effect 2.0.0-next.38 → 2.0.0-next.39

package/internal/cause.esm.js

@@ -0,0 +1,1067 @@
+import { reverse, empty as empty$1, prepend, of, isNonEmpty, appendAll, headNonEmpty, head, isEmpty as isEmpty$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { left, right } from '../Either/dist/effect-Either.esm.js';
+import { equals, symbol as symbol$1 } from '../Equal/dist/effect-Equal.esm.js';
+import { ids } from '../FiberId/dist/effect-FiberId.esm.js';
+import { pipe, dual, identity, constTrue, constFalse } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash } from '../Hash/dist/effect-Hash.esm.js';
+import { empty as empty$2, add, make, flatMap as flatMap$1, map as map$2, union, size as size$1 } from '../HashSet/dist/effect-HashSet.esm.js';
+import { toJSON, NodeInspectSymbol } from '../Inspectable/dist/effect-Inspectable.esm.js';
+import { none, some, isSome, map as map$1, isNone, match as match$1, getOrUndefined } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { reduce as reduce$1 } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { OP_EMPTY, OP_FAIL, OP_DIE, OP_INTERRUPT, OP_PARALLEL, OP_SEQUENTIAL } from './opCodes/cause.esm.js';
+
+// -----------------------------------------------------------------------------
+// Models
+// -----------------------------------------------------------------------------
+/** @internal */
+const CauseSymbolKey = "effect/Cause";
+
+/** @internal */
+const CauseTypeId = /*#__PURE__*/Symbol.for(CauseSymbolKey);
+
+/** @internal */
+const variance = {
+  _E: _ => _
+};
+
+/** @internal */
+const proto = {
+  [CauseTypeId]: variance,
+  [symbol]() {
+    return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))));
+  },
+  [symbol$1](that) {
+    return isCause(that) && causeEquals(this, that);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  toJSON() {
+    switch (this._tag) {
+      case "Empty":
+        return {
+          _id: "Cause",
+          _tag: this._tag
+        };
+      case "Die":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          defect: toJSON(this.defect)
+        };
+      case "Interrupt":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          fiberId: this.fiberId.toJSON()
+        };
+      case "Fail":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          failure: toJSON(this.error)
+        };
+      case "Sequential":
+      case "Parallel":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          errors: toJSON(prettyErrors(this))
+        };
+    }
+  },
+  toString() {
+    return pretty(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+
+// -----------------------------------------------------------------------------
+// Constructors
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const empty = /*#__PURE__*/(() => {
+  const o = /*#__PURE__*/Object.create(proto);
+  o._tag = OP_EMPTY;
+  return o;
+})();
+
+/** @internal */
+const fail = error => {
+  const o = Object.create(proto);
+  o._tag = OP_FAIL;
+  o.error = error;
+  return o;
+};
+
+/** @internal */
+const die = defect => {
+  const o = Object.create(proto);
+  o._tag = OP_DIE;
+  o.defect = defect;
+  return o;
+};
+
+/** @internal */
+const interrupt = 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 some(acc);
+        }
+      case OP_DIE:
+      case OP_FAIL:
+      case OP_INTERRUPT:
+        {
+          return some(false);
+        }
+      default:
+        {
+          return none();
+        }
+    }
+  });
+};
+
+/** @internal */
+const isFailure = self => isSome(failureOption(self));
+
+/** @internal */
+const isDie = self => isSome(dieOption(self));
+
+/** @internal */
+const isInterrupted = self => isSome(interruptOption(self));
+
+/** @internal */
+const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
+
+/** @internal */
+const failures = self => reverse(reduce(self, empty$1(), (list, cause) => cause._tag === OP_FAIL ? some(pipe(list, prepend(cause.error))) : none()));
+
+/** @internal */
+const defects = self => reverse(reduce(self, empty$1(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend(cause.defect))) : none()));
+
+/** @internal */
+const interruptors = self => reduce(self, empty$2(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none());
+
+/** @internal */
+const failureOption = self => find(self, cause => cause._tag === OP_FAIL ? some(cause.error) : none());
+
+/** @internal */
+const failureOrCause = self => {
+  const option = failureOption(self);
+  switch (option._tag) {
+    case "None":
+      {
+        // no `E` inside this `Cause`, so it can be safely cast to `never`
+        return right(self);
+      }
+    case "Some":
+      {
+        return left(option.value);
+      }
+  }
+};
+
+/** @internal */
+const dieOption = self => find(self, cause => cause._tag === OP_DIE ? some(cause.defect) : none());
+
+/** @internal */
+const flipCauseOption = self => match(self, {
+  onEmpty: some(empty),
+  onFail: failureOption => pipe(failureOption, map$1(fail)),
+  onDie: defect => some(die(defect)),
+  onInterrupt: fiberId => some(interrupt(fiberId)),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? some(cause.fiberId) : none());
+
+/** @internal */
+const keepDefects = self => match(self, {
+  onEmpty: none(),
+  onFail: () => none(),
+  onDie: defect => some(die(defect)),
+  onInterrupt: () => none(),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const keepDefectsAndElectFailures = self => match(self, {
+  onEmpty: none(),
+  onFail: failure => some(die(failure)),
+  onDie: defect => some(die(defect)),
+  onInterrupt: () => none(),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const linearize = self => match(self, {
+  onEmpty: empty$2(),
+  onFail: error => make(fail(error)),
+  onDie: defect => make(die(defect)),
+  onInterrupt: fiberId => make(interrupt(fiberId)),
+  onSequential: (leftSet, rightSet) => pipe(leftSet, flatMap$1(leftCause => pipe(rightSet, map$2(rightCause => sequential(leftCause, rightCause))))),
+  onParallel: (leftSet, rightSet) => pipe(leftSet, flatMap$1(leftCause => pipe(rightSet, map$2(rightCause => parallel(leftCause, rightCause)))))
+});
+
+/** @internal */
+const stripFailures = self => match(self, {
+  onEmpty: empty,
+  onFail: () => empty,
+  onDie: defect => die(defect),
+  onInterrupt: fiberId => interrupt(fiberId),
+  onSequential: sequential,
+  onParallel: parallel
+});
+
+/** @internal */
+const electFailures = self => match(self, {
+  onEmpty: empty,
+  onFail: failure => die(failure),
+  onDie: defect => die(defect),
+  onInterrupt: fiberId => interrupt(fiberId),
+  onSequential: (left, right) => sequential(left, right),
+  onParallel: (left, right) => parallel(left, right)
+});
+
+/** @internal */
+const stripSomeDefects = /*#__PURE__*/dual(2, (self, pf) => match(self, {
+  onEmpty: some(empty),
+  onFail: error => some(fail(error)),
+  onDie: defect => {
+    const option = pf(defect);
+    return isSome(option) ? none() : some(die(defect));
+  },
+  onInterrupt: fiberId => some(interrupt(fiberId)),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+}));
+
+// -----------------------------------------------------------------------------
+// Mapping
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const as = /*#__PURE__*/dual(2, (self, error) => map(self, () => error));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => flatMap(self, e => fail(f(e))));
+
+// -----------------------------------------------------------------------------
+// Sequencing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => match(self, {
+  onEmpty: empty,
+  onFail: error => f(error),
+  onDie: defect => die(defect),
+  onInterrupt: fiberId => interrupt(fiberId),
+  onSequential: (left, right) => sequential(left, right),
+  onParallel: (left, right) => parallel(left, right)
+}));
+
+/** @internal */
+const flatten = self => flatMap(self, identity);
+
+// -----------------------------------------------------------------------------
+// Equality
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const contains = /*#__PURE__*/dual(2, (self, that) => {
+  if (that._tag === OP_EMPTY || self === that) {
+    return true;
+  }
+  return reduce(self, false, (accumulator, cause) => {
+    return some(accumulator || causeEquals(cause, that));
+  });
+});
+
+/** @internal */
+const causeEquals = (left, right) => {
+  let leftStack = of(left);
+  let rightStack = of(right);
+  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce([empty$2(), empty$1()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
+    }));
+    const [rightParallel, rightSequential] = pipe(headNonEmpty(rightStack), reduce([empty$2(), empty$1()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
+    }));
+    if (!equals(leftParallel, rightParallel)) {
+      return false;
+    }
+    leftStack = leftSequential;
+    rightStack = rightSequential;
+  }
+  return true;
+};
+
+// -----------------------------------------------------------------------------
+// Flattening
+// -----------------------------------------------------------------------------
+
+/**
+ * Flattens a cause to a sequence of sets of causes, where each set represents
+ * causes that fail in parallel and sequential sets represent causes that fail
+ * after each other.
+ *
+ * @internal
+ */
+const flattenCause = cause => {
+  return flattenCauseLoop(of(cause), empty$1());
+};
+
+/** @internal */
+const flattenCauseLoop = (causes, flattened) => {
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = pipe(causes, reduce$1([empty$2(), empty$1()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return [pipe(parallel, union(par)), pipe(sequential, appendAll(seq))];
+    }));
+    const updated = size$1(parallel) > 0 ? pipe(flattened, prepend(parallel)) : flattened;
+    if (isEmpty$1(sequential)) {
+      return reverse(updated);
+    }
+    causes = sequential;
+    flattened = updated;
+  }
+  throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/io/issues");
+};
+
+// -----------------------------------------------------------------------------
+// Squashing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const squash = self => {
+  return squashWith(identity)(self);
+};
+
+/** @internal */
+const squashWith = /*#__PURE__*/dual(2, (self, f) => {
+  const option = pipe(self, failureOption, map$1(f));
+  switch (option._tag) {
+    case "None":
+      {
+        return pipe(defects(self), head, match$1({
+          onNone: () => {
+            const interrupts = Array.from(interruptors(self)).flatMap(fiberId => Array.from(ids(fiberId)).map(id => `#${id}`));
+            return InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0);
+          },
+          onSome: identity
+        }));
+      }
+    case "Some":
+      {
+        return option.value;
+      }
+  }
+});
+
+// -----------------------------------------------------------------------------
+// Finding
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const find = /*#__PURE__*/dual(2, (self, pf) => {
+  const stack = [self];
+  while (stack.length > 0) {
+    const item = stack.pop();
+    const option = pf(item);
+    switch (option._tag) {
+      case "None":
+        {
+          switch (item._tag) {
+            case OP_SEQUENTIAL:
+            case OP_PARALLEL:
+              {
+                stack.push(item.right);
+                stack.push(item.left);
+                break;
+              }
+          }
+          break;
+        }
+      case "Some":
+        {
+          return option;
+        }
+    }
+  }
+  return none();
+});
+
+// -----------------------------------------------------------------------------
+// Filtering
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const filter = /*#__PURE__*/dual(2, (self, predicate) => reduceWithContext(self, void 0, FilterCauseReducer(predicate)));
+
+// -----------------------------------------------------------------------------
+// Evaluation
+// -----------------------------------------------------------------------------
+
+/**
+ * Takes one step in evaluating a cause, returning a set of causes that fail
+ * in parallel and a list of causes that fail sequentially after those causes.
+ *
+ * @internal
+ */
+const evaluateCause = self => {
+  let cause = self;
+  const stack = [];
+  let _parallel = empty$2();
+  let _sequential = empty$1();
+  while (cause !== undefined) {
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          cause = stack.pop();
+          break;
+        }
+      case OP_FAIL:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.error)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.error));
+          cause = stack.pop();
+          break;
+        }
+      case OP_DIE:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.defect)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.defect));
+          cause = stack.pop();
+          break;
+        }
+      case OP_INTERRUPT:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.fiberId)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.fiberId));
+          cause = stack.pop();
+          break;
+        }
+      case OP_SEQUENTIAL:
+        {
+          switch (cause.left._tag) {
+            case OP_EMPTY:
+              {
+                cause = cause.right;
+                break;
+              }
+            case OP_SEQUENTIAL:
+              {
+                cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
+                break;
+              }
+            case OP_PARALLEL:
+              {
+                cause = parallel(sequential(cause.left.left, cause.right), sequential(cause.left.right, cause.right));
+                break;
+              }
+            default:
+              {
+                _sequential = pipe(_sequential, prepend(cause.right));
+                cause = cause.left;
+                break;
+              }
+          }
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          stack.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+    }
+  }
+  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/io/issues");
+};
+
+// -----------------------------------------------------------------------------
+// Reducing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const SizeCauseReducer = {
+  emptyCase: () => 0,
+  failCase: () => 1,
+  dieCase: () => 1,
+  interruptCase: () => 1,
+  sequentialCase: (_, left, right) => left + right,
+  parallelCase: (_, left, right) => left + right
+};
+
+/** @internal */
+const IsInterruptedOnlyCauseReducer = {
+  emptyCase: constTrue,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: constTrue,
+  sequentialCase: (_, left, right) => left && right,
+  parallelCase: (_, left, right) => left && right
+};
+
+/** @internal */
+const FilterCauseReducer = predicate => ({
+  emptyCase: () => empty,
+  failCase: (_, error) => fail(error),
+  dieCase: (_, defect) => die(defect),
+  interruptCase: (_, fiberId) => interrupt(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__*/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__*/dual(3, (self, zero, pf) => {
+  let accumulator = zero;
+  let cause = self;
+  const causes = [];
+  while (cause !== undefined) {
+    const option = pf(accumulator, cause);
+    accumulator = isSome(option) ? option.value : accumulator;
+    switch (cause._tag) {
+      case OP_SEQUENTIAL:
+        {
+          causes.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          causes.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+      default:
+        {
+          cause = undefined;
+          break;
+        }
+    }
+    if (cause === undefined && causes.length > 0) {
+      cause = causes.pop();
+    }
+  }
+  return accumulator;
+});
+
+/** @internal */
+const reduceWithContext = /*#__PURE__*/dual(3, (self, context, reducer) => {
+  const input = [self];
+  const output = [];
+  while (input.length > 0) {
+    const cause = input.pop();
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          output.push(right(reducer.emptyCase(context)));
+          break;
+        }
+      case OP_FAIL:
+        {
+          output.push(right(reducer.failCase(context, cause.error)));
+          break;
+        }
+      case OP_DIE:
+        {
+          output.push(right(reducer.dieCase(context, cause.defect)));
+          break;
+        }
+      case OP_INTERRUPT:
+        {
+          output.push(right(reducer.interruptCase(context, cause.fiberId)));
+          break;
+        }
+      case OP_SEQUENTIAL:
+        {
+          input.push(cause.right);
+          input.push(cause.left);
+          output.push(left({
+            _tag: OP_SEQUENTIAL_CASE
+          }));
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          input.push(cause.right);
+          input.push(cause.left);
+          output.push(left({
+            _tag: OP_PARALLEL_CASE
+          }));
+          break;
+        }
+    }
+  }
+  const accumulator = [];
+  while (output.length > 0) {
+    const either = output.pop();
+    switch (either._tag) {
+      case "Left":
+        {
+          switch (either.left._tag) {
+            case OP_SEQUENTIAL_CASE:
+              {
+                const left = accumulator.pop();
+                const right = accumulator.pop();
+                const value = reducer.sequentialCase(context, left, right);
+                accumulator.push(value);
+                break;
+              }
+            case OP_PARALLEL_CASE:
+              {
+                const left = accumulator.pop();
+                const right = accumulator.pop();
+                const value = reducer.parallelCase(context, left, right);
+                accumulator.push(value);
+                break;
+              }
+          }
+          break;
+        }
+      case "Right":
+        {
+          accumulator.push(either.right);
+          break;
+        }
+    }
+  }
+  if (accumulator.length === 0) {
+    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  return accumulator.pop();
+});
+
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+
+const makeException = (proto, tag) => {
+  const _tag = {
+    value: tag,
+    enumerable: true
+  };
+  const protoWithToString = {
+    ...proto,
+    toString() {
+      return `${this._tag}: ${this.message}`;
+    }
+  };
+  return message => Object.create(protoWithToString, {
+    _tag,
+    message: {
+      value: message,
+      enumerable: true
+    }
+  });
+};
+
+/** @internal */
+const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
+
+/** @internal */
+const RuntimeException = /*#__PURE__*/makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+
+/** @internal */
+const isRuntimeException = u => {
+  return typeof u === "object" && u != null && RuntimeExceptionTypeId in u;
+};
+
+/** @internal */
+const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
+
+/** @internal */
+const InterruptedException = /*#__PURE__*/makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+
+/** @internal */
+const isInterruptedException = u => {
+  return typeof u === "object" && u != null && InterruptedExceptionTypeId in u;
+};
+
+/** @internal */
+const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
+
+/** @internal */
+const IllegalArgumentException = /*#__PURE__*/makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+
+/** @internal */
+const isIllegalArgumentException = u => {
+  return typeof u === "object" && u != null && IllegalArgumentExceptionTypeId in u;
+};
+
+/** @internal */
+const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
+
+/** @internal */
+const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+
+/** @internal */
+const isNoSuchElementException = u => {
+  return typeof u === "object" && u != null && NoSuchElementExceptionTypeId in u;
+};
+
+/** @internal */
+const InvalidHubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidHubCapacityException");
+
+/** @internal */
+const InvalidHubCapacityException = /*#__PURE__*/makeException({
+  [InvalidHubCapacityExceptionTypeId]: InvalidHubCapacityExceptionTypeId
+}, "InvalidHubCapacityException");
+
+// -----------------------------------------------------------------------------
+// Pretty Printing
+// -----------------------------------------------------------------------------
+
+const filterStack = stack => {
+  const lines = stack.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("EffectPrimitive") || lines[i].includes("Generator.next") || lines[i].includes("FiberRuntime")) {
+      return out.join("\n");
+    } else {
+      out.push(lines[i]);
+    }
+  }
+  return out.join("\n");
+};
+
+/** @internal */
+const pretty = cause => {
+  if (isInterruptedOnly(cause)) {
+    return "All fibers interrupted without errors.";
+  }
+  const final = prettyErrors(cause).map(e => {
+    let message = e.message;
+    if (e.stack) {
+      message += `\r\n${filterStack(e.stack)}`;
+    }
+    if (e.span) {
+      let current = e.span;
+      let i = 0;
+      while (current && current._tag === "Span" && i < 10) {
+        message += `\r\n    at ${current.name}`;
+        current = getOrUndefined(current.parent);
+        i++;
+      }
+    }
+    return message;
+  }).join("\r\n");
+  return final;
+};
+class PrettyError {
+  constructor(message, stack, span) {
+    this.message = message;
+    this.stack = stack;
+    this.span = span;
+  }
+  toJSON() {
+    const out = {
+      message: this.message
+    };
+    if (this.stack) {
+      out.stack = this.stack;
+    }
+    if (this.span) {
+      out.span = this.span;
+    }
+    return out;
+  }
+}
+
+/**
+ * A utility function for generating human-readable error messages from a generic error of type `unknown`.
+ *
+ * Rules:
+ *
+ * 1) If the input `u` is already a string, it's considered a message, and "Error" is added as a prefix.
+ * 2) If `u` has a user-defined `toString()` method, it uses that method and adds "Error" as a prefix.
+ * 3) If `u` is an object and its only (optional) properties are "name", "message", or "_tag", it constructs
+ *    an error message based on those properties.
+ * 4) Otherwise, it uses `JSON.stringify` to produce a string representation and uses it as the error message,
+ *   with "Error" added as a prefix.
+ *
+ * @internal
+ */
+const prettyErrorMessage = u => {
+  // 1)
+  if (typeof u === "string") {
+    return `Error: ${u}`;
+  }
+  // 2)
+  if (typeof u === "object" && u != null && "toString" in u && typeof u["toString"] === "function" && u["toString"] !== Object.prototype.toString) {
+    return u["toString"]();
+  }
+  // 3)
+  if (typeof u === "object" && u !== null) {
+    if ("message" in u && typeof u["message"] === "string") {
+      const raw = JSON.parse(JSON.stringify(u));
+      const keys = new Set(Object.keys(raw));
+      keys.delete("name");
+      keys.delete("message");
+      keys.delete("_tag");
+      if (keys.size === 0) {
+        const name = "name" in u && typeof u.name === "string" ? u.name : "Error";
+        const tag = "_tag" in u && typeof u["_tag"] === "string" ? `(${u._tag})` : ``;
+        return `${name}${tag}: ${u.message}`;
+      }
+    }
+  }
+  // 4)
+  return `Error: ${JSON.stringify(u)}`;
+};
+const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
+const defaultRenderError = error => {
+  const span = typeof error === "object" && error !== null && spanSymbol in error && error[spanSymbol];
+  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]
+});
+
+export { CauseTypeId, IllegalArgumentException, IllegalArgumentExceptionTypeId, InterruptedException, InterruptedExceptionTypeId, InvalidHubCapacityException, InvalidHubCapacityExceptionTypeId, NoSuchElementException, NoSuchElementExceptionTypeId, RuntimeException, RuntimeExceptionTypeId, as, contains, defects, die, dieOption, electFailures, empty, fail, failureOption, failureOrCause, failures, filter, find, flatMap, flatten, flipCauseOption, interrupt, interruptOption, interruptors, isCause, isDie, isDieType, isEmpty, isEmptyType, isFailType, isFailure, isIllegalArgumentException, isInterruptType, isInterrupted, isInterruptedException, isInterruptedOnly, isNoSuchElementException, isParallelType, isRuntimeException, isSequentialType, keepDefects, keepDefectsAndElectFailures, linearize, map, match, parallel, pretty, prettyErrorMessage, prettyErrors, reduce, reduceWithContext, sequential, size, squash, squashWith, stripFailures, stripSomeDefects };