effect 2.0.0-next.44 → 2.0.0-next.46

package/dist/{core-b4d7b4f5.cjs.dev.js → core-b7401357.cjs.dev.js}

@@ -5,7 +5,7 @@ var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.dev
 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-557db880.cjs.dev.js');
+var FiberId_dist_effectFiberId = require('./FiberId-d88ddce6.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');
@@ -16,10 +16,368 @@ 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-2f022879.cjs.dev.js');
-var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-ea268c50.cjs.dev.js');
+var Effectable = require('./Effectable-7314aed8.cjs.dev.js');
+var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-69102b03.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";
 
@@ -123,7 +481,7 @@ const proto = {
 // -----------------------------------------------------------------------------
 
 /** @internal */
-const empty$1 = /*#__PURE__*/(() => {
+const empty = /*#__PURE__*/(() => {
   const o = /*#__PURE__*/Object.create(proto);
   o._tag = OP_EMPTY;
   return o;
@@ -208,7 +566,7 @@ const isEmpty = self => {
   if (self._tag === OP_EMPTY) {
     return true;
   }
-  return reduce$1(self, true, (acc, cause) => {
+  return reduce(self, true, (acc, cause) => {
     switch (cause._tag) {
       case OP_EMPTY:
         {
@@ -241,13 +599,13 @@ const isInterrupted = self => Option_dist_effectOption.isSome(interruptOption(se
 const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
 
 /** @internal */
-const failures = self => Chunk_dist_effectChunk.reverse(reduce$1(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()));
+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$1(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()));
+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$1(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());
+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());
@@ -273,7 +631,7 @@ const dieOption = self => find(self, cause => cause._tag === OP_DIE ? Option_dis
 
 /** @internal */
 const flipCauseOption = self => match(self, {
-  onEmpty: Option_dist_effectOption.some(empty$1),
+  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)),
@@ -382,8 +740,8 @@ const linearize = self => match(self, {
 
 /** @internal */
 const stripFailures = self => match(self, {
-  onEmpty: empty$1,
-  onFail: () => empty$1,
+  onEmpty: empty,
+  onFail: () => empty,
   onDie: defect => die$1(defect),
   onInterrupt: fiberId => interrupt$1(fiberId),
   onSequential: sequential,
@@ -392,7 +750,7 @@ const stripFailures = self => match(self, {
 
 /** @internal */
 const electFailures = self => match(self, {
-  onEmpty: empty$1,
+  onEmpty: empty,
   onFail: failure => die$1(failure),
   onDie: defect => die$1(defect),
   onInterrupt: fiberId => interrupt$1(fiberId),
@@ -402,7 +760,7 @@ const electFailures = self => match(self, {
 
 /** @internal */
 const stripSomeDefects = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => match(self, {
-  onEmpty: Option_dist_effectOption.some(empty$1),
+  onEmpty: Option_dist_effectOption.some(empty),
   onFail: error => Option_dist_effectOption.some(fail$1(error)),
   onDie: defect => {
     const option = pf(defect);
@@ -451,7 +809,7 @@ const map$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => fla
 
 /** @internal */
 const flatMap$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => match(self, {
-  onEmpty: empty$1,
+  onEmpty: empty,
   onFail: error => f(error),
   onDie: defect => die$1(defect),
   onInterrupt: fiberId => interrupt$1(fiberId),
@@ -460,7 +818,7 @@ const flatMap$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) =>
 }));
 
 /** @internal */
-const flatten$2 = self => flatMap$1(self, Function_dist_effectFunction.identity);
+const flatten$1 = self => flatMap$1(self, Function_dist_effectFunction.identity);
 
 // -----------------------------------------------------------------------------
 // Equality
@@ -471,7 +829,7 @@ const contains = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that)
   if (that._tag === OP_EMPTY || self === that) {
     return true;
   }
-  return reduce$1(self, false, (accumulator, cause) => {
+  return reduce(self, false, (accumulator, cause) => {
     return Option_dist_effectOption.some(accumulator || causeEquals(cause, that));
   });
 });
@@ -481,11 +839,11 @@ 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$1([HashSet_dist_effectHashSet.empty(), Chunk_dist_effectChunk.empty()], ([parallel, sequential], cause) => {
+    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$1([HashSet_dist_effectHashSet.empty(), Chunk_dist_effectChunk.empty()], ([parallel, sequential], cause) => {
+    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))]);
     }));
@@ -660,806 +1018,433 @@ const evaluateCause = self => {
               {
                 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$1,
-  failCase: (_, error) => fail$1(error),
-  dieCase: (_, defect) => die$1(defect),
-  interruptCase: (_, fiberId) => interrupt$1(fiberId),
-  sequentialCase: (_, left, right) => {
-    if (predicate(left)) {
-      if (predicate(right)) {
-        return sequential(left, right);
-      }
-      return left;
-    }
-    if (predicate(right)) {
-      return right;
-    }
-    return empty$1;
-  },
-  parallelCase: (_, left, right) => {
-    if (predicate(left)) {
-      if (predicate(right)) {
-        return parallel(left, right);
-      }
-      return left;
-    }
-    if (predicate(right)) {
-      return right;
-    }
-    return empty$1;
-  }
-});
-
-/** @internal */
-
-const OP_SEQUENTIAL_CASE = "SequentialCase";
-const OP_PARALLEL_CASE = "ParallelCase";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const match = /*#__PURE__*/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$1 = /*#__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:
+              }
+            case OP_SEQUENTIAL:
               {
-                const left = accumulator.pop();
-                const right = accumulator.pop();
-                const value = reducer.sequentialCase(context, left, right);
-                accumulator.push(value);
+                cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
                 break;
               }
-            case OP_PARALLEL_CASE:
+            case OP_PARALLEL:
               {
-                const left = accumulator.pop();
-                const right = accumulator.pop();
-                const value = reducer.parallelCase(context, left, right);
-                accumulator.push(value);
+                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 "Right":
+      case OP_PARALLEL:
         {
-          accumulator.push(either.right);
+          stack.push(cause.right);
+          cause = cause.left;
           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();
-});
+  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/io/issues");
+};
 
 // -----------------------------------------------------------------------------
-// Errors
+// Reducing
 // -----------------------------------------------------------------------------
 
-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;
+const SizeCauseReducer = {
+  emptyCase: () => 0,
+  failCase: () => 1,
+  dieCase: () => 1,
+  interruptCase: () => 1,
+  sequentialCase: (_, left, right) => left + right,
+  parallelCase: (_, left, right) => left + right
 };
 
 /** @internal */
-const InvalidHubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidHubCapacityException");
-
-/** @internal */
-const InvalidHubCapacityException = /*#__PURE__*/makeException({
-  [InvalidHubCapacityExceptionTypeId]: InvalidHubCapacityExceptionTypeId
-}, "InvalidHubCapacityException");
-
-// -----------------------------------------------------------------------------
-// Pretty Printing
-// -----------------------------------------------------------------------------
-
-const filterStack = stack => {
-  const lines = stack.split("\n");
-  const out = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes("EffectPrimitive") || lines[i].includes("Generator.next") || lines[i].includes("FiberRuntime")) {
-      return out.join("\n");
-    } else {
-      out.push(lines[i]);
-    }
-  }
-  return out.join("\n");
+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 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++;
+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;
     }
-    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;
+    if (predicate(right)) {
+      return right;
     }
-    return out;
-  }
-}
-
-/**
- * A utility function for generating human-readable error messages from a generic error of type `unknown`.
- *
- * Rules:
- *
- * 1) If the input `u` is already a string, it's considered a message, and "Error" is added as a prefix.
- * 2) If `u` has a user-defined `toString()` method, it uses that method and adds "Error" as a prefix.
- * 3) If `u` is an object and its only (optional) properties are "name", "message", or "_tag", it constructs
- *    an error message based on those properties.
- * 4) Otherwise, it uses `JSON.stringify` to produce a string representation and uses it as the error message,
- *   with "Error" added as a prefix.
- *
- * @internal
- */
-const prettyErrorMessage = u => {
-  // 1)
-  if (typeof u === "string") {
-    return `Error: ${u}`;
-  }
-  // 2)
-  if (typeof u === "object" && u != null && "toString" in u && typeof u["toString"] === "function" && u["toString"] !== Object.prototype.toString) {
-    return u["toString"]();
-  }
-  // 3)
-  if (typeof u === "object" && u !== null) {
-    if ("message" in u && typeof u["message"] === "string") {
-      const raw = JSON.parse(JSON.stringify(u));
-      const keys = new Set(Object.keys(raw));
-      keys.delete("name");
-      keys.delete("message");
-      keys.delete("_tag");
-      if (keys.size === 0) {
-        const name = "name" in u && typeof u.name === "string" ? u.name : "Error";
-        const tag = "_tag" in u && typeof u["_tag"] === "string" ? `(${u._tag})` : ``;
-        return `${name}${tag}: ${u.message}`;
+    return empty;
+  },
+  parallelCase: (_, left, right) => {
+    if (predicate(left)) {
+      if (predicate(right)) {
+        return parallel(left, right);
       }
+      return left;
     }
-  }
-  // 4)
-  return `Error: ${JSON.stringify(u)}`;
-};
-const spanSymbol$1 = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
-const defaultRenderError = error => {
-  const span = typeof error === "object" && error !== null && spanSymbol$1 in error && error[spanSymbol$1];
-  if (typeof error === "object" && error !== null && error instanceof Error) {
-    return new PrettyError(prettyErrorMessage(error), error.stack?.split("\n").filter(_ => !_.startsWith("Error")).join("\n"), span);
-  }
-  return new PrettyError(prettyErrorMessage(error), void 0, span);
-};
-
-/** @internal */
-const prettyErrors = cause => reduceWithContext(cause, void 0, {
-  emptyCase: () => [],
-  dieCase: (_, unknownError) => {
-    return [defaultRenderError(unknownError)];
-  },
-  failCase: (_, error) => {
-    return [defaultRenderError(error)];
-  },
-  interruptCase: () => [],
-  parallelCase: (_, l, r) => [...l, ...r],
-  sequentialCase: (_, l, r) => [...l, ...r]
-});
-
-/** @internal */
-const empty = {
-  _tag: "Empty"
-};
-
-/**
- * Combines this collection of blocked requests with the specified collection
- * of blocked requests, in parallel.
- *
- * @internal
- */
-const par = (self, that) => ({
-  _tag: "Par",
-  left: self,
-  right: that
+    if (predicate(right)) {
+      return right;
+    }
+    return empty;
+  }
 });
 
-/**
- * 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
-});
+/** @internal */
 
-/**
- * Constructs a collection of blocked requests from the specified blocked
- * request and data source.
- *
- * @internal
- */
-const single = (dataSource, blockedRequest) => ({
-  _tag: "Single",
-  dataSource,
-  blockedRequest
-});
+const OP_SEQUENTIAL_CASE = "SequentialCase";
+const OP_PARALLEL_CASE = "ParallelCase";
 
 /** @internal */
-const MapRequestResolversReducer = f => ({
-  emptyCase: () => empty,
-  parCase: (left, right) => par(left, right),
-  seqCase: (left, right) => seq(left, right),
-  singleCase: (dataSource, blockedRequest) => single(f(dataSource), blockedRequest)
+
+/** @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)
+  });
 });
-/**
- * Transforms all data sources with the specified data source aspect, which
- * can change the environment type of data sources but must preserve the
- * request type of each data source.
- *
- * @internal
- */
-const mapRequestResolvers = (self, f) => reduce(self, MapRequestResolversReducer(f));
 
-/**
- * Folds over the cases of this collection of blocked requests with the
- * specified functions.
- *
- * @internal
- */
-const reduce = (self, reducer) => {
-  let input = 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":
+/** @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:
         {
-          output = List_dist_effectList.cons(Either_dist_effectEither.right(reducer.emptyCase()), output);
-          input = input.tail;
+          causes.push(cause.right);
+          cause = cause.left;
           break;
         }
-      case "Par":
+      case OP_PARALLEL:
         {
-          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));
+          causes.push(cause.right);
+          cause = cause.left;
           break;
         }
-      case "Seq":
+      default:
         {
-          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));
+          cause = undefined;
           break;
         }
-      case "Single":
+    }
+    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:
         {
-          const result = reducer.singleCase(current.dataSource, current.blockedRequest);
-          output = List_dist_effectList.cons(Either_dist_effectEither.right(result), output);
-          input = input.tail;
+          output.push(Either_dist_effectEither.right(reducer.emptyCase(context)));
           break;
         }
-    }
-  }
-  const result = List_dist_effectList.reduce(output, List_dist_effectList.empty(), (acc, current) => {
-    switch (current._tag) {
-      case "Left":
+      case OP_FAIL:
         {
-          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);
-              }
-          }
+          output.push(Either_dist_effectEither.right(reducer.failCase(context, cause.error)));
+          break;
         }
-      case "Right":
+      case OP_DIE:
         {
-          return List_dist_effectList.cons(current.right, acc);
+          output.push(Either_dist_effectEither.right(reducer.dieCase(context, cause.defect)));
+          break;
         }
-    }
-  });
-  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$1 = 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":
+      case OP_INTERRUPT:
         {
-          if (List_dist_effectList.isNil(stack)) {
-            return [parallel, sequential];
-          }
-          current = stack.head;
-          stack = stack.tail;
+          output.push(Either_dist_effectEither.right(reducer.interruptCase(context, cause.fiberId)));
           break;
         }
-      case "Par":
+      case OP_SEQUENTIAL:
         {
-          stack = List_dist_effectList.cons(current.right, stack);
-          current = current.left;
+          input.push(cause.right);
+          input.push(cause.left);
+          output.push(Either_dist_effectEither.left({
+            _tag: OP_SEQUENTIAL_CASE
+          }));
           break;
         }
-      case "Seq":
+      case OP_PARALLEL:
         {
-          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":
+          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 l = left.left;
-                const r = left.right;
-                current = seq(l, seq(r, right));
+                const left = accumulator.pop();
+                const right = accumulator.pop();
+                const value = reducer.sequentialCase(context, left, right);
+                accumulator.push(value);
                 break;
               }
-            case "Single":
-              {
-                current = left;
-                sequential = List_dist_effectList.cons(right, sequential);
+            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 "Single":
+      case "Right":
         {
-          parallel = parallelCollectionCombine(parallel, parallelCollectionMake(current.dataSource, current.blockedRequest));
-          if (List_dist_effectList.isNil(stack)) {
-            return [parallel, sequential];
-          }
-          current = stack.head;
-          stack = stack.tail;
+          accumulator.push(either.right);
           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);
+  if (accumulator.length === 0) {
+    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/io/issues");
   }
-  return List_dist_effectList.cons(parallelCollectionToSequentialCollection(parallel), sequential);
-};
-
-//
-// circular
-//
-
-/** @internal */
-const EntryTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/Entry");
+  return accumulator.pop();
+});
 
-/** @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;
-  }
-}
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
 
-/** @internal */
-const blockedRequestVariance = {
-  _R: _ => _
+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 isEntry = u => {
-  return typeof u === "object" && u != null && EntryTypeId in u;
-};
+const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
 
 /** @internal */
-const makeEntry = options => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state);
+const RuntimeException = /*#__PURE__*/makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
 
 /** @internal */
-const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
-const parallelVariance = {
-  _R: _ => _
+const isRuntimeException = u => {
+  return typeof u === "object" && u != null && RuntimeExceptionTypeId in u;
 };
-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]
-}))));
+const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
 
 /** @internal */
-const parallelCollectionIsEmpty = self => HashMap_dist_effectHashMap.isEmpty(self.map);
+const InterruptedException = /*#__PURE__*/makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
 
 /** @internal */
-const parallelCollectionKeys = self => Array.from(HashMap_dist_effectHashMap.keys(self.map));
+const isInterruptedException = u => {
+  return typeof u === "object" && u != null && InterruptedExceptionTypeId in u;
+};
 
 /** @internal */
-const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(HashMap_dist_effectHashMap.map(self.map, x => Array.of(x)));
+const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
 
 /** @internal */
-const SequentialCollectionTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential");
+const IllegalArgumentException = /*#__PURE__*/makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
 
 /** @internal */
-const sequentialVariance = {
-  _R: _ => _
+const isIllegalArgumentException = u => {
+  return typeof u === "object" && u != null && IllegalArgumentExceptionTypeId in u;
 };
-class SequentialImpl {
-  [SequentialCollectionTypeId] = sequentialVariance;
-  constructor(map) {
-    this.map = map;
-  }
-}
 
 /** @internal */
-const sequentialCollectionMake = map => new SequentialImpl(map);
+const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
 
 /** @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]
-}))));
+const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
 
 /** @internal */
-const sequentialCollectionKeys = self => Array.from(HashMap_dist_effectHashMap.keys(self.map));
+const isNoSuchElementException = u => {
+  return typeof u === "object" && u != null && NoSuchElementExceptionTypeId in u;
+};
 
 /** @internal */
-const sequentialCollectionToChunk = self => Array.from(self.map);
+const InvalidPubSubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
 
 /** @internal */
+const InvalidPubSubCapacityException = /*#__PURE__*/makeException({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException");
 
-/** @internal */
+// -----------------------------------------------------------------------------
+// Pretty Printing
+// -----------------------------------------------------------------------------
 
-/** @internal */
+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;
+  }
+}
 
-/** @internal */
+/**
+ * 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";
@@ -2523,9 +2508,9 @@ const isRequestResolver = u => typeof u === "object" && u != null && RequestReso
 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(self, LocallyReducer(ref, value));
+const requestBlockLocally = (self, ref, value) => reduce$1(self, LocallyReducer(ref, value));
 const LocallyReducer = (ref, value) => ({
-  emptyCase: () => empty,
+  emptyCase: () => empty$1,
   parCase: (left, right) => par(left, right),
   seqCase: (left, right) => seq(left, right),
   singleCase: (dataSource, blockedRequest) => single(resolverLocally(dataSource, ref, value), blockedRequest)
@@ -2638,8 +2623,8 @@ const currentForkScopeOverride = /*#__PURE__*/GlobalValue_dist_effectGlobalValue
 }));
 
 /** @internal */
-const currentInterruptedCause = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty$1, {
-  fork: () => empty$1,
+const currentInterruptedCause = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty, {
+  fork: () => empty,
   join: (parent, _) => parent
 }));
 
@@ -3233,8 +3218,8 @@ exports.IllegalArgumentException = IllegalArgumentException;
 exports.IllegalArgumentExceptionTypeId = IllegalArgumentExceptionTypeId;
 exports.InterruptedException = InterruptedException;
 exports.InterruptedExceptionTypeId = InterruptedExceptionTypeId;
-exports.InvalidHubCapacityException = InvalidHubCapacityException;
-exports.InvalidHubCapacityExceptionTypeId = InvalidHubCapacityExceptionTypeId;
+exports.InvalidPubSubCapacityException = InvalidPubSubCapacityException;
+exports.InvalidPubSubCapacityExceptionTypeId = InvalidPubSubCapacityExceptionTypeId;
 exports.NoSuchElementException = NoSuchElementException;
 exports.NoSuchElementExceptionTypeId = NoSuchElementExceptionTypeId;
 exports.RequestResolverImpl = RequestResolverImpl;
@@ -3245,8 +3230,8 @@ exports.RuntimeExceptionTypeId = RuntimeExceptionTypeId;
 exports.ScopeTypeId = ScopeTypeId;
 exports.acquireUseRelease = acquireUseRelease;
 exports.allLogLevels = allLogLevels;
-exports.as = as;
-exports.as$1 = as$1;
+exports.as = as$1;
+exports.as$1 = as;
 exports.asUnit = asUnit;
 exports.async = async;
 exports.asyncEither = asyncEither;
@@ -3302,8 +3287,8 @@ exports.dieMessage = dieMessage;
 exports.dieOption = dieOption;
 exports.dieSync = dieSync;
 exports.either = either;
-exports.empty = empty$1;
-exports.empty$1 = empty;
+exports.empty = empty;
+exports.empty$1 = empty$1;
 exports.exit = exit;
 exports.exitAs = exitAs;
 exports.exitAsUnit = exitAsUnit;
@@ -3340,8 +3325,8 @@ exports.exitZipParLeft = exitZipParLeft;
 exports.exitZipParRight = exitZipParRight;
 exports.exitZipRight = exitZipRight;
 exports.exitZipWith = exitZipWith;
-exports.fail = fail;
-exports.fail$1 = fail$1;
+exports.fail = fail$1;
+exports.fail$1 = fail;
 exports.failCause = failCause;
 exports.failCauseSync = failCauseSync;
 exports.failSync = failSync;
@@ -3373,19 +3358,19 @@ exports.fiberRefUpdateSome = fiberRefUpdateSome;
 exports.fiberRefUpdateSomeAndGet = fiberRefUpdateSomeAndGet;
 exports.filter = filter;
 exports.find = find;
-exports.flatMap = flatMap;
-exports.flatMap$1 = flatMap$1;
+exports.flatMap = flatMap$1;
+exports.flatMap$1 = flatMap;
 exports.flatMapStep = flatMapStep;
-exports.flatten = flatten;
-exports.flatten$1 = flatten$1;
+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;
-exports.interrupt$1 = interrupt$1;
+exports.interrupt = interrupt$1;
+exports.interrupt$1 = interrupt;
 exports.interruptAsFiber = interruptAsFiber;
 exports.interruptFiber = interruptFiber;
 exports.interruptOption = interruptOption;
@@ -3426,8 +3411,8 @@ exports.logLevelTrace = logLevelTrace;
 exports.logLevelWarning = logLevelWarning;
 exports.makeEffectError = makeEffectError;
 exports.makeEntry = makeEntry;
-exports.map = map;
-exports.map$1 = map$1;
+exports.map = map$1;
+exports.map$1 = map;
 exports.mapBoth = mapBoth;
 exports.mapError = mapError;
 exports.mapInputContext = mapInputContext;
@@ -3452,8 +3437,8 @@ exports.pretty = pretty;
 exports.prettyErrors = prettyErrors;
 exports.provideContext = provideContext;
 exports.provideSomeContext = provideSomeContext;
-exports.reduce = reduce$1;
-exports.reduce$1 = reduce;
+exports.reduce = reduce;
+exports.reduce$1 = reduce$1;
 exports.reduceWithContext = reduceWithContext;
 exports.releaseMapAdd = releaseMapAdd;
 exports.releaseMapMake = releaseMapMake;