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

package/dist/core-b4bf44d3.cjs.dev.js

@@ -0,0 +1,3572 @@
+'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-6595cf4c.cjs.dev.js');
+var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
+var GlobalValue_dist_effectGlobalValue = require('../GlobalValue/dist/effect-GlobalValue.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 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-71c10ab9.cjs.dev.js');
+var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-7d62915d.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 => {
+  return typeof u === "object" && u != null && EntryTypeId in u;
+};
+
+/** @internal */
+const makeEntry = options => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state);
+
+/** @internal */
+const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
+const parallelVariance = {
+  _R: _ => _
+};
+class ParallelImpl {
+  [RequestBlockParallelTypeId] = parallelVariance;
+  constructor(map) {
+    this.map = map;
+  }
+}
+
+/** @internal */
+const parallelCollectionEmpty = () => new ParallelImpl(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 => typeof u === "object" && u != null && CauseTypeId in u;
+
+/** @internal */
+const isEmptyType = self => self._tag === OP_EMPTY;
+
+/** @internal */
+const isFailType = self => self._tag === OP_FAIL;
+
+/** @internal */
+const isDieType = self => self._tag === OP_DIE;
+
+/** @internal */
+const isInterruptType = self => self._tag === OP_INTERRUPT;
+
+/** @internal */
+const isSequentialType = self => self._tag === OP_SEQUENTIAL;
+
+/** @internal */
+const isParallelType = self => self._tag === OP_PARALLEL;
+
+// -----------------------------------------------------------------------------
+// Getters
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const size = self => reduceWithContext(self, void 0, SizeCauseReducer);
+
+/** @internal */
+const isEmpty = self => {
+  if (self._tag === OP_EMPTY) {
+    return true;
+  }
+  return reduce(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 => {
+  return typeof u === "object" && u != null && RuntimeExceptionTypeId in u;
+};
+
+/** @internal */
+const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
+
+/** @internal */
+const InterruptedException = /*#__PURE__*/makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+
+/** @internal */
+const isInterruptedException = u => {
+  return typeof u === "object" && u != null && InterruptedExceptionTypeId in u;
+};
+
+/** @internal */
+const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
+
+/** @internal */
+const IllegalArgumentException = /*#__PURE__*/makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+
+/** @internal */
+const isIllegalArgumentException = u => {
+  return typeof u === "object" && u != null && IllegalArgumentExceptionTypeId in u;
+};
+
+/** @internal */
+const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
+
+/** @internal */
+const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+
+/** @internal */
+const isNoSuchElementException = u => {
+  return typeof u === "object" && u != null && NoSuchElementExceptionTypeId in u;
+};
+
+/** @internal */
+const 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 (typeof u === "object" && u != null && "toString" in u && typeof u["toString"] === "function" && 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 = typeof error === "object" && error !== null && spanSymbol$1 in error && error[spanSymbol$1];
+  if (typeof error === "object" && error !== null && error instanceof Error) {
+    return new PrettyError(prettyErrorMessage(error), error.stack?.split("\n").filter(_ => _.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 => typeof u === "object" && u != null && EffectErrorTypeId in u;
+
+/** @internal */
+const makeEffectError = cause => ({
+  [EffectErrorTypeId]: EffectErrorTypeId,
+  _tag: "EffectError",
+  cause
+});
+
+/**
+ * @internal
+ */
+const blocked = (blockedRequests, _continue) => {
+  const effect = new EffectPrimitive("Blocked");
+  effect.i0 = blockedRequests;
+  effect.i1 = _continue;
+  return effect;
+};
+
+/**
+ * @internal
+ */
+const runRequestBlock = blockedRequests => {
+  const effect = new EffectPrimitive("RunBlocked");
+  effect.i0 = blockedRequests;
+  return effect;
+};
+
+/** @internal */
+const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+class RevertFlags {
+  _op = 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] = 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] = 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] = 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 */
+const effectVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isEffect = u => typeof u === "object" && u != null && EffectTypeId in u;
+
+/* @internal */
+const withFiberRuntime = withRuntime => {
+  const effect = new EffectPrimitive(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 (typeof obj === "object" && obj !== null && originalSymbol in obj) {
+    // @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 => typeof defect === "object" && defect !== null && !(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 => typeof error === "object" && error !== null && !(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 => typeof u === "object" && u != null && RequestResolverTypeId in u;
+
+// 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;