effect 2.0.0-next.53 → 2.0.0-next.55

package/dist/core-908ae0ff.cjs.dev.js

@@ -1,3557 +0,0 @@
-'use strict';
-
-var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.dev.js');
-var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.dev.js');
-var Differ_dist_effectDiffer = require('../Differ/dist/effect-Differ.cjs.dev.js');
-var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.dev.js');
-var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.dev.js');
-var FiberId_dist_effectFiberId = require('./FiberId-fe3586bc.cjs.dev.js');
-var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var GlobalValue_dist_effectGlobalValue = require('./GlobalValue-871500cb.cjs.dev.js');
-var Hash_dist_effectHash = require('../Hash/dist/effect-Hash.cjs.dev.js');
-var HashMap_dist_effectHashMap = require('../HashMap/dist/effect-HashMap.cjs.dev.js');
-var HashSet_dist_effectHashSet = require('../HashSet/dist/effect-HashSet.cjs.dev.js');
-var Inspectable_dist_effectInspectable = require('../Inspectable/dist/effect-Inspectable.cjs.dev.js');
-var List_dist_effectList = require('../List/dist/effect-List.cjs.dev.js');
-var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js');
-var Predicate_dist_effectPredicate = require('../Predicate/dist/effect-Predicate.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.dev.js');
-var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
-var Effectable = require('./Effectable-ed77aaf6.cjs.dev.js');
-var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-5a4ff83e.cjs.dev.js');
-var MutableRef_dist_effectMutableRef = require('../MutableRef/dist/effect-MutableRef.cjs.dev.js');
-
-/** @internal */
-const empty$1 = {
-  _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$1,
-  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$1(self, MapRequestResolversReducer(f));
-
-/**
- * Folds over the cases of this collection of blocked requests with the
- * specified functions.
- *
- * @internal
- */
-const reduce$1 = (self, reducer) => {
-  let input = List_dist_effectList.of(self);
-  let output = List_dist_effectList.empty();
-  while (List_dist_effectList.isCons(input)) {
-    const current = input.head;
-    switch (current._tag) {
-      case "Empty":
-        {
-          output = List_dist_effectList.cons(Either_dist_effectEither.right(reducer.emptyCase()), output);
-          input = input.tail;
-          break;
-        }
-      case "Par":
-        {
-          output = List_dist_effectList.cons(Either_dist_effectEither.left({
-            _tag: "ParCase"
-          }), output);
-          input = List_dist_effectList.cons(current.left, List_dist_effectList.cons(current.right, input.tail));
-          break;
-        }
-      case "Seq":
-        {
-          output = List_dist_effectList.cons(Either_dist_effectEither.left({
-            _tag: "SeqCase"
-          }), output);
-          input = List_dist_effectList.cons(current.left, List_dist_effectList.cons(current.right, input.tail));
-          break;
-        }
-      case "Single":
-        {
-          const result = reducer.singleCase(current.dataSource, current.blockedRequest);
-          output = List_dist_effectList.cons(Either_dist_effectEither.right(result), output);
-          input = input.tail;
-          break;
-        }
-    }
-  }
-  const result = List_dist_effectList.reduce(output, List_dist_effectList.empty(), (acc, current) => {
-    switch (current._tag) {
-      case "Left":
-        {
-          const left = List_dist_effectList.unsafeHead(acc);
-          const right = List_dist_effectList.unsafeHead(List_dist_effectList.unsafeTail(acc));
-          const tail = List_dist_effectList.unsafeTail(List_dist_effectList.unsafeTail(acc));
-          switch (current.left._tag) {
-            case "ParCase":
-              {
-                return List_dist_effectList.cons(reducer.parCase(left, right), tail);
-              }
-            case "SeqCase":
-              {
-                return List_dist_effectList.cons(reducer.seqCase(left, right), tail);
-              }
-          }
-        }
-      case "Right":
-        {
-          return List_dist_effectList.cons(current.right, acc);
-        }
-    }
-  });
-  if (List_dist_effectList.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$2 = self => {
-  let current = List_dist_effectList.of(self);
-  let updated = List_dist_effectList.empty();
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = List_dist_effectList.reduce(current, [parallelCollectionEmpty(), List_dist_effectList.empty()], ([parallel, sequential], blockedRequest) => {
-      const [par, seq] = step$1(blockedRequest);
-      return [parallelCollectionCombine(parallel, par), List_dist_effectList.appendAll(sequential, seq)];
-    });
-    updated = merge(updated, parallel);
-    if (List_dist_effectList.isNil(sequential)) {
-      return List_dist_effectList.reverse(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 = List_dist_effectList.empty();
-  let sequential = List_dist_effectList.empty();
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    switch (current._tag) {
-      case "Empty":
-        {
-          if (List_dist_effectList.isNil(stack)) {
-            return [parallel, sequential];
-          }
-          current = stack.head;
-          stack = stack.tail;
-          break;
-        }
-      case "Par":
-        {
-          stack = List_dist_effectList.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 = List_dist_effectList.cons(right, sequential);
-                break;
-              }
-          }
-          break;
-        }
-      case "Single":
-        {
-          parallel = parallelCollectionCombine(parallel, parallelCollectionMake(current.dataSource, current.blockedRequest));
-          if (List_dist_effectList.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 (List_dist_effectList.isNil(sequential)) {
-    return List_dist_effectList.of(parallelCollectionToSequentialCollection(parallel));
-  }
-  if (parallelCollectionIsEmpty(parallel)) {
-    return sequential;
-  }
-  const seqHeadKeys = sequentialCollectionKeys(sequential.head);
-  const parKeys = parallelCollectionKeys(parallel);
-  if (seqHeadKeys.length === 1 && parKeys.length === 1 && Equal_dist_effectEqual.equals(seqHeadKeys[0], parKeys[0])) {
-    return List_dist_effectList.cons(sequentialCollectionCombine(sequential.head, parallelCollectionToSequentialCollection(parallel)), sequential.tail);
-  }
-  return List_dist_effectList.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 => Predicate_dist_effectPredicate.hasProperty(u, EntryTypeId);
-
-/** @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(HashMap_dist_effectHashMap.empty());
-
-/** @internal */
-const parallelCollectionMake = (dataSource, blockedRequest) => new ParallelImpl(HashMap_dist_effectHashMap.make([dataSource, Array.of(blockedRequest)]));
-
-/** @internal */
-const parallelCollectionCombine = (self, that) => new ParallelImpl(HashMap_dist_effectHashMap.reduce(self.map, that.map, (map, value, key) => HashMap_dist_effectHashMap.set(map, key, Option_dist_effectOption.match(HashMap_dist_effectHashMap.get(map, key), {
-  onNone: () => value,
-  onSome: a => [...a, ...value]
-}))));
-
-/** @internal */
-const parallelCollectionIsEmpty = self => HashMap_dist_effectHashMap.isEmpty(self.map);
-
-/** @internal */
-const parallelCollectionKeys = self => Array.from(HashMap_dist_effectHashMap.keys(self.map));
-
-/** @internal */
-const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(HashMap_dist_effectHashMap.map(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(HashMap_dist_effectHashMap.reduce(that.map, self.map, (map, value, key) => HashMap_dist_effectHashMap.set(map, key, Option_dist_effectOption.match(HashMap_dist_effectHashMap.get(map, key), {
-  onNone: () => [],
-  onSome: a => [...a, ...value]
-}))));
-
-/** @internal */
-const sequentialCollectionKeys = self => Array.from(HashMap_dist_effectHashMap.keys(self.map));
-
-/** @internal */
-const sequentialCollectionToChunk = self => Array.from(self.map);
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @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,
-  [Hash_dist_effectHash.symbol]() {
-    return Function_dist_effectFunction.pipe(Hash_dist_effectHash.hash(CauseSymbolKey), Hash_dist_effectHash.combine(Hash_dist_effectHash.hash(flattenCause(this))));
-  },
-  [Equal_dist_effectEqual.symbol](that) {
-    return isCause(that) && causeEquals(this, that);
-  },
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  },
-  toJSON() {
-    switch (this._tag) {
-      case "Empty":
-        return {
-          _id: "Cause",
-          _tag: this._tag
-        };
-      case "Die":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          defect: Inspectable_dist_effectInspectable.toJSON(this.defect)
-        };
-      case "Interrupt":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          fiberId: this.fiberId.toJSON()
-        };
-      case "Fail":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          failure: Inspectable_dist_effectInspectable.toJSON(this.error)
-        };
-      case "Sequential":
-      case "Parallel":
-        return {
-          _id: "Cause",
-          _tag: this._tag,
-          left: Inspectable_dist_effectInspectable.toJSON(this.left),
-          right: Inspectable_dist_effectInspectable.toJSON(this.right)
-        };
-    }
-  },
-  toString() {
-    return pretty(this);
-  },
-  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-};
-
-// -----------------------------------------------------------------------------
-// Constructors
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const empty = /*#__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 => Predicate_dist_effectPredicate.hasProperty(u, CauseTypeId);
-
-/** @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(self, true, (acc, cause) => {
-    switch (cause._tag) {
-      case OP_EMPTY:
-        {
-          return Option_dist_effectOption.some(acc);
-        }
-      case OP_DIE:
-      case OP_FAIL:
-      case OP_INTERRUPT:
-        {
-          return Option_dist_effectOption.some(false);
-        }
-      default:
-        {
-          return Option_dist_effectOption.none();
-        }
-    }
-  });
-};
-
-/** @internal */
-const isFailure = self => Option_dist_effectOption.isSome(failureOption(self));
-
-/** @internal */
-const isDie = self => Option_dist_effectOption.isSome(dieOption(self));
-
-/** @internal */
-const isInterrupted = self => Option_dist_effectOption.isSome(interruptOption(self));
-
-/** @internal */
-const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
-
-/** @internal */
-const failures = self => Chunk_dist_effectChunk.reverse(reduce(self, Chunk_dist_effectChunk.empty(), (list, cause) => cause._tag === OP_FAIL ? Option_dist_effectOption.some(Function_dist_effectFunction.pipe(list, Chunk_dist_effectChunk.prepend(cause.error))) : Option_dist_effectOption.none()));
-
-/** @internal */
-const defects = self => Chunk_dist_effectChunk.reverse(reduce(self, Chunk_dist_effectChunk.empty(), (list, cause) => cause._tag === OP_DIE ? Option_dist_effectOption.some(Function_dist_effectFunction.pipe(list, Chunk_dist_effectChunk.prepend(cause.defect))) : Option_dist_effectOption.none()));
-
-/** @internal */
-const interruptors = self => reduce(self, HashSet_dist_effectHashSet.empty(), (set, cause) => cause._tag === OP_INTERRUPT ? Option_dist_effectOption.some(Function_dist_effectFunction.pipe(set, HashSet_dist_effectHashSet.add(cause.fiberId))) : Option_dist_effectOption.none());
-
-/** @internal */
-const failureOption = self => find(self, cause => cause._tag === OP_FAIL ? Option_dist_effectOption.some(cause.error) : Option_dist_effectOption.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 Either_dist_effectEither.right(self);
-      }
-    case "Some":
-      {
-        return Either_dist_effectEither.left(option.value);
-      }
-  }
-};
-
-/** @internal */
-const dieOption = self => find(self, cause => cause._tag === OP_DIE ? Option_dist_effectOption.some(cause.defect) : Option_dist_effectOption.none());
-
-/** @internal */
-const flipCauseOption = self => match(self, {
-  onEmpty: Option_dist_effectOption.some(empty),
-  onFail: failureOption => Function_dist_effectFunction.pipe(failureOption, Option_dist_effectOption.map(fail$1)),
-  onDie: defect => Option_dist_effectOption.some(die$1(defect)),
-  onInterrupt: fiberId => Option_dist_effectOption.some(interrupt$1(fiberId)),
-  onSequential: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(sequential(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    return Option_dist_effectOption.none();
-  },
-  onParallel: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(parallel(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    return Option_dist_effectOption.none();
-  }
-});
-
-/** @internal */
-const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? Option_dist_effectOption.some(cause.fiberId) : Option_dist_effectOption.none());
-
-/** @internal */
-const keepDefects = self => match(self, {
-  onEmpty: Option_dist_effectOption.none(),
-  onFail: () => Option_dist_effectOption.none(),
-  onDie: defect => Option_dist_effectOption.some(die$1(defect)),
-  onInterrupt: () => Option_dist_effectOption.none(),
-  onSequential: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(sequential(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  },
-  onParallel: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(parallel(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  }
-});
-
-/** @internal */
-const keepDefectsAndElectFailures = self => match(self, {
-  onEmpty: Option_dist_effectOption.none(),
-  onFail: failure => Option_dist_effectOption.some(die$1(failure)),
-  onDie: defect => Option_dist_effectOption.some(die$1(defect)),
-  onInterrupt: () => Option_dist_effectOption.none(),
-  onSequential: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(sequential(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  },
-  onParallel: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(parallel(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  }
-});
-
-/** @internal */
-const linearize = self => match(self, {
-  onEmpty: HashSet_dist_effectHashSet.empty(),
-  onFail: error => HashSet_dist_effectHashSet.make(fail$1(error)),
-  onDie: defect => HashSet_dist_effectHashSet.make(die$1(defect)),
-  onInterrupt: fiberId => HashSet_dist_effectHashSet.make(interrupt$1(fiberId)),
-  onSequential: (leftSet, rightSet) => Function_dist_effectFunction.pipe(leftSet, HashSet_dist_effectHashSet.flatMap(leftCause => Function_dist_effectFunction.pipe(rightSet, HashSet_dist_effectHashSet.map(rightCause => sequential(leftCause, rightCause))))),
-  onParallel: (leftSet, rightSet) => Function_dist_effectFunction.pipe(leftSet, HashSet_dist_effectHashSet.flatMap(leftCause => Function_dist_effectFunction.pipe(rightSet, HashSet_dist_effectHashSet.map(rightCause => parallel(leftCause, rightCause)))))
-});
-
-/** @internal */
-const stripFailures = self => match(self, {
-  onEmpty: empty,
-  onFail: () => empty,
-  onDie: defect => die$1(defect),
-  onInterrupt: fiberId => interrupt$1(fiberId),
-  onSequential: sequential,
-  onParallel: parallel
-});
-
-/** @internal */
-const electFailures = self => match(self, {
-  onEmpty: empty,
-  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__*/Function_dist_effectFunction.dual(2, (self, pf) => match(self, {
-  onEmpty: Option_dist_effectOption.some(empty),
-  onFail: error => Option_dist_effectOption.some(fail$1(error)),
-  onDie: defect => {
-    const option = pf(defect);
-    return Option_dist_effectOption.isSome(option) ? Option_dist_effectOption.none() : Option_dist_effectOption.some(die$1(defect));
-  },
-  onInterrupt: fiberId => Option_dist_effectOption.some(interrupt$1(fiberId)),
-  onSequential: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(sequential(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  },
-  onParallel: (left, right) => {
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(parallel(left.value, right.value));
-    }
-    if (Option_dist_effectOption.isSome(left) && Option_dist_effectOption.isNone(right)) {
-      return Option_dist_effectOption.some(left.value);
-    }
-    if (Option_dist_effectOption.isNone(left) && Option_dist_effectOption.isSome(right)) {
-      return Option_dist_effectOption.some(right.value);
-    }
-    return Option_dist_effectOption.none();
-  }
-}));
-
-// -----------------------------------------------------------------------------
-// Mapping
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const as$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => map$1(self, () => error));
-
-/** @internal */
-const map$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap$1(self, e => fail$1(f(e))));
-
-// -----------------------------------------------------------------------------
-// Sequencing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const flatMap$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => match(self, {
-  onEmpty: empty,
-  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$1 = self => flatMap$1(self, Function_dist_effectFunction.identity);
-
-// -----------------------------------------------------------------------------
-// Equality
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const contains = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
-  if (that._tag === OP_EMPTY || self === that) {
-    return true;
-  }
-  return reduce(self, false, (accumulator, cause) => {
-    return Option_dist_effectOption.some(accumulator || causeEquals(cause, that));
-  });
-});
-
-/** @internal */
-const causeEquals = (left, right) => {
-  let leftStack = Chunk_dist_effectChunk.of(left);
-  let rightStack = Chunk_dist_effectChunk.of(right);
-  while (Chunk_dist_effectChunk.isNonEmpty(leftStack) && Chunk_dist_effectChunk.isNonEmpty(rightStack)) {
-    const [leftParallel, leftSequential] = Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.headNonEmpty(leftStack), reduce([HashSet_dist_effectHashSet.empty(), Chunk_dist_effectChunk.empty()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return Option_dist_effectOption.some([Function_dist_effectFunction.pipe(parallel, HashSet_dist_effectHashSet.union(par)), Function_dist_effectFunction.pipe(sequential, Chunk_dist_effectChunk.appendAll(seq))]);
-    }));
-    const [rightParallel, rightSequential] = Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.headNonEmpty(rightStack), reduce([HashSet_dist_effectHashSet.empty(), Chunk_dist_effectChunk.empty()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return Option_dist_effectOption.some([Function_dist_effectFunction.pipe(parallel, HashSet_dist_effectHashSet.union(par)), Function_dist_effectFunction.pipe(sequential, Chunk_dist_effectChunk.appendAll(seq))]);
-    }));
-    if (!Equal_dist_effectEqual.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(Chunk_dist_effectChunk.of(cause), Chunk_dist_effectChunk.empty());
-};
-
-/** @internal */
-const flattenCauseLoop = (causes, flattened) => {
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = Function_dist_effectFunction.pipe(causes, ReadonlyArray_dist_effectReadonlyArray.reduce([HashSet_dist_effectHashSet.empty(), Chunk_dist_effectChunk.empty()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return [Function_dist_effectFunction.pipe(parallel, HashSet_dist_effectHashSet.union(par)), Function_dist_effectFunction.pipe(sequential, Chunk_dist_effectChunk.appendAll(seq))];
-    }));
-    const updated = HashSet_dist_effectHashSet.size(parallel) > 0 ? Function_dist_effectFunction.pipe(flattened, Chunk_dist_effectChunk.prepend(parallel)) : flattened;
-    if (Chunk_dist_effectChunk.isEmpty(sequential)) {
-      return Chunk_dist_effectChunk.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(Function_dist_effectFunction.identity)(self);
-};
-
-/** @internal */
-const squashWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const option = Function_dist_effectFunction.pipe(self, failureOption, Option_dist_effectOption.map(f));
-  switch (option._tag) {
-    case "None":
-      {
-        return Function_dist_effectFunction.pipe(defects(self), Chunk_dist_effectChunk.head, Option_dist_effectOption.match({
-          onNone: () => {
-            const interrupts = Array.from(interruptors(self)).flatMap(fiberId => Array.from(FiberId_dist_effectFiberId.ids(fiberId)).map(id => `#${id}`));
-            return InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0);
-          },
-          onSome: Function_dist_effectFunction.identity
-        }));
-      }
-    case "Some":
-      {
-        return option.value;
-      }
-  }
-});
-
-// -----------------------------------------------------------------------------
-// Finding
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const find = /*#__PURE__*/Function_dist_effectFunction.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 Option_dist_effectOption.none();
-});
-
-// -----------------------------------------------------------------------------
-// Filtering
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const filter = /*#__PURE__*/Function_dist_effectFunction.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 = HashSet_dist_effectHashSet.empty();
-  let _sequential = Chunk_dist_effectChunk.empty();
-  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 [Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.add(cause.error)), _sequential];
-          }
-          _parallel = Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.add(cause.error));
-          cause = stack.pop();
-          break;
-        }
-      case OP_DIE:
-        {
-          if (stack.length === 0) {
-            return [Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.add(cause.defect)), _sequential];
-          }
-          _parallel = Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.add(cause.defect));
-          cause = stack.pop();
-          break;
-        }
-      case OP_INTERRUPT:
-        {
-          if (stack.length === 0) {
-            return [Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.add(cause.fiberId)), _sequential];
-          }
-          _parallel = Function_dist_effectFunction.pipe(_parallel, HashSet_dist_effectHashSet.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 = Function_dist_effectFunction.pipe(_sequential, Chunk_dist_effectChunk.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: Function_dist_effectFunction.constTrue,
-  failCase: Function_dist_effectFunction.constFalse,
-  dieCase: Function_dist_effectFunction.constFalse,
-  interruptCase: Function_dist_effectFunction.constTrue,
-  sequentialCase: (_, left, right) => left && right,
-  parallelCase: (_, left, right) => left && right
-};
-
-/** @internal */
-const FilterCauseReducer = predicate => ({
-  emptyCase: () => empty,
-  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;
-  },
-  parallelCase: (_, left, right) => {
-    if (predicate(left)) {
-      if (predicate(right)) {
-        return parallel(left, right);
-      }
-      return left;
-    }
-    if (predicate(right)) {
-      return right;
-    }
-    return empty;
-  }
-});
-
-/** @internal */
-
-const OP_SEQUENTIAL_CASE = "SequentialCase";
-const OP_PARALLEL_CASE = "ParallelCase";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const match = /*#__PURE__*/Function_dist_effectFunction.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 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, pf) => {
-  let accumulator = zero;
-  let cause = self;
-  const causes = [];
-  while (cause !== undefined) {
-    const option = pf(accumulator, cause);
-    accumulator = Option_dist_effectOption.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__*/Function_dist_effectFunction.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(Either_dist_effectEither.right(reducer.emptyCase(context)));
-          break;
-        }
-      case OP_FAIL:
-        {
-          output.push(Either_dist_effectEither.right(reducer.failCase(context, cause.error)));
-          break;
-        }
-      case OP_DIE:
-        {
-          output.push(Either_dist_effectEither.right(reducer.dieCase(context, cause.defect)));
-          break;
-        }
-      case OP_INTERRUPT:
-        {
-          output.push(Either_dist_effectEither.right(reducer.interruptCase(context, cause.fiberId)));
-          break;
-        }
-      case OP_SEQUENTIAL:
-        {
-          input.push(cause.right);
-          input.push(cause.left);
-          output.push(Either_dist_effectEither.left({
-            _tag: OP_SEQUENTIAL_CASE
-          }));
-          break;
-        }
-      case OP_PARALLEL:
-        {
-          input.push(cause.right);
-          input.push(cause.left);
-          output.push(Either_dist_effectEither.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 => Predicate_dist_effectPredicate.hasProperty(u, RuntimeExceptionTypeId);
-
-/** @internal */
-const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
-
-/** @internal */
-const InterruptedException = /*#__PURE__*/makeException({
-  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
-}, "InterruptedException");
-
-/** @internal */
-const isInterruptedException = u => Predicate_dist_effectPredicate.hasProperty(u, InterruptedExceptionTypeId);
-
-/** @internal */
-const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
-
-/** @internal */
-const IllegalArgumentException = /*#__PURE__*/makeException({
-  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
-}, "IllegalArgumentException");
-
-/** @internal */
-const isIllegalArgumentException = u => Predicate_dist_effectPredicate.hasProperty(u, IllegalArgumentExceptionTypeId);
-
-/** @internal */
-const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
-
-/** @internal */
-const NoSuchElementException = /*#__PURE__*/makeException({
-  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
-}, "NoSuchElementException");
-
-/** @internal */
-const isNoSuchElementException = u => Predicate_dist_effectPredicate.hasProperty(u, NoSuchElementExceptionTypeId);
-
-/** @internal */
-const InvalidPubSubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
-
-/** @internal */
-const InvalidPubSubCapacityException = /*#__PURE__*/makeException({
-  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
-}, "InvalidPubSubCapacityException");
-
-// -----------------------------------------------------------------------------
-// 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 = Option_dist_effectOption.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 (Predicate_dist_effectPredicate.hasProperty(u, "toString") && Predicate_dist_effectPredicate.isFunction(u["toString"]) && u["toString"] !== Object.prototype.toString) {
-    return u["toString"]();
-  }
-  // 3)
-  return `Error: ${JSON.stringify(u)}`;
-};
-const spanSymbol$1 = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
-const defaultRenderError = error => {
-  const span = Predicate_dist_effectPredicate.hasProperty(error, spanSymbol$1) && error[spanSymbol$1];
-  if (error instanceof Error) {
-    return new PrettyError(prettyErrorMessage(error), error.stack?.split("\n").filter(_ => _.match(/at (.*)/)).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 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
-  };
-};
-
-/**
- * @since 2.0.0
- */
-/** @internal */
-const TracerTypeId = /*#__PURE__*/Symbol.for("effect/Tracer");
-
-/** @internal */
-const make = options => ({
-  [TracerTypeId]: TracerTypeId,
-  ...options
-});
-
-/** @internal */
-const tracerTag = /*#__PURE__*/Context_dist_effectContext.Tag( /*#__PURE__*/Symbol.for("effect/Tracer"));
-
-/** @internal */
-const spanTag = /*#__PURE__*/Context_dist_effectContext.Tag( /*#__PURE__*/Symbol.for("effect/ParentSpan"));
-const ids = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue("effect/Tracer/SpanId.ids", () => MutableRef_dist_effectMutableRef.make(0));
-
-/** @internal */
-class NativeSpan {
-  _tag = "Span";
-  traceId = "native";
-  sampled = true;
-  events = [];
-  constructor(name, parent, context, links, startTime) {
-    this.name = name;
-    this.parent = parent;
-    this.context = context;
-    this.links = links;
-    this.startTime = startTime;
-    this.status = {
-      _tag: "Started",
-      startTime
-    };
-    this.attributes = new Map();
-    this.spanId = `span${MutableRef_dist_effectMutableRef.incrementAndGet(ids)}`;
-  }
-  end = (endTime, exit) => {
-    this.status = {
-      _tag: "Ended",
-      endTime,
-      exit,
-      startTime: this.status.startTime
-    };
-  };
-  attribute = (key, value) => {
-    this.attributes.set(key, value);
-  };
-  event = (name, startTime, attributes) => {
-    this.events.push([name, startTime, attributes ?? {}]);
-  };
-}
-
-/** @internal */
-const nativeTracer = /*#__PURE__*/make({
-  span: (name, parent, context, links, startTime) => new NativeSpan(name, parent, context, links, startTime),
-  context: f => f()
-});
-
-/** @internal */
-const externalSpan = options => ({
-  _tag: "ExternalSpan",
-  spanId: options.spanId,
-  traceId: options.traceId,
-  sampled: options.sampled ?? true,
-  context: options.context ?? Context_dist_effectContext.empty()
-});
-
-// -----------------------------------------------------------------------------
-// Effect
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const EffectErrorSymbolKey = "effect/EffectError";
-
-/** @internal */
-const EffectErrorTypeId = /*#__PURE__*/Symbol.for(EffectErrorSymbolKey);
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const isEffectError = u => Predicate_dist_effectPredicate.hasProperty(u, EffectErrorTypeId);
-
-/** @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 = Effectable.OP_REVERT_FLAGS;
-  constructor(patch, op) {
-    this.patch = patch;
-    this.op = op;
-  }
-}
-
-/** @internal */
-class EffectPrimitive {
-  i0 = undefined;
-  i1 = undefined;
-  i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = Effectable.effectVariance;
-  constructor(_op) {
-    this._op = _op;
-  }
-  [Equal_dist_effectEqual.symbol](that) {
-    return this === that;
-  }
-  [Hash_dist_effectHash.symbol]() {
-    return Hash_dist_effectHash.random(this);
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Effect",
-      _op: this._op,
-      i0: Inspectable_dist_effectInspectable.toJSON(this.i0),
-      i1: Inspectable_dist_effectInspectable.toJSON(this.i1),
-      i2: Inspectable_dist_effectInspectable.toJSON(this.i2)
-    };
-  }
-  toString() {
-    return Inspectable_dist_effectInspectable.toString(this.toJSON());
-  }
-  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-}
-
-/** @internal */
-class EffectPrimitiveFailure {
-  i0 = undefined;
-  i1 = undefined;
-  i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = Effectable.effectVariance;
-  constructor(_op) {
-    this._op = _op;
-    // @ts-expect-error
-    this._tag = _op;
-  }
-  [Equal_dist_effectEqual.symbol](that) {
-    return this === that;
-  }
-  [Hash_dist_effectHash.symbol]() {
-    return Hash_dist_effectHash.random(this);
-  }
-  get cause() {
-    return this.i0;
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Exit",
-      _tag: this._op,
-      cause: this.cause.toJSON()
-    };
-  }
-  toString() {
-    return Inspectable_dist_effectInspectable.toString(this.toJSON());
-  }
-  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-}
-
-/** @internal */
-class EffectPrimitiveSuccess {
-  i0 = undefined;
-  i1 = undefined;
-  i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = Effectable.effectVariance;
-  constructor(_op) {
-    this._op = _op;
-    // @ts-expect-error
-    this._tag = _op;
-  }
-  [Equal_dist_effectEqual.symbol](that) {
-    return this === that;
-  }
-  [Hash_dist_effectHash.symbol]() {
-    return Hash_dist_effectHash.random(this);
-  }
-  get value() {
-    return this.i0;
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Exit",
-      _tag: this._op,
-      value: Inspectable_dist_effectInspectable.toJSON(this.value)
-    };
-  }
-  toString() {
-    return Inspectable_dist_effectInspectable.toString(this.toJSON());
-  }
-  [Inspectable_dist_effectInspectable.NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-}
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const isEffect = u => Predicate_dist_effectPredicate.hasProperty(u, EffectTypeId);
-
-/* @internal */
-const withFiberRuntime = withRuntime => {
-  const effect = new EffectPrimitive(Effectable.OP_WITH_RUNTIME);
-  effect.i0 = withRuntime;
-  return effect;
-};
-
-/* @internal */
-const acquireUseRelease = /*#__PURE__*/Function_dist_effectFunction.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 Effectable.OP_FAILURE:
-          {
-            return failCause(parallel(flat.i0, cause));
-          }
-        case Effectable.OP_SUCCESS:
-          {
-            return failCause(cause);
-          }
-      }
-    },
-    onSuccess: () => flat
-  }));
-}))));
-
-/* @internal */
-const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => flatMap(self, () => succeed(value)));
-
-/* @internal */
-const asUnit = self => as(self, void 0);
-
-/* @internal */
-const async = (register, blockingOn = FiberId_dist_effectFiberId.none) => suspend(() => {
-  let cancelerRef = undefined;
-  let controllerRef = undefined;
-  const effect = new EffectPrimitive(Effectable.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 = FiberId_dist_effectFiberId.none) => async(resume => {
-  const result = register(resume);
-  if (Either_dist_effectEither.isRight(result)) {
-    resume(result.right);
-  } else {
-    return result.left;
-  }
-}, blockingOn);
-
-/* @internal */
-const catchAllCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const effect = new EffectPrimitive(Effectable.OP_ON_FAILURE);
-  effect.i0 = self;
-  effect.i1 = f;
-  return effect;
-});
-
-/* @internal */
-const catchAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => matchEffect(self, {
-  onFailure: f,
-  onSuccess: succeed
-}));
-
-/**
- * @macro identity
- * @internal
- */
-const unified = f => (...args) => f(...args);
-
-/* @internal */
-const catchIf = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, pf) => catchAllCause(self, cause => {
-  const either = failureOrCause(cause);
-  switch (either._tag) {
-    case "Left":
-      {
-        return Function_dist_effectFunction.pipe(pf(either.left), Option_dist_effectOption.getOrElse(() => failCause(cause)));
-      }
-    case "Right":
-      {
-        return failCause(either.right);
-      }
-  }
-}));
-
-/* @internal */
-const checkInterruptible = f => withFiberRuntime((_, status) => f(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruption(status.runtimeFlags)));
-const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
-const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
-
-/* @internal */
-const originalInstance = obj => {
-  if (Predicate_dist_effectPredicate.hasProperty(obj, originalSymbol)) {
-    // @ts-expect-error
-    return obj[originalSymbol];
-  }
-  return obj;
-};
-
-/* @internal */
-const capture = (obj, span) => {
-  if (Option_dist_effectOption.isSome(span)) {
-    return new Proxy(obj, {
-      has(target, p) {
-        return p === spanSymbol || p === originalSymbol || p in target;
-      },
-      get(target, p) {
-        if (p === spanSymbol) {
-          return span.value;
-        }
-        if (p === originalSymbol) {
-          return obj;
-        }
-        // @ts-expect-error
-        return target[p];
-      }
-    });
-  }
-  return obj;
-};
-
-/* @internal */
-const die = defect => Predicate_dist_effectPredicate.isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause(die$1(capture(defect, currentSpanFromFiber(fiber))))) : 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(Either_dist_effectEither.left(e)),
-  onSuccess: a => succeed(Either_dist_effectEither.right(a))
-});
-
-/* @internal */
-const exit = self => matchCause(self, {
-  onFailure: exitFailCause,
-  onSuccess: exitSucceed
-});
-
-/* @internal */
-const fail = error => Predicate_dist_effectPredicate.isObject(error) && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause(fail$1(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail$1(error));
-
-/* @internal */
-const failSync = evaluate => flatMap(sync(evaluate), fail);
-
-/* @internal */
-const failCause = cause => {
-  const effect = new EffectPrimitiveFailure(Effectable.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__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const effect = new EffectPrimitive(Effectable.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, Function_dist_effectFunction.identity);
-
-/* @internal */
-const flip = self => matchEffect(self, {
-  onFailure: succeed,
-  onSuccess: fail
-});
-
-/* @internal */
-const matchCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => matchCauseEffect(self, {
-  onFailure: cause => succeed(onFailure(cause)),
-  onSuccess: a => succeed(onSuccess(a))
-}));
-
-/* @internal */
-const matchCauseEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  const effect = new EffectPrimitive(Effectable.OP_ON_SUCCESS_AND_FAILURE);
-  effect.i0 = self;
-  effect.i1 = onFailure;
-  effect.i2 = onSuccess;
-  return effect;
-});
-
-/* @internal */
-const matchEffect = /*#__PURE__*/Function_dist_effectFunction.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(Chunk_dist_effectChunk.unsafeHead(failures$1));
-    }
-    return failCause(cause);
-  },
-  onSuccess
-}));
-
-/* @internal */
-const forEachSequential = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => suspend(() => {
-  const arr = ReadonlyArray_dist_effectReadonlyArray.fromIterable(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__*/Function_dist_effectFunction.dual(2, (self, f) => suspend(() => {
-  const arr = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
-  let i = 0;
-  return whileLoop({
-    while: () => i < arr.length,
-    body: () => f(arr[i], i),
-    step: () => {
-      i++;
-    }
-  });
-}));
-
-/* @internal */
-const if_ = /*#__PURE__*/Function_dist_effectFunction.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(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.enable(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.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(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.enable(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.Interruption);
-  const _continue = step => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, interruptible(step.i1));
-    }
-    return step;
-  };
-  effect.i1 = oldFlags => RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruption(oldFlags) ? step(f(interruptible)) : step(f(uninterruptible));
-  return flatMap(effect, _continue);
-};
-
-/* @internal */
-const intoDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => uninterruptibleMask(restore => flatMap(exit(restore(self)), exit => deferredDone(deferred, exit))));
-
-/* @internal */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap(self, a => sync(() => f(a))));
-
-/* @internal */
-const mapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => matchEffect(self, {
-  onFailure: e => failSync(() => onFailure(e)),
-  onSuccess: a => sync(() => onSuccess(a))
-}));
-
-/* @internal */
-const mapError = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, cleanup) => onExit(self, unified(exit => exitIsSuccess(exit) ? unit : cleanup(exit.i0))));
-
-/* @internal */
-const onExit = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, cleanup) => onExit(self, exitMatch({
-  onFailure: cause => isInterruptedOnly(cause) ? asUnit(cleanup(interruptors(cause))) : unit,
-  onSuccess: () => unit
-})));
-
-/* @internal */
-const orElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => attemptOrElse(self, that, succeed));
-
-/* @internal */
-const orDie = self => orDieWith(self, Function_dist_effectFunction.identity);
-
-/* @internal */
-const orDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => matchEffect(self, {
-  onFailure: e => die(f(e)),
-  onSuccess: succeed
-}));
-
-/* @internal */
-const partitionMap = (elements, f) => ReadonlyArray_dist_effectReadonlyArray.fromIterable(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 runtimeFlags = /*#__PURE__*/withFiberRuntime((_, status) => succeed(status.runtimeFlags));
-
-/* @internal */
-const succeed = value => {
-  const effect = new EffectPrimitiveSuccess(Effectable.OP_SUCCESS);
-  effect.i0 = value;
-  return effect;
-};
-
-/* @internal */
-const suspend = effect => flatMap(sync(effect), Function_dist_effectFunction.identity);
-
-/* @internal */
-const sync = evaluate => {
-  const effect = new EffectPrimitive(Effectable.OP_SYNC);
-  effect.i0 = evaluate;
-  return effect;
-};
-
-/* @internal */
-const tap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap(self, a => as(f(a), a)));
-
-/* @internal */
-const transplant = f => withFiberRuntime(state => {
-  const scopeOverride = state.getFiberRef(currentForkScopeOverride);
-  const scope = Function_dist_effectFunction.pipe(scopeOverride, Option_dist_effectOption.getOrElse(() => state.scope()));
-  return f(fiberRefLocally(currentForkScopeOverride, Option_dist_effectOption.some(scope)));
-});
-
-/* @internal */
-const attemptOrElse = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, onSuccess) => matchCauseEffect(self, {
-  onFailure: cause => {
-    const defects$1 = defects(cause);
-    if (defects$1.length > 0) {
-      return failCause(Option_dist_effectOption.getOrThrow(keepDefectsAndElectFailures(cause)));
-    }
-    return that();
-  },
-  onSuccess
-}));
-
-/* @internal */
-const uninterruptible = self => {
-  const effect = new EffectPrimitive(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.disable(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.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(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.disable(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.Interruption);
-  const _continue = step => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, uninterruptible(step.i1));
-    }
-    return step;
-  };
-  effect.i1 = oldFlags => RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.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(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = patch;
-  effect.i1 = void 0;
-  return effect;
-};
-
-/* @internal */
-const whenEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => flatMap(predicate, b => {
-  if (b) {
-    return Function_dist_effectFunction.pipe(self, map(Option_dist_effectOption.some));
-  }
-  return succeed(Option_dist_effectOption.none());
-}));
-
-/* @internal */
-const whileLoop = options => {
-  const effect = new EffectPrimitive(Effectable.OP_WHILE);
-  effect.i0 = options.while;
-  effect.i1 = options.body;
-  effect.i2 = options.step;
-  return effect;
-};
-
-/* @internal */
-const withConcurrency = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, concurrency) => fiberRefLocally(self, currentConcurrency, concurrency));
-
-/* @internal */
-const withRequestBatching = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, requestBatching) => fiberRefLocally(self, currentRequestBatching, requestBatching));
-
-/* @internal */
-const withRuntimeFlags = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, update) => {
-  const effect = new EffectPrimitive(Effectable.OP_UPDATE_RUNTIME_FLAGS);
-  effect.i0 = update;
-  effect.i1 = () => self;
-  return effect;
-});
-
-/** @internal */
-const withTracerTiming = /*#__PURE__*/Function_dist_effectFunction.dual(2, (effect, enabled) => fiberRefLocally(effect, currentTracerTimingEnabled, enabled));
-
-/* @internal */
-const yieldNow = options => {
-  const effect = new EffectPrimitive(Effectable.OP_YIELD);
-  return typeof options?.priority !== "undefined" ? withSchedulingPriority(options.priority)(effect) : effect;
-};
-
-/* @internal */
-const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => flatMap(self, a => map(that, b => [a, b])));
-
-/* @internal */
-const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => flatMap(self, a => as(that, a)));
-
-/* @internal */
-const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => flatMap(self, () => that));
-
-/* @internal */
-const zipWith = /*#__PURE__*/Function_dist_effectFunction.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 Either_dist_effectEither.left(sync(() => clearInterval(interval)));
-});
-
-// -----------------------------------------------------------------------------
-// Fiber
-// -----------------------------------------------------------------------------
-
-/* @internal */
-const interruptFiber = self => flatMap(fiberId, fiberId => Function_dist_effectFunction.pipe(self, interruptAsFiber(fiberId)));
-
-/* @internal */
-const interruptAsFiber = /*#__PURE__*/Function_dist_effectFunction.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 Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelFatal = {
-  _tag: "Fatal",
-  syslog: 2,
-  label: "FATAL",
-  ordinal: 50000,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelError = {
-  _tag: "Error",
-  syslog: 3,
-  label: "ERROR",
-  ordinal: 40000,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelWarning = {
-  _tag: "Warning",
-  syslog: 4,
-  label: "WARN",
-  ordinal: 30000,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelInfo = {
-  _tag: "Info",
-  syslog: 6,
-  label: "INFO",
-  ordinal: 20000,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelDebug = {
-  _tag: "Debug",
-  syslog: 7,
-  label: "DEBUG",
-  ordinal: 10000,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelTrace = {
-  _tag: "Trace",
-  syslog: 7,
-  label: "TRACE",
-  ordinal: 0,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const logLevelNone = {
-  _tag: "None",
-  syslog: 7,
-  label: "OFF",
-  ordinal: Number.MAX_SAFE_INTEGER,
-  pipe() {
-    return Pipeable_dist_effectPipeable.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__*/Function_dist_effectFunction.dual(2, (self, value) => fiberRefModify(self, v => [v, value]));
-
-/* @internal */
-const fiberRefGetAndUpdate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => fiberRefModify(self, v => [v, f(v)]));
-
-/* @internal */
-const fiberRefGetAndUpdateSome = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => fiberRefModify(self, v => [v, Option_dist_effectOption.getOrElse(pf(v), () => v)]));
-
-/* @internal */
-const fiberRefGetWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap(fiberRefGet(self), f));
-
-/* @internal */
-const fiberRefSet = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.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 => Option_dist_effectOption.getOrElse(f(v), () => [def, v]));
-
-/* @internal */
-const fiberRefUpdate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => fiberRefModify(self, v => [void 0, f(v)]));
-
-/* @internal */
-const fiberRefUpdateSome = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => fiberRefModify(self, v => [void 0, Option_dist_effectOption.getOrElse(pf(v), () => v)]));
-
-/* @internal */
-const fiberRefUpdateAndGet = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => fiberRefModify(self, v => {
-  const result = f(v);
-  return [result, result];
-}));
-
-/* @internal */
-const fiberRefUpdateSomeAndGet = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => fiberRefModify(self, v => {
-  const result = Option_dist_effectOption.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;
-  }
-  [Hash_dist_effectHash.symbol]() {
-    return this.target ? Hash_dist_effectHash.hash(this.target) : Hash_dist_effectHash.random(this);
-  }
-  [Equal_dist_effectEqual.symbol](that) {
-    return this.target ? isRequestResolver(that) && Equal_dist_effectEqual.equals(this.target, that.target) : this === that;
-  }
-  identified(...ids) {
-    return new RequestResolverImpl(this.runAll, Chunk_dist_effectChunk.fromIterable(ids));
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const isRequestResolver = u => Predicate_dist_effectPredicate.hasProperty(u, RequestResolverTypeId);
-
-// end
-
-/** @internal */
-const resolverLocally = /*#__PURE__*/Function_dist_effectFunction.dual(3, (use, self, value) => new RequestResolverImpl(requests => fiberRefLocally(use.runAll(requests), self, value), Chunk_dist_effectChunk.make("Locally", use, self, value)));
-
-/** @internal */
-const requestBlockLocally = (self, ref, value) => reduce$1(self, LocallyReducer(ref, value));
-const LocallyReducer = (ref, value) => ({
-  emptyCase: () => empty$1,
-  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__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(3, (use, self, f) => fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))));
-
-/** @internal */
-const fiberRefUnsafeMake = (initial, options) => fiberRefUnsafeMakePatch(initial, {
-  differ: Differ_dist_effectDiffer.update(),
-  fork: options?.fork ?? Function_dist_effectFunction.identity,
-  join: options?.join
-});
-
-/** @internal */
-const fiberRefUnsafeMakeHashSet = initial => {
-  const differ = Differ_dist_effectDiffer.hashSet();
-  return fiberRefUnsafeMakePatch(initial, {
-    differ,
-    fork: differ.empty
-  });
-};
-
-/** @internal */
-const fiberRefUnsafeMakeContext = initial => {
-  const differ = Differ_dist_effectDiffer.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 Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-});
-
-/** @internal */
-const fiberRefUnsafeMakeRuntimeFlags = initial => fiberRefUnsafeMakePatch(initial, {
-  differ: RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.differ,
-  fork: RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.differ.empty
-});
-
-/** @internal */
-const currentContext = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(Context_dist_effectContext.empty()));
-
-/** @internal */
-const currentSchedulingPriority = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentSchedulingPriority"), () => fiberRefUnsafeMake(0));
-
-/** @internal */
-const currentMaxOpsBeforeYield = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentMaxOpsBeforeYield"), () => fiberRefUnsafeMake(2048));
-
-/** @internal */
-const currentLogAnnotations = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogAnnotation"), () => fiberRefUnsafeMake(HashMap_dist_effectHashMap.empty()));
-
-/** @internal */
-const currentLogLevel = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogLevel"), () => fiberRefUnsafeMake(logLevelInfo));
-
-/** @internal */
-const currentLogSpan = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(List_dist_effectList.empty()));
-
-/** @internal */
-const withSchedulingPriority = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
-
-/** @internal */
-const withMaxOpsBeforeYield = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, scheduler) => fiberRefLocally(self, currentMaxOpsBeforeYield, scheduler));
-
-/** @internal */
-const currentConcurrency = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentConcurrency"), () => fiberRefUnsafeMake("unbounded"));
-
-/**
- * @internal
- */
-const currentRequestBatching = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestBatching"), () => fiberRefUnsafeMake(true));
-
-/** @internal */
-const currentUnhandledErrorLogLevel = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"), () => fiberRefUnsafeMake(Option_dist_effectOption.some(logLevelDebug)));
-
-/** @internal */
-const withUnhandledErrorLogLevel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, level) => fiberRefLocally(self, currentUnhandledErrorLogLevel, level));
-
-/** @internal */
-const currentMetricLabels = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeHashSet(HashSet_dist_effectHashSet.empty()));
-
-/* @internal */
-const metricLabels = /*#__PURE__*/fiberRefGet(currentMetricLabels);
-
-/** @internal */
-const currentForkScopeOverride = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(Option_dist_effectOption.none(), {
-  fork: () => Option_dist_effectOption.none(),
-  join: (parent, _) => parent
-}));
-
-/** @internal */
-const currentInterruptedCause = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty, {
-  fork: () => empty,
-  join: (parent, _) => parent
-}));
-
-/** @internal */
-const currentTracerTimingEnabled = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerTiming"), () => fiberRefUnsafeMake(true));
-
-/** @internal */
-const currentTracerSpanAnnotations = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"), () => fiberRefUnsafeMake(HashMap_dist_effectHashMap.empty()));
-
-/** @internal */
-const currentTracerSpanLinks = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpanLinks"), () => fiberRefUnsafeMake(Chunk_dist_effectChunk.empty()));
-
-// -----------------------------------------------------------------------------
-// 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__*/Function_dist_effectFunction.dual(2, (self, finalizer) => map(releaseMapAddIfOpen(self, finalizer), Option_dist_effectOption.match({
-  onNone: () => () => unit,
-  onSome: key => exit => releaseMapRelease(key, exit)(self)
-})));
-
-/* @internal */
-const releaseMapRelease = /*#__PURE__*/Function_dist_effectFunction.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__*/Function_dist_effectFunction.dual(2, (self, finalizer) => suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        self.state.nextKey += 1;
-        return as(finalizer(self.state.exit), Option_dist_effectOption.none());
-      }
-    case "Running":
-      {
-        const key = self.state.nextKey;
-        self.state.finalizers.set(key, finalizer);
-        self.state.nextKey += 1;
-        return succeed(Option_dist_effectOption.some(key));
-      }
-  }
-}));
-
-/* @internal */
-const releaseMapMake = /*#__PURE__*/sync(() => ({
-  state: {
-    _tag: "Running",
-    nextKey: 0,
-    finalizers: new Map(),
-    update: Function_dist_effectFunction.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 Effectable.OP_FAILURE:
-      {
-        return isInterrupted(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return false;
-      }
-  }
-};
-
-/** @internal */
-const exitAs = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return exitSucceed(value);
-      }
-  }
-});
-
-/** @internal */
-const exitAsUnit = self => exitAs(self, void 0);
-
-/** @internal */
-const exitCauseOption = self => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return Option_dist_effectOption.some(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return Option_dist_effectOption.none();
-      }
-  }
-};
-
-/** @internal */
-const exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel : sequential);
-
-/** @internal */
-const exitDie = defect => exitFailCause(die$1(defect));
-
-/** @internal */
-const exitExists = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return false;
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return predicate(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitFail = error => exitFailCause(fail$1(error));
-
-/** @internal */
-const exitFailCause = cause => {
-  const effect = new EffectPrimitiveFailure(Effectable.OP_FAILURE);
-  effect.i0 = cause;
-  return effect;
-};
-
-/** @internal */
-const exitFlatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return f(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitFlatMapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return succeed(exitFailCause(self.i0));
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return f(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitFlatten = self => Function_dist_effectFunction.pipe(self, exitFlatMap(Function_dist_effectFunction.identity));
-
-/** @internal */
-const exitForEachEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return succeed(exitFailCause(self.i0));
-      }
-    case Effectable.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__*/Function_dist_effectFunction.dual(2, (self, orElse) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return orElse(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return self.i0;
-      }
-  }
-});
-
-/** @internal */
-const exitInterrupt = fiberId => exitFailCause(interrupt$1(fiberId));
-
-/** @internal */
-const exitMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return exitSucceed(f(self.i0));
-      }
-  }
-});
-
-/** @internal */
-const exitMapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(Function_dist_effectFunction.pipe(self.i0, map$1(onFailure)));
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return exitSucceed(onSuccess(self.i0));
-      }
-  }
-});
-
-/** @internal */
-const exitMapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(Function_dist_effectFunction.pipe(self.i0, map$1(f)));
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return exitSucceed(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitMapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return exitFailCause(f(self.i0));
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return exitSucceed(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitMatch = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return onFailure(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return onSuccess(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitMatchEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        return onFailure(self.i0);
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        return onSuccess(self.i0);
-      }
-  }
-});
-
-/** @internal */
-const exitSucceed = value => {
-  const effect = new EffectPrimitiveSuccess(Effectable.OP_SUCCESS);
-  effect.i0 = value;
-  return effect;
-};
-
-/** @internal */
-const exitUnit = /*#__PURE__*/exitSucceed(void 0);
-
-/** @internal */
-const exitZip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (a, a2) => [a, a2],
-  onFailure: sequential
-}));
-
-/** @internal */
-const exitZipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (a, _) => a,
-  onFailure: sequential
-}));
-
-/** @internal */
-const exitZipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (_, a2) => a2,
-  onFailure: sequential
-}));
-
-/** @internal */
-const exitZipPar = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (a, a2) => [a, a2],
-  onFailure: parallel
-}));
-
-/** @internal */
-const exitZipParLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (a, _) => a,
-  onFailure: parallel
-}));
-
-/** @internal */
-const exitZipParRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (_, a2) => a2,
-  onFailure: parallel
-}));
-
-/** @internal */
-const exitZipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case Effectable.OP_FAILURE:
-      {
-        switch (that._tag) {
-          case Effectable.OP_SUCCESS:
-            {
-              return exitFailCause(self.i0);
-            }
-          case Effectable.OP_FAILURE:
-            {
-              return exitFailCause(onFailure(self.i0, that.i0));
-            }
-        }
-      }
-    case Effectable.OP_SUCCESS:
-      {
-        switch (that._tag) {
-          case Effectable.OP_SUCCESS:
-            {
-              return exitSucceed(onSuccess(self.i0, that.i0));
-            }
-          case Effectable.OP_FAILURE:
-            {
-              return exitFailCause(that.i0);
-            }
-        }
-      }
-  }
-});
-const exitCollectAllInternal = (exits, combineCauses) => {
-  const list = Chunk_dist_effectChunk.fromIterable(exits);
-  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
-    return Option_dist_effectOption.none();
-  }
-  return Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.tailNonEmpty(list), ReadonlyArray_dist_effectReadonlyArray.reduce(Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.headNonEmpty(list), exitMap(Chunk_dist_effectChunk.of)), (accumulator, current) => Function_dist_effectFunction.pipe(accumulator, exitZipWith(current, {
-    onSuccess: (list, value) => Function_dist_effectFunction.pipe(list, Chunk_dist_effectChunk.prepend(value)),
-    onFailure: combineCauses
-  }))), exitMap(Chunk_dist_effectChunk.reverse), exitMap(chunk => Array.from(chunk)), Option_dist_effectOption.some);
-};
-
-// -----------------------------------------------------------------------------
-// Deferred
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const deferredUnsafeMake = fiberId => ({
-  [DeferredTypeId]: deferredVariance,
-  state: MutableRef_dist_effectMutableRef.make(pending([])),
-  blockingOn: fiberId,
-  pipe() {
-    return Pipeable_dist_effectPipeable.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 = MutableRef_dist_effectMutableRef.get(self.state);
-  switch (state._tag) {
-    case OP_STATE_DONE:
-      {
-        return Either_dist_effectEither.right(state.effect);
-      }
-    case OP_STATE_PENDING:
-      {
-        Function_dist_effectFunction.pipe(self.state, MutableRef_dist_effectMutableRef.set(pending([k, ...state.joiners])));
-        return Either_dist_effectEither.left(deferredInterruptJoiner(self, k));
-      }
-  }
-}, self.blockingOn);
-
-/* @internal */
-const deferredComplete = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => intoDeferred(effect, self));
-
-/* @internal */
-const deferredCompleteWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => sync(() => {
-  const state = MutableRef_dist_effectMutableRef.get(self.state);
-  switch (state._tag) {
-    case OP_STATE_DONE:
-      {
-        return false;
-      }
-    case OP_STATE_PENDING:
-      {
-        Function_dist_effectFunction.pipe(self.state, MutableRef_dist_effectMutableRef.set(done(effect)));
-        for (let i = 0; i < state.joiners.length; i++) {
-          state.joiners[i](effect);
-        }
-        return true;
-      }
-  }
-}));
-
-/* @internal */
-const deferredDone = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, exit) => deferredCompleteWith(self, exit));
-
-/* @internal */
-const deferredFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => deferredCompleteWith(self, fail(error)));
-
-/* @internal */
-const deferredFailSync = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => deferredCompleteWith(self, failSync(evaluate)));
-
-/* @internal */
-const deferredFailCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cause) => deferredCompleteWith(self, failCause(cause)));
-
-/* @internal */
-const deferredFailCauseSync = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => deferredCompleteWith(self, failCauseSync(evaluate)));
-
-/* @internal */
-const deferredDie = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, defect) => deferredCompleteWith(self, die(defect)));
-
-/* @internal */
-const deferredDieSync = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => deferredCompleteWith(self, dieSync(evaluate)));
-
-/* @internal */
-const deferredInterrupt = self => flatMap(fiberId, fiberId => deferredCompleteWith(self, interruptWith(fiberId)));
-
-/* @internal */
-const deferredInterruptWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, fiberId) => deferredCompleteWith(self, interruptWith(fiberId)));
-
-/* @internal */
-const deferredIsDone = self => sync(() => MutableRef_dist_effectMutableRef.get(self.state)._tag === OP_STATE_DONE);
-
-/* @internal */
-const deferredPoll = self => sync(() => {
-  const state = MutableRef_dist_effectMutableRef.get(self.state);
-  switch (state._tag) {
-    case OP_STATE_DONE:
-      {
-        return Option_dist_effectOption.some(state.effect);
-      }
-    case OP_STATE_PENDING:
-      {
-        return Option_dist_effectOption.none();
-      }
-  }
-});
-
-/* @internal */
-const deferredSucceed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => deferredCompleteWith(self, succeed(value)));
-
-/* @internal */
-const deferredSync = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, evaluate) => deferredCompleteWith(self, sync(evaluate)));
-
-/** @internal */
-const deferredUnsafeDone = (self, effect) => {
-  const state = MutableRef_dist_effectMutableRef.get(self.state);
-  if (state._tag === OP_STATE_PENDING) {
-    Function_dist_effectFunction.pipe(self.state, MutableRef_dist_effectMutableRef.set(done(effect)));
-    for (let i = state.joiners.length - 1; i >= 0; i--) {
-      state.joiners[i](effect);
-    }
-  }
-};
-const deferredInterruptJoiner = (self, joiner) => sync(() => {
-  const state = MutableRef_dist_effectMutableRef.get(self.state);
-  if (state._tag === OP_STATE_PENDING) {
-    Function_dist_effectFunction.pipe(self.state, MutableRef_dist_effectMutableRef.set(pending(state.joiners.filter(j => j !== joiner))));
-  }
-});
-
-// -----------------------------------------------------------------------------
-// Context
-// -----------------------------------------------------------------------------
-
-const constContext = /*#__PURE__*/fiberRefGet(currentContext);
-
-/* @internal */
-const context = () => constContext;
-
-/* @internal */
-const contextWithEffect = f => flatMap(context(), f);
-
-/* @internal */
-const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => fiberRefLocally(currentContext, context)(self));
-
-/* @internal */
-const provideSomeContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => fiberRefLocallyWith(currentContext, parent => Context_dist_effectContext.merge(parent, context))(self));
-
-/* @internal */
-const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => contextWithEffect(context => provideContext(self, f(context))));
-
-// -----------------------------------------------------------------------------
-// Tracing
-// -----------------------------------------------------------------------------
-
-/** @internal */
-const currentSpanFromFiber = fiber => {
-  const span = fiber.getFiberRef(currentContext).unsafeMap.get(spanTag);
-  return span !== undefined && span._tag === "Span" ? Option_dist_effectOption.some(span) : Option_dist_effectOption.none();
-};
-
-exports.CauseTypeId = CauseTypeId;
-exports.CloseableScopeTypeId = CloseableScopeTypeId;
-exports.DeferredTypeId = DeferredTypeId;
-exports.EffectTypeId = EffectTypeId;
-exports.FiberRefTypeId = FiberRefTypeId;
-exports.IllegalArgumentException = IllegalArgumentException;
-exports.IllegalArgumentExceptionTypeId = IllegalArgumentExceptionTypeId;
-exports.InterruptedException = InterruptedException;
-exports.InterruptedExceptionTypeId = InterruptedExceptionTypeId;
-exports.InvalidPubSubCapacityException = InvalidPubSubCapacityException;
-exports.InvalidPubSubCapacityExceptionTypeId = InvalidPubSubCapacityExceptionTypeId;
-exports.NoSuchElementException = NoSuchElementException;
-exports.NoSuchElementExceptionTypeId = NoSuchElementExceptionTypeId;
-exports.RequestResolverImpl = RequestResolverImpl;
-exports.RequestResolverTypeId = RequestResolverTypeId;
-exports.RevertFlags = RevertFlags;
-exports.RuntimeException = RuntimeException;
-exports.RuntimeExceptionTypeId = RuntimeExceptionTypeId;
-exports.ScopeTypeId = ScopeTypeId;
-exports.TracerTypeId = TracerTypeId;
-exports.acquireUseRelease = acquireUseRelease;
-exports.allLogLevels = allLogLevels;
-exports.as = as$1;
-exports.as$1 = as;
-exports.asUnit = asUnit;
-exports.async = async;
-exports.asyncEither = asyncEither;
-exports.blocked = blocked;
-exports.catchAll = catchAll;
-exports.catchAllCause = catchAllCause;
-exports.catchIf = catchIf;
-exports.catchSome = catchSome;
-exports.checkInterruptible = checkInterruptible;
-exports.contains = contains;
-exports.context = context;
-exports.contextWithEffect = contextWithEffect;
-exports.currentConcurrency = currentConcurrency;
-exports.currentContext = currentContext;
-exports.currentForkScopeOverride = currentForkScopeOverride;
-exports.currentInterruptedCause = currentInterruptedCause;
-exports.currentLogAnnotations = currentLogAnnotations;
-exports.currentLogLevel = currentLogLevel;
-exports.currentLogSpan = currentLogSpan;
-exports.currentMaxOpsBeforeYield = currentMaxOpsBeforeYield;
-exports.currentMetricLabels = currentMetricLabels;
-exports.currentRequestBatching = currentRequestBatching;
-exports.currentSchedulingPriority = currentSchedulingPriority;
-exports.currentTracerSpanAnnotations = currentTracerSpanAnnotations;
-exports.currentTracerSpanLinks = currentTracerSpanLinks;
-exports.currentTracerTimingEnabled = currentTracerTimingEnabled;
-exports.currentUnhandledErrorLogLevel = currentUnhandledErrorLogLevel;
-exports.defects = defects;
-exports.deferredAwait = deferredAwait;
-exports.deferredComplete = deferredComplete;
-exports.deferredCompleteWith = deferredCompleteWith;
-exports.deferredDie = deferredDie;
-exports.deferredDieSync = deferredDieSync;
-exports.deferredDone = deferredDone;
-exports.deferredFail = deferredFail;
-exports.deferredFailCause = deferredFailCause;
-exports.deferredFailCauseSync = deferredFailCauseSync;
-exports.deferredFailSync = deferredFailSync;
-exports.deferredInterrupt = deferredInterrupt;
-exports.deferredInterruptWith = deferredInterruptWith;
-exports.deferredIsDone = deferredIsDone;
-exports.deferredMake = deferredMake;
-exports.deferredMakeAs = deferredMakeAs;
-exports.deferredPoll = deferredPoll;
-exports.deferredSucceed = deferredSucceed;
-exports.deferredSync = deferredSync;
-exports.deferredUnsafeDone = deferredUnsafeDone;
-exports.deferredUnsafeMake = deferredUnsafeMake;
-exports.die = die$1;
-exports.die$1 = die;
-exports.dieMessage = dieMessage;
-exports.dieOption = dieOption;
-exports.dieSync = dieSync;
-exports.either = either;
-exports.empty = empty;
-exports.empty$1 = empty$1;
-exports.exit = exit;
-exports.exitAs = exitAs;
-exports.exitAsUnit = exitAsUnit;
-exports.exitCauseOption = exitCauseOption;
-exports.exitCollectAll = exitCollectAll;
-exports.exitDie = exitDie;
-exports.exitExists = exitExists;
-exports.exitFail = exitFail;
-exports.exitFailCause = exitFailCause;
-exports.exitFlatMap = exitFlatMap;
-exports.exitFlatMapEffect = exitFlatMapEffect;
-exports.exitFlatten = exitFlatten;
-exports.exitForEachEffect = exitForEachEffect;
-exports.exitFromEither = exitFromEither;
-exports.exitFromOption = exitFromOption;
-exports.exitGetOrElse = exitGetOrElse;
-exports.exitInterrupt = exitInterrupt;
-exports.exitIsExit = exitIsExit;
-exports.exitIsFailure = exitIsFailure;
-exports.exitIsInterrupted = exitIsInterrupted;
-exports.exitIsSuccess = exitIsSuccess;
-exports.exitMap = exitMap;
-exports.exitMapBoth = exitMapBoth;
-exports.exitMapError = exitMapError;
-exports.exitMapErrorCause = exitMapErrorCause;
-exports.exitMatch = exitMatch;
-exports.exitMatchEffect = exitMatchEffect;
-exports.exitSucceed = exitSucceed;
-exports.exitUnit = exitUnit;
-exports.exitZip = exitZip;
-exports.exitZipLeft = exitZipLeft;
-exports.exitZipPar = exitZipPar;
-exports.exitZipParLeft = exitZipParLeft;
-exports.exitZipParRight = exitZipParRight;
-exports.exitZipRight = exitZipRight;
-exports.exitZipWith = exitZipWith;
-exports.externalSpan = externalSpan;
-exports.fail = fail$1;
-exports.fail$1 = fail;
-exports.failCause = failCause;
-exports.failCauseSync = failCauseSync;
-exports.failSync = failSync;
-exports.failureOption = failureOption;
-exports.failureOrCause = failureOrCause;
-exports.failures = failures;
-exports.fiberId = fiberId;
-exports.fiberIdWith = fiberIdWith;
-exports.fiberRefDelete = fiberRefDelete;
-exports.fiberRefGet = fiberRefGet;
-exports.fiberRefGetAndSet = fiberRefGetAndSet;
-exports.fiberRefGetAndUpdate = fiberRefGetAndUpdate;
-exports.fiberRefGetAndUpdateSome = fiberRefGetAndUpdateSome;
-exports.fiberRefGetWith = fiberRefGetWith;
-exports.fiberRefLocally = fiberRefLocally;
-exports.fiberRefLocallyWith = fiberRefLocallyWith;
-exports.fiberRefModify = fiberRefModify;
-exports.fiberRefModifySome = fiberRefModifySome;
-exports.fiberRefReset = fiberRefReset;
-exports.fiberRefSet = fiberRefSet;
-exports.fiberRefUnsafeMake = fiberRefUnsafeMake;
-exports.fiberRefUnsafeMakeContext = fiberRefUnsafeMakeContext;
-exports.fiberRefUnsafeMakeHashSet = fiberRefUnsafeMakeHashSet;
-exports.fiberRefUnsafeMakePatch = fiberRefUnsafeMakePatch;
-exports.fiberRefUnsafeMakeRuntimeFlags = fiberRefUnsafeMakeRuntimeFlags;
-exports.fiberRefUpdate = fiberRefUpdate;
-exports.fiberRefUpdateAndGet = fiberRefUpdateAndGet;
-exports.fiberRefUpdateSome = fiberRefUpdateSome;
-exports.fiberRefUpdateSomeAndGet = fiberRefUpdateSomeAndGet;
-exports.filter = filter;
-exports.find = find;
-exports.flatMap = flatMap$1;
-exports.flatMap$1 = flatMap;
-exports.flatMapStep = flatMapStep;
-exports.flatten = flatten$1;
-exports.flatten$1 = flatten;
-exports.flatten$2 = flatten$2;
-exports.flip = flip;
-exports.flipCauseOption = flipCauseOption;
-exports.forEachSequential = forEachSequential;
-exports.forEachSequentialDiscard = forEachSequentialDiscard;
-exports.if_ = if_;
-exports.interrupt = interrupt$1;
-exports.interrupt$1 = interrupt;
-exports.interruptAsFiber = interruptAsFiber;
-exports.interruptFiber = interruptFiber;
-exports.interruptOption = interruptOption;
-exports.interruptWith = interruptWith;
-exports.interruptible = interruptible;
-exports.interruptibleMask = interruptibleMask;
-exports.interruptors = interruptors;
-exports.intoDeferred = intoDeferred;
-exports.isCause = isCause;
-exports.isDie = isDie;
-exports.isDieType = isDieType;
-exports.isEffect = isEffect;
-exports.isEffectError = isEffectError;
-exports.isEmpty = isEmpty;
-exports.isEmptyType = isEmptyType;
-exports.isEntry = isEntry;
-exports.isFailType = isFailType;
-exports.isFailure = isFailure;
-exports.isIllegalArgumentException = isIllegalArgumentException;
-exports.isInterruptType = isInterruptType;
-exports.isInterrupted = isInterrupted;
-exports.isInterruptedException = isInterruptedException;
-exports.isInterruptedOnly = isInterruptedOnly;
-exports.isNoSuchElementException = isNoSuchElementException;
-exports.isParallelType = isParallelType;
-exports.isRequestResolver = isRequestResolver;
-exports.isRuntimeException = isRuntimeException;
-exports.isSequentialType = isSequentialType;
-exports.keepDefects = keepDefects;
-exports.linearize = linearize;
-exports.logLevelAll = logLevelAll;
-exports.logLevelDebug = logLevelDebug;
-exports.logLevelError = logLevelError;
-exports.logLevelFatal = logLevelFatal;
-exports.logLevelInfo = logLevelInfo;
-exports.logLevelNone = logLevelNone;
-exports.logLevelTrace = logLevelTrace;
-exports.logLevelWarning = logLevelWarning;
-exports.make = make;
-exports.makeEffectError = makeEffectError;
-exports.makeEntry = makeEntry;
-exports.map = map$1;
-exports.map$1 = map;
-exports.mapBoth = mapBoth;
-exports.mapError = mapError;
-exports.mapInputContext = mapInputContext;
-exports.mapRequestResolvers = mapRequestResolvers;
-exports.match = match;
-exports.matchCause = matchCause;
-exports.matchCauseEffect = matchCauseEffect;
-exports.matchEffect = matchEffect;
-exports.metricLabels = metricLabels;
-exports.nativeTracer = nativeTracer;
-exports.never = never;
-exports.onError = onError;
-exports.onExit = onExit;
-exports.onInterrupt = onInterrupt;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse;
-exports.originalInstance = originalInstance;
-exports.par = par;
-exports.parallel = parallel;
-exports.partitionMap = partitionMap;
-exports.pretty = pretty;
-exports.prettyErrors = prettyErrors;
-exports.provideContext = provideContext;
-exports.provideSomeContext = provideSomeContext;
-exports.reduce = reduce;
-exports.reduce$1 = reduce$1;
-exports.reduceWithContext = reduceWithContext;
-exports.releaseMapAdd = releaseMapAdd;
-exports.releaseMapMake = releaseMapMake;
-exports.requestBlockLocally = requestBlockLocally;
-exports.resolverLocally = resolverLocally;
-exports.runRequestBlock = runRequestBlock;
-exports.runtimeFlags = runtimeFlags;
-exports.scopeAddFinalizer = scopeAddFinalizer;
-exports.scopeAddFinalizerExit = scopeAddFinalizerExit;
-exports.scopeClose = scopeClose;
-exports.scopeFork = scopeFork;
-exports.seq = seq;
-exports.sequential = sequential;
-exports.sequentialCollectionToChunk = sequentialCollectionToChunk;
-exports.single = single;
-exports.size = size;
-exports.spanTag = spanTag;
-exports.squash = squash;
-exports.squashWith = squashWith;
-exports.step = step;
-exports.stripFailures = stripFailures;
-exports.stripSomeDefects = stripSomeDefects;
-exports.succeed = succeed;
-exports.suspend = suspend;
-exports.sync = sync;
-exports.tap = tap;
-exports.tracerTag = tracerTag;
-exports.transplant = transplant;
-exports.unified = unified;
-exports.uninterruptible = uninterruptible;
-exports.uninterruptibleMask = uninterruptibleMask;
-exports.unit = unit;
-exports.updateRuntimeFlags = updateRuntimeFlags;
-exports.whenEffect = whenEffect;
-exports.whileLoop = whileLoop;
-exports.withConcurrency = withConcurrency;
-exports.withFiberRuntime = withFiberRuntime;
-exports.withMaxOpsBeforeYield = withMaxOpsBeforeYield;
-exports.withRequestBatching = withRequestBatching;
-exports.withRuntimeFlags = withRuntimeFlags;
-exports.withSchedulingPriority = withSchedulingPriority;
-exports.withTracerTiming = withTracerTiming;
-exports.withUnhandledErrorLogLevel = withUnhandledErrorLogLevel;
-exports.yieldNow = yieldNow;
-exports.zip = zip;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;