@lmvz-ds/components 0.19.0 → 0.20.0

package/esm/{logger-0bL3pydp.js → logger-CGmJG63p.js}

@@ -273,19 +273,19 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
  * @category constructors
  * @since 2.0.0
  */
-const make$8 = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
+const make$b = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput = /*#__PURE__*/dual(2, (self, f) => make$8((x, y) => self(f(x), f(y))));
+const mapInput = /*#__PURE__*/dual(2, (self, f) => make$b((x, y) => self(f(x), f(y))));
 /**
  * Creates a new `Equivalence` for an array of values based on a given `Equivalence` for the elements of the array.
  *
  * @category combinators
  * @since 2.0.0
  */
-const array$1 = item => make$8((self, that) => {
+const array$1 = item => make$b((self, that) => {
   if (self.length !== that.length) {
     return false;
   }
@@ -598,7 +598,7 @@ const getBugErrorMessage = message => `BUG: ${message} - please report an issue
  * @category constructors
  * @since 2.0.0
  */
-class SingleShotGen {
+let SingleShotGen$1 = class SingleShotGen {
   self;
   called = false;
   constructor(self) {
@@ -637,7 +637,7 @@ class SingleShotGen {
   [Symbol.iterator]() {
     return new SingleShotGen(this.self);
   }
-}
+};
 const defaultIncHi = 0x14057b7e;
 const defaultIncLo = 0xf767814f;
 const MUL_HI = 0x5851f42d >>> 0;
@@ -899,7 +899,7 @@ const random = self => {
  * @since 2.0.0
  * @category hashing
  */
-const combine$1 = b => self => self * 53 ^ b;
+const combine$5 = b => self => self * 53 ^ b;
 /**
  * @since 2.0.0
  * @category hashing
@@ -946,7 +946,7 @@ const string = str => {
 const structureKeys = (o, keys) => {
   let h = 12289;
   for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]), combine$1(hash(o[keys[i]])));
+    h ^= pipe(string(keys[i]), combine$5(hash(o[keys[i]])));
   }
   return optimize(h);
 };
@@ -962,7 +962,7 @@ const structure = o => structureKeys(o, Object.keys(o));
 const array = arr => {
   let h = 6151;
   for (let i = 0; i < arr.length; i++) {
-    h = pipe(h, combine$1(hash(arr[i])));
+    h = pipe(h, combine$5(hash(arr[i])));
   }
   return optimize(h);
 };
@@ -1223,7 +1223,7 @@ let moduleVersion = "3.21.1";
 const getCurrentVersion = () => moduleVersion;
 
 /** @internal */
-const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
+const EffectTypeId$1 = /*#__PURE__*/Symbol.for("effect/Effect");
 /** @internal */
 const StreamTypeId = /*#__PURE__*/Symbol.for("effect/Stream");
 /** @internal */
@@ -1270,7 +1270,7 @@ const channelVariance = {
 };
 /** @internal */
 const EffectPrototype$1 = {
-  [EffectTypeId]: effectVariance,
+  [EffectTypeId$1]: effectVariance,
   [StreamTypeId]: effectVariance,
   [SinkTypeId]: sinkVariance,
   [ChannelTypeId]: channelVariance,
@@ -1281,7 +1281,7 @@ const EffectPrototype$1 = {
     return cached(this, random(this));
   },
   [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
+    return new SingleShotGen$1(new YieldWrap(this));
   },
   pipe() {
     return pipeArguments(this, arguments);
@@ -1326,10 +1326,10 @@ const Base$1 = /*#__PURE__*/function () {
 /**
  * @since 2.0.0
  */
-const TypeId$5 = /*#__PURE__*/Symbol.for("effect/Option");
+const TypeId$6 = /*#__PURE__*/Symbol.for("effect/Option");
 const CommonProto$1 = {
   ...EffectPrototype$1,
-  [TypeId$5]: {
+  [TypeId$6]: {
     _A: _ => _
   },
   [NodeInspectSymbol]() {
@@ -1346,7 +1346,7 @@ const SomeProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
     return isOption(that) && isSome$1(that) && equals(this.value, that.value);
   },
   [symbol$1]() {
-    return cached(this, combine$1(hash(this._tag))(hash(this.value)));
+    return cached(this, combine$5(hash(this._tag))(hash(this.value)));
   },
   toJSON() {
     return {
@@ -1374,13 +1374,13 @@ const NoneProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
   }
 });
 /** @internal */
-const isOption = input => hasProperty(input, TypeId$5);
+const isOption = input => hasProperty(input, TypeId$6);
 /** @internal */
 const isNone$1 = fa => fa._tag === "None";
 /** @internal */
 const isSome$1 = fa => fa._tag === "Some";
 /** @internal */
-const none$2 = /*#__PURE__*/Object.create(NoneProto);
+const none$4 = /*#__PURE__*/Object.create(NoneProto);
 /** @internal */
 const some$1 = value => {
   const a = Object.create(SomeProto);
@@ -1394,10 +1394,10 @@ const some$1 = value => {
 /**
  * @internal
  */
-const TypeId$4 = /*#__PURE__*/Symbol.for("effect/Either");
+const TypeId$5 = /*#__PURE__*/Symbol.for("effect/Either");
 const CommonProto = {
   ...EffectPrototype$1,
-  [TypeId$4]: {
+  [TypeId$5]: {
     _R: _ => _
   },
   [NodeInspectSymbol]() {
@@ -1414,7 +1414,7 @@ const RightProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonP
     return isEither(that) && isRight$1(that) && equals(this.right, that.right);
   },
   [symbol$1]() {
-    return combine$1(hash(this._tag))(hash(this.right));
+    return combine$5(hash(this._tag))(hash(this.right));
   },
   toJSON() {
     return {
@@ -1431,7 +1431,7 @@ const LeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
     return isEither(that) && isLeft$1(that) && equals(this.left, that.left);
   },
   [symbol$1]() {
-    return combine$1(hash(this._tag))(hash(this.left));
+    return combine$5(hash(this._tag))(hash(this.left));
   },
   toJSON() {
     return {
@@ -1442,7 +1442,7 @@ const LeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
   }
 });
 /** @internal */
-const isEither = input => hasProperty(input, TypeId$4);
+const isEither = input => hasProperty(input, TypeId$5);
 /** @internal */
 const isLeft$1 = ma => ma._tag === "Left";
 /** @internal */
@@ -1460,7 +1460,7 @@ const right$1 = right => {
   return a;
 };
 /** @internal */
-const getRight$1 = self => isLeft$1(self) ? none$2 : some$1(self.right);
+const getRight$1 = self => isLeft$1(self) ? none$4 : some$1(self.right);
 
 /**
  * @since 2.0.0
@@ -1608,7 +1608,7 @@ const isNonEmptyArray$1 = self => self.length > 0;
  * @category Constructors
  * @since 2.0.0
  */
-const none$1 = () => none$2;
+const none$3 = () => none$4;
 /**
  * Wraps the given value into an `Option` to represent its presence.
  *
@@ -1836,7 +1836,7 @@ const orElseSome = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? some(on
  * @category Conversions
  * @since 2.0.0
  */
-const fromNullable = nullableValue => nullableValue == null ? none$1() : some(nullableValue);
+const fromNullable = nullableValue => nullableValue == null ? none$3() : some(nullableValue);
 /**
  * Returns the value contained in the `Option` if it is `Some`; otherwise,
  * returns `undefined`.
@@ -1899,7 +1899,7 @@ const getOrUndefined = /*#__PURE__*/getOrElse(constUndefined);
  * @category Mapping
  * @since 2.0.0
  */
-const map$4 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$1() : some(f(self.value)));
+const map$6 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$3() : some(f(self.value)));
 /**
  * Applies a function to the value of a `Some` and flattens the resulting
  * `Option`. If the input is `None`, it remains `None`.
@@ -1953,7 +1953,7 @@ const map$4 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$1() : some(f
  * @category Sequencing
  * @since 2.0.0
  */
-const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$1() : f(self.value));
+const flatMap$4 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$3() : f(self.value));
 /**
  * Returns a function that checks if an `Option` contains a specified value,
  * using a provided equivalence function.
@@ -1988,7 +1988,7 @@ const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$1() : f(
  * @since 2.0.0
  */
 const containsWith = isEquivalent => dual(2, (self, a) => isNone(self) ? false : isEquivalent(self.value, a));
-const _equivalence$2 = /*#__PURE__*/equivalence();
+const _equivalence$3 = /*#__PURE__*/equivalence();
 /**
  * Returns a function that checks if an `Option` contains a specified value
  * using the default `Equivalence`.
@@ -2020,7 +2020,7 @@ const _equivalence$2 = /*#__PURE__*/equivalence();
  * @category Elements
  * @since 2.0.0
  */
-const contains = /*#__PURE__*/containsWith(_equivalence$2);
+const contains = /*#__PURE__*/containsWith(_equivalence$3);
 /**
  * Merges two optional values, applying a function if both exist.
  * Unlike {@link zipWith}, this function returns `None` only if both inputs are `None`.
@@ -2055,7 +2055,7 @@ const mergeWith = f => (o1, o2) => {
  * @category constructors
  * @since 2.0.0
  */
-const make$7 = (...elements) => elements;
+const make$a = (...elements) => elements;
 
 /**
  * This module provides utility functions for working with arrays in TypeScript.
@@ -2120,7 +2120,7 @@ const makeBy = /*#__PURE__*/dual(2, (n, f) => {
  * @category constructors
  * @since 2.0.0
  */
-const fromIterable$4 = collection => Array.isArray(collection) ? collection : Array.from(collection);
+const fromIterable$5 = collection => Array.isArray(collection) ? collection : Array.from(collection);
 /**
  * Creates a new `Array` from a value that might not be an iterable.
  *
@@ -2153,7 +2153,7 @@ const ensure = self => Array.isArray(self) ? self : [self];
  * @category concatenating
  * @since 2.0.0
  */
-const prepend$1 = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
+const prepend$2 = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
 /**
  * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`.
  *
@@ -2177,7 +2177,7 @@ const append$1 = /*#__PURE__*/dual(2, (self, last) => [...self, last]);
  * @category concatenating
  * @since 2.0.0
  */
-const appendAll$1 = /*#__PURE__*/dual(2, (self, that) => fromIterable$4(self).concat(fromIterable$4(that)));
+const appendAll$2 = /*#__PURE__*/dual(2, (self, that) => fromIterable$5(self).concat(fromIterable$5(that)));
 /**
  * Determine if an `Array` is empty narrowing down the type to `[]`.
  *
@@ -2254,9 +2254,9 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
  * @category getters
  * @since 2.0.0
  */
-const get$5 = /*#__PURE__*/dual(2, (self, index) => {
+const get$6 = /*#__PURE__*/dual(2, (self, index) => {
   const i = Math.floor(index);
-  return isOutOfBounds(i, self) ? none$1() : some(self[i]);
+  return isOutOfBounds(i, self) ? none$3() : some(self[i]);
 });
 /**
  * Gets an element unsafely, will throw on out of bounds.
@@ -2277,7 +2277,7 @@ const unsafeGet$3 = /*#__PURE__*/dual(2, (self, index) => {
  * @category getters
  * @since 2.0.0
  */
-const head$1 = /*#__PURE__*/get$5(0);
+const head$1 = /*#__PURE__*/get$6(0);
 /**
  * Get the first element of a non empty array.
  *
@@ -2300,7 +2300,7 @@ const headNonEmpty$1 = /*#__PURE__*/unsafeGet$3(0);
  * @category getters
  * @since 2.0.0
  */
-const last = self => isNonEmptyReadonlyArray(self) ? some(lastNonEmpty(self)) : none$1();
+const last = self => isNonEmptyReadonlyArray(self) ? some(lastNonEmpty(self)) : none$3();
 /**
  * Get the last element of a non empty array.
  *
@@ -2371,7 +2371,7 @@ const span = /*#__PURE__*/dual(2, (self, predicate) => splitAt$1(self, spanIndex
  * @since 2.0.0
  */
 const drop$1 = /*#__PURE__*/dual(2, (self, n) => {
-  const input = fromIterable$4(self);
+  const input = fromIterable$5(self);
   return input.slice(clamp(n, input), input.length);
 });
 /**
@@ -2389,7 +2389,7 @@ const drop$1 = /*#__PURE__*/dual(2, (self, n) => {
  * @category elements
  * @since 2.0.0
  */
-const reverse$1 = self => Array.from(self).reverse();
+const reverse$2 = self => Array.from(self).reverse();
 /**
  * Create a new array with elements sorted in increasing order based on the specified comparator.
  * If the input is a `NonEmptyReadonlyArray`, the output will also be a `NonEmptyReadonlyArray`.
@@ -2419,7 +2419,7 @@ const sort = /*#__PURE__*/dual(2, (self, O) => {
  * @category zipping
  * @since 2.0.0
  */
-const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, make$7));
+const zip$1 = /*#__PURE__*/dual(2, (self, that) => zipWith$1(self, that, make$a));
 /**
  * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
  * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
@@ -2436,9 +2436,9 @@ const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, make$7));
  * @category zipping
  * @since 2.0.0
  */
-const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
-  const as = fromIterable$4(self);
-  const bs = fromIterable$4(that);
+const zipWith$1 = /*#__PURE__*/dual(3, (self, that, f) => {
+  const as = fromIterable$5(self);
+  const bs = fromIterable$5(that);
   if (isNonEmptyReadonlyArray(as) && isNonEmptyReadonlyArray(bs)) {
     const out = [f(headNonEmpty$1(as), headNonEmpty$1(bs))];
     const len = Math.min(as.length, bs.length);
@@ -2449,7 +2449,7 @@ const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
   }
   return [];
 });
-const _equivalence$1 = /*#__PURE__*/equivalence();
+const _equivalence$2 = /*#__PURE__*/equivalence();
 /**
  * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements.
  * The value of `n` can be `0`.
@@ -2495,7 +2495,7 @@ const splitAt$1 = /*#__PURE__*/dual(2, (self, n) => {
  */
 const splitNonEmptyAt = /*#__PURE__*/dual(2, (self, n) => {
   const _n = Math.max(1, Math.floor(n));
-  return _n >= self.length ? [copy$1(self), []] : [prepend$1(self.slice(1, _n), headNonEmpty$1(self)), self.slice(_n)];
+  return _n >= self.length ? [copy$1(self), []] : [prepend$2(self.slice(1, _n), headNonEmpty$1(self)), self.slice(_n)];
 });
 /**
  * Copies an array.
@@ -2527,12 +2527,12 @@ const copy$1 = self => self.slice();
  * @since 2.0.0
  */
 const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
-  const a = fromIterable$4(self);
-  const b = fromIterable$4(that);
+  const a = fromIterable$5(self);
+  const b = fromIterable$5(that);
   if (isNonEmptyReadonlyArray(a)) {
     if (isNonEmptyReadonlyArray(b)) {
       const dedupe = dedupeWith(isEquivalent);
-      return dedupe(appendAll$1(a, b));
+      return dedupe(appendAll$2(a, b));
     }
     return a;
   }
@@ -2552,31 +2552,31 @@ const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
  *
  * @since 2.0.0
  */
-const union$2 = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that, _equivalence$1));
+const union$2 = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that, _equivalence$2));
 /**
  * @category constructors
  * @since 2.0.0
  */
-const empty$7 = () => [];
+const empty$d = () => [];
 /**
  * Constructs a new `NonEmptyArray<A>` from the specified value.
  *
  * @category constructors
  * @since 2.0.0
  */
-const of$1 = a => [a];
+const of$2 = a => [a];
 /**
  * @category mapping
  * @since 2.0.0
  */
-const map$3 = /*#__PURE__*/dual(2, (self, f) => self.map(f));
+const map$5 = /*#__PURE__*/dual(2, (self, f) => self.map(f));
 /**
  * Applies a function to each element in an array and returns a new array containing the concatenated mapped elements.
  *
  * @category sequencing
  * @since 2.0.0
  */
-const flatMap$2 = /*#__PURE__*/dual(2, (self, f) => {
+const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
     return [];
   }
@@ -2606,7 +2606,7 @@ const flatMap$2 = /*#__PURE__*/dual(2, (self, f) => {
  * @category sequencing
  * @since 2.0.0
  */
-const flatten = /*#__PURE__*/flatMap$2(identity);
+const flatten$1 = /*#__PURE__*/flatMap$3(identity);
 /**
  * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`.
  * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass.
@@ -2626,7 +2626,7 @@ const flatten = /*#__PURE__*/flatMap$2(identity);
  * @since 2.0.0
  */
 const filterMap$1 = /*#__PURE__*/dual(2, (self, f) => {
-  const as = fromIterable$4(self);
+  const as = fromIterable$5(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
     const o = f(as[i], i);
@@ -2641,7 +2641,7 @@ const filterMap$1 = /*#__PURE__*/dual(2, (self, f) => {
  * @since 2.0.0
  */
 const filter$1 = /*#__PURE__*/dual(2, (self, predicate) => {
-  const as = fromIterable$4(self);
+  const as = fromIterable$5(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
     if (predicate(as[i], i)) {
@@ -2665,7 +2665,7 @@ const filter$1 = /*#__PURE__*/dual(2, (self, predicate) => {
  * @category folding
  * @since 2.0.0
  */
-const reduce$5 = /*#__PURE__*/dual(3, (self, b, f) => fromIterable$4(self).reduce((b, a, i) => f(b, a, i), b));
+const reduce$7 = /*#__PURE__*/dual(3, (self, b, f) => fromIterable$5(self).reduce((b, a, i) => f(b, a, i), b));
 /**
  * @category constructors
  * @since 2.0.0
@@ -2696,7 +2696,7 @@ const unfold = (b, f) => {
  * @category instances
  * @since 2.0.0
  */
-const getEquivalence$1 = array$1;
+const getEquivalence$2 = array$1;
 /**
  * Remove duplicates from an `Iterable` using the provided `isEquivalent` function,
  * preserving the order of the first occurrence of each element.
@@ -2713,7 +2713,7 @@ const getEquivalence$1 = array$1;
  * @since 2.0.0
  */
 const dedupeWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
-  const input = fromIterable$4(self);
+  const input = fromIterable$5(self);
   if (isNonEmptyReadonlyArray(input)) {
     const out = [headNonEmpty$1(input)];
     const rest = tailNonEmpty$1(input);
@@ -2749,7 +2749,7 @@ const dedupe = self => dedupeWith(self, equivalence());
  * @since 2.0.0
  * @category folding
  */
-const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable$4(self).join(sep));
+const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable$5(self).join(sep));
 
 /** @internal */
 const TagTypeId = /*#__PURE__*/Symbol.for("effect/Context/Tag");
@@ -2785,7 +2785,7 @@ const TagProto = {
     return self;
   },
   context(self) {
-    return make$6(this, self);
+    return make$9(this, self);
   }
 };
 const ReferenceProto = {
@@ -2825,10 +2825,10 @@ const Reference$1 = () => (id, options) => {
   return ReferenceClass;
 };
 /** @internal */
-const TypeId$3 = /*#__PURE__*/Symbol.for("effect/Context");
+const TypeId$4 = /*#__PURE__*/Symbol.for("effect/Context");
 /** @internal */
 const ContextProto = {
-  [TypeId$3]: {
+  [TypeId$4]: {
     _Services: _ => _
   },
   [symbol](that) {
@@ -2888,14 +2888,14 @@ const serviceNotFoundError = tag => {
   return error;
 };
 /** @internal */
-const isContext$1 = u => hasProperty(u, TypeId$3);
+const isContext$1 = u => hasProperty(u, TypeId$4);
 /** @internal */
 const isReference = u => hasProperty(u, ReferenceTypeId);
-const _empty$3 = /*#__PURE__*/makeContext(/*#__PURE__*/new Map());
+const _empty$6 = /*#__PURE__*/makeContext(/*#__PURE__*/new Map());
 /** @internal */
-const empty$6 = () => _empty$3;
+const empty$c = () => _empty$6;
 /** @internal */
-const make$6 = (tag, service) => makeContext(new Map([[tag.key, service]]));
+const make$9 = (tag, service) => makeContext(new Map([[tag.key, service]]));
 /** @internal */
 const add$3 = /*#__PURE__*/dual(3, (self, tag, service) => {
   const map = new Map(self.unsafeMap);
@@ -2924,11 +2924,11 @@ const unsafeGet$2 = /*#__PURE__*/dual(2, (self, tag) => {
   return self.unsafeMap.get(tag.key);
 });
 /** @internal */
-const get$4 = unsafeGet$2;
+const get$5 = unsafeGet$2;
 /** @internal */
 const getOption$1 = /*#__PURE__*/dual(2, (self, tag) => {
   if (!self.unsafeMap.has(tag.key)) {
-    return isReference(tag) ? some$1(getDefaultValue(tag)) : none$2;
+    return isReference(tag) ? some$1(getDefaultValue(tag)) : none$4;
   }
   return some$1(self.unsafeMap.get(tag.key));
 });
@@ -2995,7 +2995,7 @@ const isContext = isContext$1;
  * @since 2.0.0
  * @category constructors
  */
-const empty$5 = empty$6;
+const empty$b = empty$c;
 /**
  * Creates a new `Context` with a single service associated to the tag.
  *
@@ -3014,7 +3014,7 @@ const empty$5 = empty$6;
  * @since 2.0.0
  * @category constructors
  */
-const make$5 = make$6;
+const make$8 = make$9;
 /**
  * Adds a service to a given `Context`.
  *
@@ -3062,7 +3062,7 @@ const add$2 = add$3;
  * @since 2.0.0
  * @category getters
  */
-const get$3 = get$4;
+const get$4 = get$5;
 /**
  * Get a service from the context that corresponds to the given tag.
  * This function is unsafe because if the tag is not present in the context, a runtime error will be thrown.
@@ -3219,7 +3219,7 @@ const Reference = Reference$1;
 /**
  * @since 2.0.0
  */
-const TypeId$2 = /*#__PURE__*/Symbol.for("effect/Chunk");
+const TypeId$3 = /*#__PURE__*/Symbol.for("effect/Chunk");
 function copy(src, srcPos, dest, destPos, len) {
   for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
     dest[destPos + i - srcPos] = src[i];
@@ -3233,10 +3233,10 @@ const emptyArray = [];
  * @category equivalence
  * @since 2.0.0
  */
-const getEquivalence = isEquivalent => make$8((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
-const _equivalence = /*#__PURE__*/getEquivalence(equals);
+const getEquivalence$1 = isEquivalent => make$b((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
+const _equivalence$1 = /*#__PURE__*/getEquivalence$1(equals);
 const ChunkProto = {
-  [TypeId$2]: {
+  [TypeId$3]: {
     _A: _ => _
   },
   toString() {
@@ -3252,7 +3252,7 @@ const ChunkProto = {
     return this.toJSON();
   },
   [symbol](that) {
-    return isChunk(that) && _equivalence(this, that);
+    return isChunk(that) && _equivalence$1(this, that);
   },
   [symbol$1]() {
     return cached(this, array(toReadonlyArray(this)));
@@ -3301,24 +3301,24 @@ const makeChunk = backing => {
       {
         chunk.length = backing.array.length;
         chunk.depth = 0;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
+        chunk.left = _empty$5;
+        chunk.right = _empty$5;
         break;
       }
     case "ISingleton":
       {
         chunk.length = 1;
         chunk.depth = 0;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
+        chunk.left = _empty$5;
+        chunk.right = _empty$5;
         break;
       }
     case "ISlice":
       {
         chunk.length = backing.length;
         chunk.depth = backing.chunk.depth + 1;
-        chunk.left = _empty$2;
-        chunk.right = _empty$2;
+        chunk.left = _empty$5;
+        chunk.right = _empty$5;
         break;
       }
   }
@@ -3330,29 +3330,29 @@ const makeChunk = backing => {
  * @category constructors
  * @since 2.0.0
  */
-const isChunk = u => hasProperty(u, TypeId$2);
-const _empty$2 = /*#__PURE__*/makeChunk({
+const isChunk = u => hasProperty(u, TypeId$3);
+const _empty$5 = /*#__PURE__*/makeChunk({
   _tag: "IEmpty"
 });
 /**
  * @category constructors
  * @since 2.0.0
  */
-const empty$4 = () => _empty$2;
+const empty$a = () => _empty$5;
 /**
  * Builds a `NonEmptyChunk` from an non-empty collection of elements.
  *
  * @category constructors
  * @since 2.0.0
  */
-const make$4 = (...as) => unsafeFromNonEmptyArray(as);
+const make$7 = (...as) => unsafeFromNonEmptyArray(as);
 /**
  * Builds a `NonEmptyChunk` from a single element.
  *
  * @category constructors
  * @since 2.0.0
  */
-const of = a => makeChunk({
+const of$1 = a => makeChunk({
   _tag: "ISingleton",
   a
 });
@@ -3362,7 +3362,7 @@ const of = a => makeChunk({
  * @category constructors
  * @since 2.0.0
  */
-const fromIterable$3 = self => isChunk(self) ? self : unsafeFromArray(fromIterable$4(self));
+const fromIterable$4 = self => isChunk(self) ? self : unsafeFromArray(fromIterable$5(self));
 const copyToArray = (self, array, initial) => {
   switch (self.backing._tag) {
     case "IArray":
@@ -3412,8 +3412,8 @@ const toReadonlyArray_ = self => {
           _tag: "IArray",
           array: arr
         };
-        self.left = _empty$2;
-        self.right = _empty$2;
+        self.left = _empty$5;
+        self.right = _empty$5;
         self.depth = 0;
         return arr;
       }
@@ -3437,19 +3437,19 @@ const reverseChunk = self => {
       {
         return makeChunk({
           _tag: "IArray",
-          array: reverse$1(self.backing.array)
+          array: reverse$2(self.backing.array)
         });
       }
     case "IConcat":
       {
         return makeChunk({
           _tag: "IConcat",
-          left: reverse(self.backing.right),
-          right: reverse(self.backing.left)
+          left: reverse$1(self.backing.right),
+          right: reverse$1(self.backing.left)
         });
       }
     case "ISlice":
-      return unsafeFromArray(reverse$1(toReadonlyArray(self)));
+      return unsafeFromArray(reverse$2(toReadonlyArray(self)));
   }
 };
 /**
@@ -3471,21 +3471,21 @@ const reverseChunk = self => {
  * @since 2.0.0
  * @category elements
  */
-const reverse = reverseChunk;
+const reverse$1 = reverseChunk;
 /**
  * This function provides a safe way to read a value at a particular index from a `Chunk`.
  *
  * @category elements
  * @since 2.0.0
  */
-const get$2 = /*#__PURE__*/dual(2, (self, index) => index < 0 || index >= self.length ? none$1() : some(unsafeGet(self, index)));
+const get$3 = /*#__PURE__*/dual(2, (self, index) => index < 0 || index >= self.length ? none$3() : some(unsafeGet(self, index)));
 /**
  * Wraps an array into a chunk without copying, unsafe on mutable arrays
  *
  * @since 2.0.0
  * @category unsafe
  */
-const unsafeFromArray = self => self.length === 0 ? empty$4() : self.length === 1 ? of(self[0]) : makeChunk({
+const unsafeFromArray = self => self.length === 0 ? empty$a() : self.length === 1 ? of$1(self[0]) : makeChunk({
   _tag: "IArray",
   array: self
 });
@@ -3538,14 +3538,14 @@ const unsafeGet = /*#__PURE__*/dual(2, (self, index) => {
  * @category concatenating
  * @since 2.0.0
  */
-const append = /*#__PURE__*/dual(2, (self, a) => appendAll(self, of(a)));
+const append = /*#__PURE__*/dual(2, (self, a) => appendAll$1(self, of$1(a)));
 /**
  * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
  *
  * @category concatenating
  * @since 2.0.0
  */
-const prepend = /*#__PURE__*/dual(2, (self, elem) => appendAll(of(elem), self));
+const prepend$1 = /*#__PURE__*/dual(2, (self, elem) => appendAll$1(of$1(elem), self));
 /**
  * Takes the first up to `n` elements from the chunk
  *
@@ -3553,7 +3553,7 @@ const prepend = /*#__PURE__*/dual(2, (self, elem) => appendAll(of(elem), self));
  */
 const take = /*#__PURE__*/dual(2, (self, n) => {
   if (n <= 0) {
-    return _empty$2;
+    return _empty$5;
   } else if (n >= self.length) {
     return self;
   } else {
@@ -3599,7 +3599,7 @@ const drop = /*#__PURE__*/dual(2, (self, n) => {
   if (n <= 0) {
     return self;
   } else if (n >= self.length) {
-    return _empty$2;
+    return _empty$5;
   } else {
     switch (self.backing._tag) {
       case "ISlice":
@@ -3652,7 +3652,7 @@ const drop = /*#__PURE__*/dual(2, (self, n) => {
  * @category concatenating
  * @since 2.0.0
  */
-const appendAll = /*#__PURE__*/dual(2, (self, that) => {
+const appendAll$1 = /*#__PURE__*/dual(2, (self, that) => {
   if (self.backing._tag === "IEmpty") {
     return that;
   }
@@ -3668,14 +3668,14 @@ const appendAll = /*#__PURE__*/dual(2, (self, that) => {
     });
   } else if (diff < -1) {
     if (self.left.depth >= self.right.depth) {
-      const nr = appendAll(self.right, that);
+      const nr = appendAll$1(self.right, that);
       return makeChunk({
         _tag: "IConcat",
         left: self.left,
         right: nr
       });
     } else {
-      const nrr = appendAll(self.right.right, that);
+      const nrr = appendAll$1(self.right.right, that);
       if (nrr.depth === self.depth - 3) {
         const nr = makeChunk({
           _tag: "IConcat",
@@ -3702,14 +3702,14 @@ const appendAll = /*#__PURE__*/dual(2, (self, that) => {
     }
   } else {
     if (that.right.depth >= that.left.depth) {
-      const nl = appendAll(self, that.left);
+      const nl = appendAll$1(self, that.left);
       return makeChunk({
         _tag: "IConcat",
         left: nl,
         right: that.right
       });
     } else {
-      const nll = appendAll(self, that.left.left);
+      const nll = appendAll$1(self, that.left.left);
       if (nll.depth === that.depth - 3) {
         const nl = makeChunk({
           _tag: "IConcat",
@@ -3756,7 +3756,7 @@ const filter = /*#__PURE__*/dual(2, (self, predicate) => unsafeFromArray(filter$
  * @since 2.0.0
  * @category elements
  */
-const isEmpty$2 = self => self.length === 0;
+const isEmpty$3 = self => self.length === 0;
 /**
  * Determines if the chunk is not empty.
  *
@@ -3770,7 +3770,7 @@ const isNonEmpty = self => self.length > 0;
  * @since 2.0.0
  * @category elements
  */
-const head = /*#__PURE__*/get$2(0);
+const head = /*#__PURE__*/get$3(0);
 /**
  * Returns the first element of this chunk.
  *
@@ -3805,7 +3805,7 @@ const headNonEmpty = unsafeHead;
  * @since 2.0.0
  * @category mapping
  */
-const map$2 = /*#__PURE__*/dual(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray(pipe(toReadonlyArray(self), map$3((a, i) => f(a, i)))));
+const map$4 = /*#__PURE__*/dual(2, (self, f) => self.backing._tag === "ISingleton" ? of$1(f(self.backing.a, 0)) : unsafeFromArray(pipe(toReadonlyArray(self), map$5((a, i) => f(a, i)))));
 /**
  *  Returns two splits of this chunk at the specified index.
  *
@@ -3842,7 +3842,7 @@ const tailNonEmpty = self => drop(self, 1);
  * @category folding
  * @since 2.0.0
  */
-const reduce$4 = reduce$5;
+const reduce$6 = reduce$7;
 
 /** @internal */
 const SIZE = 5;
@@ -3883,7 +3883,7 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
 
-const make$3 = (value, previous) => ({
+const make$6 = (value, previous) => ({
   value,
   previous
 });
@@ -3940,7 +3940,7 @@ function arraySpliceIn(mutate, at, v, arr) {
 class EmptyNode {
   _tag = "EmptyNode";
   modify(edit, _shift, f, hash, key, size) {
-    const v = f(none$1());
+    const v = f(none$3());
     if (isNone(v)) return new EmptyNode();
     ++size.value;
     return new LeafNode(edit, hash, key, v);
@@ -3984,7 +3984,7 @@ class LeafNode {
       }
       return new LeafNode(edit, hash, key, v);
     }
-    const v = f(none$1());
+    const v = f(none$3());
     if (isNone(v)) return this;
     ++size.value;
     return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
@@ -4008,7 +4008,7 @@ class CollisionNode {
       if (list === this.children) return this;
       return list.length > 1 ? new CollisionNode(edit, this.hash, list) : list[0]; // collapse single element collision list
     }
-    const v = f(none$1());
+    const v = f(none$3());
     if (isNone(v)) return this;
     ++size.value;
     return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
@@ -4028,7 +4028,7 @@ class CollisionNode {
         return arrayUpdate(mutate, i, new LeafNode(edit, hash, key, newValue), list);
       }
     }
-    const newValue = f(none$1());
+    const newValue = f(none$3());
     if (isNone(newValue)) return list;
     ++size.value;
     return arrayUpdate(mutate, len, new LeafNode(edit, hash, key, newValue), list);
@@ -4169,7 +4169,7 @@ function mergeLeaves(edit, shift, h1, n1, h2, n2) {
   while (true) {
     const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
     if (typeof res === "function") {
-      stack = make$3(res, stack);
+      stack = make$6(res, stack);
       currentShift = currentShift + SIZE;
     } else {
       let final = res;
@@ -4193,7 +4193,7 @@ const HashMapProto = {
   [symbol$1]() {
     let hash$1 = hash(HashMapSymbolKey);
     for (const item of this) {
-      hash$1 ^= pipe(hash(item[0]), combine$1(hash(item[1])));
+      hash$1 ^= pipe(hash(item[0]), combine$5(hash(item[1])));
     }
     return cached(this, hash$1);
   },
@@ -4267,7 +4267,7 @@ class HashMapIterator {
     return new HashMapIterator(this.map, this.f);
   }
 }
-const applyCont = cont => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none$1();
+const applyCont = cont => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none$3();
 const visitLazy = (node, f, cont = undefined) => {
   switch (node._tag) {
     case "LeafNode":
@@ -4302,23 +4302,23 @@ const visitLazyChildren = (len, children, i, f, cont) => {
   }
   return applyCont(cont);
 };
-const _empty$1 = /*#__PURE__*/makeImpl$1(false, 0, /*#__PURE__*/new EmptyNode(), 0);
+const _empty$4 = /*#__PURE__*/makeImpl$1(false, 0, /*#__PURE__*/new EmptyNode(), 0);
 /** @internal */
-const empty$3 = () => _empty$1;
+const empty$9 = () => _empty$4;
 /** @internal */
-const fromIterable$2 = entries => {
-  const map = beginMutation$1(empty$3());
+const fromIterable$3 = entries => {
+  const map = beginMutation$1(empty$9());
   for (const entry of entries) {
-    set$1(map, entry[0], entry[1]);
+    set$2(map, entry[0], entry[1]);
   }
   return endMutation$1(map);
 };
 /** @internal */
 const isHashMap = u => hasProperty(u, HashMapTypeId);
 /** @internal */
-const isEmpty$1 = self => self && isEmptyNode(self._root);
+const isEmpty$2 = self => self && isEmptyNode(self._root);
 /** @internal */
-const get$1 = /*#__PURE__*/dual(2, (self, key) => getHash(self, key, hash(key)));
+const get$2 = /*#__PURE__*/dual(2, (self, key) => getHash(self, key, hash(key)));
 /** @internal */
 const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
   let node = self._root;
@@ -4327,7 +4327,7 @@ const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
     switch (node._tag) {
       case "LeafNode":
         {
-          return equals(key, node.key) ? node.value : none$1();
+          return equals(key, node.key) ? node.value : none$3();
         }
       case "CollisionNode":
         {
@@ -4340,7 +4340,7 @@ const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
               }
             }
           }
-          return none$1();
+          return none$3();
         }
       case "IndexedNode":
         {
@@ -4351,7 +4351,7 @@ const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
             shift += SIZE;
             break;
           }
-          return none$1();
+          return none$3();
         }
       case "ArrayNode":
         {
@@ -4360,17 +4360,17 @@ const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
             shift += SIZE;
             break;
           }
-          return none$1();
+          return none$3();
         }
       default:
-        return none$1();
+        return none$3();
     }
   }
 });
 /** @internal */
 const has$2 = /*#__PURE__*/dual(2, (self, key) => isSome(getHash(self, key, hash(key))));
 /** @internal */
-const set$1 = /*#__PURE__*/dual(3, (self, key, value) => modifyAt(self, key, () => some(value)));
+const set$2 = /*#__PURE__*/dual(3, (self, key, value) => modifyAt$1(self, key, () => some(value)));
 /** @internal */
 const setTree = /*#__PURE__*/dual(3, (self, newRoot, newSize) => {
   if (self._editable) {
@@ -4381,7 +4381,7 @@ const setTree = /*#__PURE__*/dual(3, (self, newRoot, newSize) => {
   return newRoot === self._root ? self : makeImpl$1(self._editable, self._edit, newRoot, newSize);
 });
 /** @internal */
-const keys = self => new HashMapIterator(self, key => key);
+const keys$1 = self => new HashMapIterator(self, key => key);
 /** @internal */
 const size$2 = self => self._size;
 /** @internal */
@@ -4392,7 +4392,7 @@ const endMutation$1 = self => {
   return self;
 };
 /** @internal */
-const modifyAt = /*#__PURE__*/dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
+const modifyAt$1 = /*#__PURE__*/dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
 /** @internal */
 const modifyHash = /*#__PURE__*/dual(4, (self, key, hash, f) => {
   const size = {
@@ -4402,18 +4402,18 @@ const modifyHash = /*#__PURE__*/dual(4, (self, key, hash, f) => {
   return pipe(self, setTree(newRoot, size.value));
 });
 /** @internal */
-const remove$2 = /*#__PURE__*/dual(2, (self, key) => modifyAt(self, key, none$1));
+const remove$2 = /*#__PURE__*/dual(2, (self, key) => modifyAt$1(self, key, none$3));
 /**
  * Maps over the entries of the `HashMap` using the specified function.
  *
  * @since 2.0.0
  * @category mapping
  */
-const map$1 = /*#__PURE__*/dual(2, (self, f) => reduce$3(self, empty$3(), (map, value, key) => set$1(map, key, f(value, key))));
+const map$3 = /*#__PURE__*/dual(2, (self, f) => reduce$5(self, empty$9(), (map, value, key) => set$2(map, key, f(value, key))));
 /** @internal */
-const forEach$1 = /*#__PURE__*/dual(2, (self, f) => reduce$3(self, void 0, (_, value, key) => f(value, key)));
+const forEach$1 = /*#__PURE__*/dual(2, (self, f) => reduce$5(self, void 0, (_, value, key) => f(value, key)));
 /** @internal */
-const reduce$3 = /*#__PURE__*/dual(3, (self, zero, f) => {
+const reduce$5 = /*#__PURE__*/dual(3, (self, zero, f) => {
   const root = self._root;
   if (root._tag === "LeafNode") {
     return isSome(root.value) ? f(zero, root.value.value, root.key) : zero;
@@ -4446,10 +4446,10 @@ const HashSetTypeId = /*#__PURE__*/Symbol.for(HashSetSymbolKey);
 const HashSetProto = {
   [HashSetTypeId]: HashSetTypeId,
   [Symbol.iterator]() {
-    return keys(this._keyMap);
+    return keys$1(this._keyMap);
   },
   [symbol$1]() {
-    return cached(this, combine$1(hash(this._keyMap))(hash(HashSetSymbolKey)));
+    return cached(this, combine$5(hash(this._keyMap))(hash(HashSetSymbolKey)));
   },
   [symbol](that) {
     if (isHashSet(that)) {
@@ -4481,20 +4481,20 @@ const makeImpl = keyMap => {
 };
 /** @internal */
 const isHashSet = u => hasProperty(u, HashSetTypeId);
-const _empty = /*#__PURE__*/makeImpl(/*#__PURE__*/empty$3());
+const _empty$3 = /*#__PURE__*/makeImpl(/*#__PURE__*/empty$9());
 /** @internal */
-const empty$2 = () => _empty;
+const empty$8 = () => _empty$3;
 /** @internal */
-const fromIterable$1 = elements => {
-  const set = beginMutation(empty$2());
+const fromIterable$2 = elements => {
+  const set = beginMutation(empty$8());
   for (const value of elements) {
     add$1(set, value);
   }
   return endMutation(set);
 };
 /** @internal */
-const make$2 = (...elements) => {
-  const set = beginMutation(empty$2());
+const make$5 = (...elements) => {
+  const set = beginMutation(empty$8());
   for (const value of elements) {
     add$1(set, value);
   }
@@ -4518,7 +4518,7 @@ const mutate = /*#__PURE__*/dual(2, (self, f) => {
   return endMutation(transient);
 });
 /** @internal */
-const add$1 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (set$1(value, true)(self._keyMap), self) : makeImpl(set$1(value, true)(self._keyMap)));
+const add$1 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (set$2(value, true)(self._keyMap), self) : makeImpl(set$2(value, true)(self._keyMap)));
 /** @internal */
 const remove$1 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (remove$2(value)(self._keyMap), self) : makeImpl(remove$2(value)(self._keyMap)));
 /** @internal */
@@ -4528,7 +4528,7 @@ const difference$1 = /*#__PURE__*/dual(2, (self, that) => mutate(self, set => {
   }
 }));
 /** @internal */
-const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$2(), set => {
+const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$8(), set => {
   forEach(self, value => add$1(set, value));
   for (const value of that) {
     add$1(set, value);
@@ -4537,7 +4537,7 @@ const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$2(), set => {
 /** @internal */
 const forEach = /*#__PURE__*/dual(2, (self, f) => forEach$1(self._keyMap, (_, k) => f(k)));
 /** @internal */
-const reduce$2 = /*#__PURE__*/dual(3, (self, zero, f) => reduce$3(self._keyMap, zero, (z, _, a) => f(z, a)));
+const reduce$4 = /*#__PURE__*/dual(3, (self, zero, f) => reduce$5(self._keyMap, zero, (z, _, a) => f(z, a)));
 
 /**
  * # HashSet
@@ -4819,7 +4819,7 @@ const reduce$2 = /*#__PURE__*/dual(3, (self, zero, f) => reduce$3(self._keyMap,
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.make} {@link module:HashSet.fromIterable}
  */
-const empty$1 = empty$2;
+const empty$7 = empty$8;
 /**
  * Creates a new `HashSet` from an iterable collection of values.
  *
@@ -4913,7 +4913,7 @@ const empty$1 = empty$2;
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.empty} {@link module:HashSet.make}
  */
-const fromIterable = fromIterable$1;
+const fromIterable$1 = fromIterable$2;
 /**
  * Construct a new `HashSet` from a variable number of values.
  *
@@ -5001,7 +5001,7 @@ const fromIterable = fromIterable$1;
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.fromIterable} {@link module:HashSet.empty}
  */
-const make$1 = make$2;
+const make$4 = make$5;
 /**
  * Checks if the specified value exists in the `HashSet`.
  *
@@ -5202,14 +5202,14 @@ const union = union$1;
  * HashSet.reduce(HashSet.make(0, 1, 2), 0, sum)
  * ```
  */
-const reduce$1 = reduce$2;
+const reduce$3 = reduce$4;
 
 /**
  * @since 2.0.0
  */
-const TypeId$1 = /*#__PURE__*/Symbol.for("effect/MutableRef");
+const TypeId$2 = /*#__PURE__*/Symbol.for("effect/MutableRef");
 const MutableRefProto = {
-  [TypeId$1]: TypeId$1,
+  [TypeId$2]: TypeId$2,
   toString() {
     return format$1(this.toJSON());
   },
@@ -5230,7 +5230,7 @@ const MutableRefProto = {
  * @since 2.0.0
  * @category constructors
  */
-const make = value => {
+const make$3 = value => {
   const ref = Object.create(MutableRefProto);
   ref.current = value;
   return ref;
@@ -5250,12 +5250,12 @@ const compareAndSet = /*#__PURE__*/dual(3, (self, oldValue, newValue) => {
  * @since 2.0.0
  * @category general
  */
-const get = self => self.current;
+const get$1 = self => self.current;
 /**
  * @since 2.0.0
  * @category general
  */
-const set = /*#__PURE__*/dual(2, (self, value) => {
+const set$1 = /*#__PURE__*/dual(2, (self, value) => {
   self.current = value;
   return self;
 });
@@ -5272,7 +5272,7 @@ const OP_RUNTIME = "Runtime";
 const OP_COMPOSITE = "Composite";
 const emptyHash = /*#__PURE__*/string(`${FiberIdSymbolKey}-${OP_NONE}`);
 /** @internal */
-class None {
+let None$1 = class None {
   [FiberIdTypeId] = FiberIdTypeId;
   _tag = OP_NONE;
   id = -1;
@@ -5295,7 +5295,7 @@ class None {
   [NodeInspectSymbol]() {
     return this.toJSON();
   }
-}
+};
 /** @internal */
 class Runtime {
   id;
@@ -5339,7 +5339,7 @@ class Composite {
   }
   _hash;
   [symbol$1]() {
-    return pipe(string(`${FiberIdSymbolKey}-${this._tag}`), combine$1(hash(this.left)), combine$1(hash(this.right)), cached(this));
+    return pipe(string(`${FiberIdSymbolKey}-${this._tag}`), combine$5(hash(this.left)), combine$5(hash(this.right)), cached(this));
   }
   [symbol](that) {
     return isFiberId(that) && that._tag === OP_COMPOSITE && equals(this.left, that.left) && equals(this.right, that.right);
@@ -5360,11 +5360,11 @@ class Composite {
   }
 }
 /** @internal */
-const none = /*#__PURE__*/new None();
+const none$2 = /*#__PURE__*/new None$1();
 /** @internal */
 const isFiberId = self => hasProperty(self, FiberIdTypeId);
 /** @internal */
-const combine = /*#__PURE__*/dual(2, (self, that) => {
+const combine$4 = /*#__PURE__*/dual(2, (self, that) => {
   if (self._tag === OP_NONE) {
     return that;
   }
@@ -5374,19 +5374,19 @@ const combine = /*#__PURE__*/dual(2, (self, that) => {
   return new Composite(self, that);
 });
 /** @internal */
-const combineAll = fiberIds => {
-  return pipe(fiberIds, reduce$1(none, (a, b) => combine(b)(a)));
+const combineAll$1 = fiberIds => {
+  return pipe(fiberIds, reduce$3(none$2, (a, b) => combine$4(b)(a)));
 };
 /** @internal */
 const ids = self => {
   switch (self._tag) {
     case OP_NONE:
       {
-        return empty$1();
+        return empty$7();
       }
     case OP_RUNTIME:
       {
-        return make$1(self.id);
+        return make$4(self.id);
       }
     case OP_COMPOSITE:
       {
@@ -5394,713 +5394,2802 @@ const ids = self => {
       }
   }
 };
-const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make(0));
+const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make$3(0));
 /** @internal */
-const threadName = self => {
+const threadName$1 = self => {
   const identifiers = Array.from(ids(self)).map(n => `#${n}`).join(",");
   return identifiers;
 };
 /** @internal */
-const unsafeMake = () => {
-  const id = get(_fiberCounter);
-  pipe(_fiberCounter, set(id + 1));
+const unsafeMake$1 = () => {
+  const id = get$1(_fiberCounter);
+  pipe(_fiberCounter, set$1(id + 1));
   return new Runtime(id, Date.now());
 };
 
-/** @internal */
-const OP_DIE = "Die";
-/** @internal */
-const OP_EMPTY = "Empty";
-/** @internal */
-const OP_FAIL = "Fail";
-/** @internal */
-const OP_INTERRUPT = "Interrupt";
-/** @internal */
-const OP_PARALLEL = "Parallel";
-/** @internal */
-const OP_SEQUENTIAL = "Sequential";
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const none$1 = none$2;
+/**
+ * Combine two `FiberId`s.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const combine$3 = combine$4;
+/**
+ * Combines a set of `FiberId`s into a single `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const combineAll = combineAll$1;
+/**
+ * Creates a string representing the name of the current thread of execution
+ * represented by the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const threadName = threadName$1;
+/**
+ * Unsafely creates a new `FiberId`.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeMake = unsafeMake$1;
 
-// -----------------------------------------------------------------------------
-// Models
-// -----------------------------------------------------------------------------
-/** @internal */
-const CauseSymbolKey = "effect/Cause";
-/** @internal */
-const CauseTypeId = /*#__PURE__*/Symbol.for(CauseSymbolKey);
-const variance = {
-  /* c8 ignore next */
-  _E: _ => _
-};
-/** @internal */
-const proto = {
-  [CauseTypeId]: variance,
-  [symbol$1]() {
-    return pipe(hash(CauseSymbolKey), combine$1(hash(flattenCause(this))), cached(this));
+/**
+ * @since 2.0.0
+ */
+/**
+ * Creates a new `HashMap`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty$6 = empty$9;
+/**
+ * Creates a new `HashMap` from an iterable collection of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$3;
+/**
+ * Checks if the `HashMap` contains any entries.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const isEmpty$1 = isEmpty$2;
+/**
+ * Safely lookup the value for the specified key in the `HashMap` using the
+ * internal hashing function.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const get = get$2;
+/**
+ * Sets the specified key to the specified value using the internal hashing
+ * function.
+ *
+ * @since 2.0.0
+ */
+const set = set$2;
+/**
+ * Returns an `IterableIterator` of the keys within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const keys = keys$1;
+/**
+ * Set or remove the specified key in the `HashMap` using the specified
+ * update function. The value of the specified key will be computed using the
+ * provided hash.
+ *
+ * The update function will be invoked with the current value of the key if it
+ * exists, or `None` if no such value exists.
+ *
+ * @since 2.0.0
+ */
+const modifyAt = modifyAt$1;
+/**
+ * Maps over the entries of the `HashMap` using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map$2 = map$3;
+/**
+ * Reduces the specified state over the entries of the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce$2 = reduce$5;
+
+/**
+ * A data type for immutable linked lists representing ordered collections of elements of type `A`.
+ *
+ * This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
+ *
+ * **Performance**
+ *
+ * - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`.
+ * - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.
+ *
+ * @since 2.0.0
+ */
+/**
+ * This file is ported from
+ *
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ */
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+const TypeId$1 = /*#__PURE__*/Symbol.for("effect/List");
+/**
+ * Converts the specified `List` to an `Array`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toArray = self => fromIterable$5(self);
+/**
+ * @category equivalence
+ * @since 2.0.0
+ */
+const getEquivalence = isEquivalent => mapInput(getEquivalence$2(isEquivalent), toArray);
+const _equivalence = /*#__PURE__*/getEquivalence(equals);
+const ConsProto = {
+  [TypeId$1]: TypeId$1,
+  _tag: "Cons",
+  toString() {
+    return format$1(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "List",
+      _tag: "Cons",
+      values: toArray(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
   },
   [symbol](that) {
-    return isCause(that) && causeEquals(this, that);
+    return isList(that) && this._tag === that._tag && _equivalence(this, that);
   },
-  pipe() {
-    return pipeArguments(this, arguments);
+  [symbol$1]() {
+    return cached(this, array(toArray(this)));
   },
-  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":
+  [Symbol.iterator]() {
+    let done = false;
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let self = this;
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        }
+        if (self._tag === "Nil") {
+          done = true;
+          return this.return();
+        }
+        const value = self.head;
+        self = self.tail;
         return {
-          _id: "Cause",
-          _tag: this._tag,
-          failure: toJSON(this.error)
+          done,
+          value
         };
-      case "Sequential":
-      case "Parallel":
+      },
+      return(value) {
+        if (!done) {
+          done = true;
+        }
         return {
-          _id: "Cause",
-          _tag: this._tag,
-          left: toJSON(this.left),
-          right: toJSON(this.right)
+          done: true,
+          value
         };
-    }
+      }
+    };
   },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+const makeCons = (head, tail) => {
+  const cons = Object.create(ConsProto);
+  cons.head = head;
+  cons.tail = tail;
+  return cons;
+};
+const NilHash = /*#__PURE__*/string("Nil");
+const NilProto = {
+  [TypeId$1]: TypeId$1,
+  _tag: "Nil",
   toString() {
-    return pretty(this);
+    return format$1(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "List",
+      _tag: "Nil"
+    };
   },
   [NodeInspectSymbol]() {
     return this.toJSON();
+  },
+  [symbol$1]() {
+    return NilHash;
+  },
+  [symbol](that) {
+    return isList(that) && this._tag === that._tag;
+  },
+  [Symbol.iterator]() {
+    return {
+      next() {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+    };
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
   }
 };
-// -----------------------------------------------------------------------------
-// Constructors
-// -----------------------------------------------------------------------------
-/** @internal */
-const empty = /*#__PURE__*/(() => {
-  const o = /*#__PURE__*/Object.create(proto);
-  o._tag = OP_EMPTY;
-  return o;
-})();
-/** @internal */
-const fail$1 = error => {
-  const o = Object.create(proto);
-  o._tag = OP_FAIL;
-  o.error = error;
-  return o;
-};
-/** @internal */
-const die = 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;
-};
+const _Nil = /*#__PURE__*/Object.create(NilProto);
+/**
+ * Returns `true` if the specified value is a `List`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isList = u => hasProperty(u, TypeId$1);
+/**
+ * Returns `true` if the specified value is a `List.Nil<A>`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isNil = self => self._tag === "Nil";
+/**
+ * Returns `true` if the specified value is a `List.Cons<A>`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isCons = self => self._tag === "Cons";
+/**
+ * Constructs a new empty `List<A>`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const nil = () => _Nil;
+/**
+ * Constructs a new `List.Cons<A>` from the specified `head` and `tail` values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const cons = (head, tail) => makeCons(head, tail);
+/**
+ * Constructs a new empty `List<A>`.
+ *
+ * Alias of {@link nil}.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty$5 = nil;
+/**
+ * Constructs a new `List<A>` from the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const of = value => makeCons(value, _Nil);
+/**
+ * Concatenates two lists, combining their elements.
+ * If either list is non-empty, the result is also a non-empty list.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { List } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray),
+ *   [1, 2, "a", "b"]
+ * )
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const appendAll = /*#__PURE__*/dual(2, (self, that) => prependAll(that, self));
+/**
+ * Prepends the specified element to the beginning of the list.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prepend = /*#__PURE__*/dual(2, (self, element) => cons(element, self));
+/**
+ * Prepends the specified prefix list to the beginning of the specified list.
+ * If either list is non-empty, the result is also a non-empty list.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { List } from "effect"
+ *
+ * assert.deepStrictEqual(
+ *   List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray),
+ *   ["a", "b", 1, 2]
+ * )
+ * ```
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const prependAll = /*#__PURE__*/dual(2, (self, prefix) => {
+  if (isNil(self)) {
+    return prefix;
+  } else if (isNil(prefix)) {
+    return self;
+  } else {
+    const result = makeCons(prefix.head, self);
+    let curr = result;
+    let that = prefix.tail;
+    while (!isNil(that)) {
+      const temp = makeCons(that.head, self);
+      curr.tail = temp;
+      curr = temp;
+      that = that.tail;
+    }
+    return result;
+  }
+});
+/**
+ * Folds over the elements of the list using the specified function, using the
+ * specified initial value.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
+  let acc = zero;
+  let these = self;
+  while (!isNil(these)) {
+    acc = f(acc, these.head);
+    these = these.tail;
+  }
+  return acc;
+});
+/**
+ * Returns a new list with the elements of the specified list in reverse order.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const reverse = self => {
+  let result = empty$5();
+  let these = self;
+  while (!isNil(these)) {
+    result = prepend(result, these.head);
+    these = these.tail;
+  }
+  return result;
+};
+
 /** @internal */
-const sequential = (left, right) => {
-  const o = Object.create(proto);
-  o._tag = OP_SEQUENTIAL;
-  o.left = left;
-  o.right = right;
+const Structural = /*#__PURE__*/function () {
+  function Structural(args) {
+    if (args) {
+      Object.assign(this, args);
+    }
+  }
+  Structural.prototype = StructuralPrototype;
+  return Structural;
+}();
+
+/** @internal */
+const ContextPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferContextPatch");
+function variance$3(a) {
+  return a;
+}
+/** @internal */
+const PatchProto$2 = {
+  ...Structural.prototype,
+  [ContextPatchTypeId]: {
+    _Value: variance$3,
+    _Patch: variance$3
+  }
+};
+const EmptyProto$2 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "Empty"
+});
+const _empty$2 = /*#__PURE__*/Object.create(EmptyProto$2);
+/**
+ * @internal
+ */
+const empty$4 = () => _empty$2;
+const AndThenProto$2 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "AndThen"
+});
+const makeAndThen$2 = (first, second) => {
+  const o = Object.create(AndThenProto$2);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "AddService"
+});
+const makeAddService = (key, service) => {
+  const o = Object.create(AddServiceProto);
+  o.key = key;
+  o.service = service;
+  return o;
+};
+const RemoveServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "RemoveService"
+});
+const makeRemoveService = key => {
+  const o = Object.create(RemoveServiceProto);
+  o.key = key;
+  return o;
+};
+const UpdateServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "UpdateService"
+});
+const makeUpdateService = (key, update) => {
+  const o = Object.create(UpdateServiceProto);
+  o.key = key;
+  o.update = update;
   return o;
 };
-// -----------------------------------------------------------------------------
-// Refinements
-// -----------------------------------------------------------------------------
-/** @internal */
-const isCause = u => hasProperty(u, CauseTypeId);
 /** @internal */
-const isEmptyType = self => self._tag === OP_EMPTY;
+const diff$3 = (oldValue, newValue) => {
+  const missingServices = new Map(oldValue.unsafeMap);
+  let patch = empty$4();
+  for (const [tag, newService] of newValue.unsafeMap.entries()) {
+    if (missingServices.has(tag)) {
+      const old = missingServices.get(tag);
+      missingServices.delete(tag);
+      if (!equals(old, newService)) {
+        patch = combine$2(makeUpdateService(tag, () => newService))(patch);
+      }
+    } else {
+      missingServices.delete(tag);
+      patch = combine$2(makeAddService(tag, newService))(patch);
+    }
+  }
+  for (const [tag] of missingServices.entries()) {
+    patch = combine$2(makeRemoveService(tag))(patch);
+  }
+  return patch;
+};
 /** @internal */
-const isDieType = self => self._tag === OP_DIE;
+const combine$2 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$2(self, that));
 /** @internal */
-const isEmpty = self => {
-  if (self._tag === OP_EMPTY) {
-    return true;
+const patch$3 = /*#__PURE__*/dual(2, (self, context) => {
+  if (self._tag === "Empty") {
+    return context;
   }
-  return reduce(self, true, (acc, cause) => {
-    switch (cause._tag) {
-      case OP_EMPTY:
+  let wasServiceUpdated = false;
+  let patches = of$1(self);
+  const updatedContext = new Map(context.unsafeMap);
+  while (isNonEmpty(patches)) {
+    const head = headNonEmpty(patches);
+    const tail = tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
         {
-          return some(acc);
+          patches = tail;
+          break;
         }
-      case OP_DIE:
-      case OP_FAIL:
-      case OP_INTERRUPT:
+      case "AddService":
         {
-          return some(false);
+          updatedContext.set(head.key, head.service);
+          patches = tail;
+          break;
         }
-      default:
+      case "AndThen":
+        {
+          patches = prepend$1(prepend$1(tail, head.second), head.first);
+          break;
+        }
+      case "RemoveService":
+        {
+          updatedContext.delete(head.key);
+          patches = tail;
+          break;
+        }
+      case "UpdateService":
         {
-          return none$1();
+          updatedContext.set(head.key, head.update(updatedContext.get(head.key)));
+          wasServiceUpdated = true;
+          patches = tail;
+          break;
         }
     }
-  });
-};
-/** @internal */
-const isInterrupted = self => isSome(interruptOption(self));
-/** @internal */
-const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
-/** @internal */
-const failures = self => reverse(reduce(self, empty$4(), (list, cause) => cause._tag === OP_FAIL ? some(pipe(list, prepend(cause.error))) : none$1()));
-/** @internal */
-const defects = self => reverse(reduce(self, empty$4(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend(cause.defect))) : none$1()));
-/** @internal */
-const interruptors = self => reduce(self, empty$1(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none$1());
+  }
+  if (!wasServiceUpdated) {
+    return makeContext(updatedContext);
+  }
+  const map = new Map();
+  for (const [tag] of context.unsafeMap) {
+    if (updatedContext.has(tag)) {
+      map.set(tag, updatedContext.get(tag));
+      updatedContext.delete(tag);
+    }
+  }
+  for (const [tag, s] of updatedContext) {
+    map.set(tag, s);
+  }
+  return makeContext(map);
+});
+
 /** @internal */
-const failureOption = self => find(self, cause => cause._tag === OP_FAIL ? some(cause.error) : none$1());
+const HashSetPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashSetPatch");
+function variance$2(a) {
+  return a;
+}
 /** @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);
-      }
+const PatchProto$1 = {
+  ...Structural.prototype,
+  [HashSetPatchTypeId]: {
+    _Value: variance$2,
+    _Key: variance$2,
+    _Patch: variance$2
   }
 };
-/** @internal */
-const flipCauseOption = self => match(self, {
-  onEmpty: some(empty),
-  onFail: map$4(fail$1),
-  onDie: defect => some(die(defect)),
-  onInterrupt: fiberId => some(interrupt(fiberId)),
-  onSequential: mergeWith(sequential),
-  onParallel: mergeWith(parallel)
+const EmptyProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Empty"
 });
+const _empty$1 = /*#__PURE__*/Object.create(EmptyProto$1);
 /** @internal */
-const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? some(cause.fiberId) : none$1());
+const empty$3 = () => _empty$1;
+const AndThenProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "AndThen"
+});
 /** @internal */
-const stripFailures = self => match(self, {
-  onEmpty: empty,
-  onFail: () => empty,
-  onDie: die,
-  onInterrupt: interrupt,
-  onSequential: sequential,
-  onParallel: parallel
+const makeAndThen$1 = (first, second) => {
+  const o = Object.create(AndThenProto$1);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Add"
 });
 /** @internal */
-const electFailures = self => match(self, {
-  onEmpty: empty,
-  onFail: die,
-  onDie: die,
-  onInterrupt: interrupt,
-  onSequential: sequential,
-  onParallel: parallel
+const makeAdd = value => {
+  const o = Object.create(AddProto);
+  o.value = value;
+  return o;
+};
+const RemoveProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Remove"
 });
 /** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, e => fail$1(f(e))));
-// -----------------------------------------------------------------------------
-// Sequencing
-// -----------------------------------------------------------------------------
+const makeRemove = value => {
+  const o = Object.create(RemoveProto);
+  o.value = value;
+  return o;
+};
 /** @internal */
-const flatMap$1 = /*#__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)
-}));
+const diff$2 = (oldValue, newValue) => {
+  const [removed, patch] = reduce$3([oldValue, empty$3()], ([set, patch], value) => {
+    if (has(value)(set)) {
+      return [remove(value)(set), patch];
+    }
+    return [set, combine$1(makeAdd(value))(patch)];
+  })(newValue);
+  return reduce$3(patch, (patch, value) => combine$1(makeRemove(value))(patch))(removed);
+};
 /** @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$1(), empty$4()], ([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$1(), empty$4()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
-    }));
-    if (!equals(leftParallel, rightParallel)) {
-      return false;
+const combine$1 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$1(self, that));
+/** @internal */
+const patch$2 = /*#__PURE__*/dual(2, (self, oldValue) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let set = oldValue;
+  let patches = of$1(self);
+  while (isNonEmpty(patches)) {
+    const head = headNonEmpty(patches);
+    const tail = tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = prepend$1(head.first)(prepend$1(head.second)(tail));
+          break;
+        }
+      case "Add":
+        {
+          set = add(head.value)(set);
+          patches = tail;
+          break;
+        }
+      case "Remove":
+        {
+          set = remove(head.value)(set);
+          patches = tail;
+        }
     }
-    leftStack = leftSequential;
-    rightStack = rightSequential;
   }
-  return true;
+  return set;
+});
+
+/** @internal */
+const ReadonlyArrayPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferReadonlyArrayPatch");
+function variance$1(a) {
+  return a;
+}
+const PatchProto = {
+  ...Structural.prototype,
+  [ReadonlyArrayPatchTypeId]: {
+    _Value: variance$1,
+    _Patch: variance$1
+  }
 };
-// -----------------------------------------------------------------------------
-// Flattening
-// -----------------------------------------------------------------------------
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
 /**
- * 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$4());
-};
+const empty$2 = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AppendProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Append"
+});
+const makeAppend = values => {
+  const o = Object.create(AppendProto);
+  o.values = values;
+  return o;
+};
+const SliceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Slice"
+});
+const makeSlice = (from, until) => {
+  const o = Object.create(SliceProto);
+  o.from = from;
+  o.until = until;
+  return o;
+};
+const UpdateProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Update"
+});
+const makeUpdate = (index, patch) => {
+  const o = Object.create(UpdateProto);
+  o.index = index;
+  o.patch = patch;
+  return o;
+};
 /** @internal */
-const flattenCauseLoop = (causes, flattened) => {
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = pipe(causes, reduce$5([empty$1(), empty$4()], ([parallel, sequential], cause) => {
-      const [par, seq] = evaluateCause(cause);
-      return [pipe(parallel, union(par)), pipe(sequential, appendAll(seq))];
-    }));
-    const updated = size(parallel) > 0 ? pipe(flattened, prepend(parallel)) : flattened;
-    if (isEmpty$2(sequential)) {
-      return reverse(updated);
+const diff$1 = options => {
+  let i = 0;
+  let patch = empty$2();
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = options.oldValue[i];
+    const newElement = options.newValue[i];
+    const valuePatch = options.differ.diff(oldElement, newElement);
+    if (!equals(valuePatch, options.differ.empty)) {
+      patch = combine(patch, makeUpdate(i, valuePatch));
     }
-    causes = sequential;
-    flattened = updated;
+    i = i + 1;
   }
-  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
+  if (i < options.oldValue.length) {
+    patch = combine(patch, makeSlice(0, i));
+  }
+  if (i < options.newValue.length) {
+    patch = combine(patch, makeAppend(drop$1(i)(options.newValue)));
+  }
+  return patch;
 };
-// -----------------------------------------------------------------------------
-// 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;
-        }
-    }
+const combine = /*#__PURE__*/dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+const patch$1 = /*#__PURE__*/dual(3, (self, oldValue, differ) => {
+  if (self._tag === "Empty") {
+    return oldValue;
   }
-  return none$1();
-});
-// -----------------------------------------------------------------------------
-// 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$1();
-  let _sequential = empty$4();
-  while (cause !== undefined) {
-    switch (cause._tag) {
-      case OP_EMPTY:
-        {
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
-          break;
-        }
-      case OP_FAIL:
+  let readonlyArray = oldValue.slice();
+  let patches = of$2(self);
+  while (isNonEmptyArray(patches)) {
+    const head = headNonEmpty$1(patches);
+    const tail = tailNonEmpty$1(patches);
+    switch (head._tag) {
+      case "Empty":
         {
-          _parallel = add(_parallel, make$4(cause._tag, cause.error));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
+          patches = tail;
           break;
         }
-      case OP_DIE:
+      case "AndThen":
         {
-          _parallel = add(_parallel, make$4(cause._tag, cause.defect));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
-          }
-          cause = stack.pop();
+          tail.unshift(head.first, head.second);
+          patches = tail;
           break;
         }
-      case OP_INTERRUPT:
+      case "Append":
         {
-          _parallel = add(_parallel, make$4(cause._tag, cause.fiberId));
-          if (stack.length === 0) {
-            return [_parallel, _sequential];
+          for (const value of head.values) {
+            readonlyArray.push(value);
           }
-          cause = stack.pop();
+          patches = tail;
           break;
         }
-      case OP_SEQUENTIAL:
+      case "Slice":
         {
-          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 = prepend(_sequential, cause.right);
-                cause = cause.left;
-                break;
-              }
-          }
+          readonlyArray = readonlyArray.slice(head.from, head.until);
+          patches = tail;
           break;
         }
-      case OP_PARALLEL:
+      case "Update":
         {
-          stack.push(cause.right);
-          cause = cause.left;
+          readonlyArray[head.index] = differ.patch(head.patch, readonlyArray[head.index]);
+          patches = tail;
           break;
         }
     }
   }
-  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
+  return readonlyArray;
+});
+
+/** @internal */
+const DifferTypeId = /*#__PURE__*/Symbol.for("effect/Differ");
+/** @internal */
+const DifferProto = {
+  [DifferTypeId]: {
+    _P: identity,
+    _V: identity
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
 };
 /** @internal */
-const IsInterruptedOnlyCauseReducer = {
-  emptyCase: constTrue,
-  failCase: constFalse,
-  dieCase: constFalse,
-  interruptCase: constTrue,
-  sequentialCase: (_, left, right) => left && right,
-  parallelCase: (_, left, right) => left && right
+const make$2 = params => {
+  const differ = Object.create(DifferProto);
+  differ.empty = params.empty;
+  differ.diff = params.diff;
+  differ.combine = params.combine;
+  differ.patch = params.patch;
+  return differ;
 };
-const OP_SEQUENTIAL_CASE = "SequentialCase";
-const OP_PARALLEL_CASE = "ParallelCase";
 /** @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)
-  });
+const environment = () => make$2({
+  empty: empty$4(),
+  combine: (first, second) => combine$2(second)(first),
+  diff: (oldValue, newValue) => diff$3(oldValue, newValue),
+  patch: (patch, oldValue) => patch$3(oldValue)(patch)
 });
 /** @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;
-        }
+const hashSet = () => make$2({
+  empty: empty$3(),
+  combine: (first, second) => combine$1(second)(first),
+  diff: (oldValue, newValue) => diff$2(oldValue, newValue),
+  patch: (patch, oldValue) => patch$2(oldValue)(patch)
+});
+/** @internal */
+const readonlyArray = differ => make$2({
+  empty: empty$2(),
+  combine: (first, second) => combine(first, second),
+  diff: (oldValue, newValue) => diff$1({
+    oldValue,
+    newValue,
+    differ
+  }),
+  patch: (patch, oldValue) => patch$1(patch, oldValue, differ)
+});
+/** @internal */
+const update = () => updateWith((_, a) => a);
+/** @internal */
+const updateWith = f => make$2({
+  empty: identity,
+  combine: (first, second) => {
+    if (first === identity) {
+      return second;
     }
-    if (cause === undefined && causes.length > 0) {
-      cause = causes.pop();
+    if (second === identity) {
+      return first;
     }
-  }
-  return accumulator;
+    return a => second(first(a));
+  },
+  diff: (oldValue, newValue) => {
+    if (equals(oldValue, newValue)) {
+      return identity;
+    }
+    return constant(newValue);
+  },
+  patch: (patch, oldValue) => f(oldValue, patch(oldValue))
 });
+
 /** @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;
+const BIT_MASK = 0xff;
+/** @internal */
+const BIT_SHIFT = 0x08;
+/** @internal */
+const active = patch => patch & BIT_MASK;
+/** @internal */
+const enabled = patch => patch >> BIT_SHIFT & BIT_MASK;
+/** @internal */
+const make$1 = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
+/** @internal */
+const empty$1 = /*#__PURE__*/make$1(0, 0);
+/** @internal */
+const enable$2 = flag => make$1(flag, flag);
+/** @internal */
+const disable$1 = flag => make$1(flag, 0);
+/** @internal */
+const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$1(active(self) & ~flag, enabled(self)));
+/** @internal */
+const andThen = /*#__PURE__*/dual(2, (self, that) => self | that);
+/** @internal */
+const invert = n => ~n >>> 0 & BIT_MASK;
+
+/** @internal */
+const None = 0;
+/** @internal */
+const Interruption = 1 << 0;
+/** @internal */
+const OpSupervision = 1 << 1;
+/** @internal */
+const RuntimeMetrics = 1 << 2;
+/** @internal */
+const WindDown = 1 << 4;
+/** @internal */
+const CooperativeYielding = 1 << 5;
+/** @internal */
+const cooperativeYielding = self => isEnabled(self, CooperativeYielding);
+/** @internal */
+const enable$1 = /*#__PURE__*/dual(2, (self, flag) => self | flag);
+/** @internal */
+const interruptible$2 = self => interruption(self) && !windDown(self);
+/** @internal */
+const interruption = self => isEnabled(self, Interruption);
+/** @internal */
+const isEnabled = /*#__PURE__*/dual(2, (self, flag) => (self & flag) !== 0);
+/** @internal */
+const make = (...flags) => flags.reduce((a, b) => a | b, 0);
+/** @internal */
+const none = /*#__PURE__*/make(None);
+/** @internal */
+const runtimeMetrics = self => isEnabled(self, RuntimeMetrics);
+const windDown = self => isEnabled(self, WindDown);
+/** @internal */
+const diff = /*#__PURE__*/dual(2, (self, that) => make$1(self ^ that, that));
+/** @internal */
+const patch = /*#__PURE__*/dual(2, (self, patch) => self & (invert(active(patch)) | enabled(patch)) | active(patch) & enabled(patch));
+/** @internal */
+const differ = /*#__PURE__*/make$2({
+  empty: empty$1,
+  diff: (oldValue, newValue) => diff(oldValue, newValue),
+  combine: (first, second) => andThen(second)(first),
+  patch: (_patch, oldValue) => patch(oldValue, _patch)
+});
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * Creates a `RuntimeFlagsPatch` describing enabling the provided `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const enable = enable$2;
+/**
+ * Creates a `RuntimeFlagsPatch` describing disabling the provided `RuntimeFlag`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const disable = disable$1;
+/**
+ * Creates a `RuntimeFlagsPatch` which describes exclusion of the specified
+ * `RuntimeFlag` from the set of `RuntimeFlags`.
+ *
+ * @category utils
+ * @since 2.0.0
+ */
+const exclude = exclude$1;
+
+/** @internal */
+const OP_DIE = "Die";
+/** @internal */
+const OP_EMPTY = "Empty";
+/** @internal */
+const OP_FAIL = "Fail";
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+/** @internal */
+const OP_PARALLEL = "Parallel";
+/** @internal */
+const OP_SEQUENTIAL = "Sequential";
+
+// -----------------------------------------------------------------------------
+// Models
+// -----------------------------------------------------------------------------
+/** @internal */
+const CauseSymbolKey = "effect/Cause";
+/** @internal */
+const CauseTypeId = /*#__PURE__*/Symbol.for(CauseSymbolKey);
+const variance = {
+  /* c8 ignore next */
+  _E: _ => _
+};
+/** @internal */
+const proto = {
+  [CauseTypeId]: variance,
+  [symbol$1]() {
+    return pipe(hash(CauseSymbolKey), combine$5(hash(flattenCause(this))), cached(this));
+  },
+  [symbol](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,
+          left: toJSON(this.left),
+          right: toJSON(this.right)
+        };
+    }
+  },
+  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$2 = error => {
+  const o = Object.create(proto);
+  o._tag = OP_FAIL;
+  o.error = error;
+  return o;
+};
+/** @internal */
+const die$1 = defect => {
+  const o = Object.create(proto);
+  o._tag = OP_DIE;
+  o.defect = defect;
+  return o;
+};
+/** @internal */
+const interrupt$1 = fiberId => {
+  const o = Object.create(proto);
+  o._tag = OP_INTERRUPT;
+  o.fiberId = fiberId;
+  return o;
+};
+/** @internal */
+const parallel = (left, right) => {
+  const o = Object.create(proto);
+  o._tag = OP_PARALLEL;
+  o.left = left;
+  o.right = right;
+  return o;
+};
+/** @internal */
+const sequential = (left, right) => {
+  const o = Object.create(proto);
+  o._tag = OP_SEQUENTIAL;
+  o.left = left;
+  o.right = right;
+  return o;
+};
+// -----------------------------------------------------------------------------
+// Refinements
+// -----------------------------------------------------------------------------
+/** @internal */
+const isCause = u => hasProperty(u, CauseTypeId);
+/** @internal */
+const isEmptyType = self => self._tag === OP_EMPTY;
+/** @internal */
+const isDieType = self => self._tag === OP_DIE;
+/** @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$3();
+        }
+    }
+  });
+};
+/** @internal */
+const isInterrupted = self => isSome(interruptOption(self));
+/** @internal */
+const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
+/** @internal */
+const failures = self => reverse$1(reduce(self, empty$a(), (list, cause) => cause._tag === OP_FAIL ? some(pipe(list, prepend$1(cause.error))) : none$3()));
+/** @internal */
+const defects = self => reverse$1(reduce(self, empty$a(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend$1(cause.defect))) : none$3()));
+/** @internal */
+const interruptors = self => reduce(self, empty$7(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none$3());
+/** @internal */
+const failureOption = self => find(self, cause => cause._tag === OP_FAIL ? some(cause.error) : none$3());
+/** @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 flipCauseOption = self => match(self, {
+  onEmpty: some(empty),
+  onFail: map$6(fail$2),
+  onDie: defect => some(die$1(defect)),
+  onInterrupt: fiberId => some(interrupt$1(fiberId)),
+  onSequential: mergeWith(sequential),
+  onParallel: mergeWith(parallel)
+});
+/** @internal */
+const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? some(cause.fiberId) : none$3());
+/** @internal */
+const stripFailures = self => match(self, {
+  onEmpty: empty,
+  onFail: () => empty,
+  onDie: die$1,
+  onInterrupt: interrupt$1,
+  onSequential: sequential,
+  onParallel: parallel
+});
+/** @internal */
+const electFailures = self => match(self, {
+  onEmpty: empty,
+  onFail: die$1,
+  onDie: die$1,
+  onInterrupt: interrupt$1,
+  onSequential: sequential,
+  onParallel: parallel
+});
+/** @internal */
+const map$1 = /*#__PURE__*/dual(2, (self, f) => flatMap$2(self, e => fail$2(f(e))));
+// -----------------------------------------------------------------------------
+// Sequencing
+// -----------------------------------------------------------------------------
+/** @internal */
+const flatMap$2 = /*#__PURE__*/dual(2, (self, f) => match(self, {
+  onEmpty: empty,
+  onFail: error => f(error),
+  onDie: defect => die$1(defect),
+  onInterrupt: fiberId => interrupt$1(fiberId),
+  onSequential: (left, right) => sequential(left, right),
+  onParallel: (left, right) => parallel(left, right)
+}));
+/** @internal */
+const causeEquals = (left, right) => {
+  let leftStack = of$1(left);
+  let rightStack = of$1(right);
+  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce([empty$7(), empty$a()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll$1(seq))]);
+    }));
+    const [rightParallel, rightSequential] = pipe(headNonEmpty(rightStack), reduce([empty$7(), empty$a()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll$1(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$1(cause), empty$a());
+};
+/** @internal */
+const flattenCauseLoop = (causes, flattened) => {
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = pipe(causes, reduce$7([empty$7(), empty$a()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return [pipe(parallel, union(par)), pipe(sequential, appendAll$1(seq))];
+    }));
+    const updated = size(parallel) > 0 ? pipe(flattened, prepend$1(parallel)) : flattened;
+    if (isEmpty$3(sequential)) {
+      return reverse$1(updated);
+    }
+    causes = sequential;
+    flattened = updated;
+  }
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
+};
+// -----------------------------------------------------------------------------
+// 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$3();
+});
+// -----------------------------------------------------------------------------
+// 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$7();
+  let _sequential = empty$a();
+  while (cause !== undefined) {
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          cause = stack.pop();
+          break;
+        }
+      case OP_FAIL:
+        {
+          _parallel = add(_parallel, make$7(cause._tag, cause.error));
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          cause = stack.pop();
+          break;
+        }
+      case OP_DIE:
+        {
+          _parallel = add(_parallel, make$7(cause._tag, cause.defect));
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          cause = stack.pop();
+          break;
+        }
+      case OP_INTERRUPT:
+        {
+          _parallel = add(_parallel, make$7(cause._tag, cause.fiberId));
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          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 = prepend$1(_sequential, cause.right);
+                cause = cause.left;
+                break;
+              }
+          }
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          stack.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+    }
+  }
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
+};
+/** @internal */
+const IsInterruptedOnlyCauseReducer = {
+  emptyCase: constTrue,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: constTrue,
+  sequentialCase: (_, left, right) => left && right,
+  parallelCase: (_, left, right) => left && right
+};
+const OP_SEQUENTIAL_CASE = "SequentialCase";
+const OP_PARALLEL_CASE = "ParallelCase";
+/** @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;
+          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/effect/issues");
+  }
+  return accumulator.pop();
+});
+// -----------------------------------------------------------------------------
+// Pretty Printing
+// -----------------------------------------------------------------------------
+/** @internal */
+const pretty = (cause, options) => {
+  if (isInterruptedOnly(cause)) {
+    return "All fibers interrupted without errors.";
+  }
+  return prettyErrors(cause).map(function (e) {
+    if (options?.renderErrorCause !== true || e.cause === undefined) {
+      return e.stack;
+    }
+    return `${e.stack} {\n${renderErrorCause(e.cause, "  ")}\n}`;
+  }).join("\n");
+};
+const renderErrorCause = (cause, prefix) => {
+  const lines = cause.stack.split("\n");
+  let stack = `${prefix}[cause]: ${lines[0]}`;
+  for (let i = 1, len = lines.length; i < len; i++) {
+    stack += `\n${prefix}${lines[i]}`;
+  }
+  if (cause.cause) {
+    stack += ` {\n${renderErrorCause(cause.cause, `${prefix}  `)}\n${prefix}}`;
+  }
+  return stack;
+};
+/** @internal */
+const makePrettyError = originalError => {
+  const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
+  const prevLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 1;
+  const error = new Error(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
+    cause: makePrettyError(originalError.cause)
+  } : undefined);
+  Error.stackTraceLimit = prevLimit;
+  if (error.message === "") {
+    error.message = "An error has occurred";
+  }
+  Error.stackTraceLimit = prevLimit;
+  error.name = originalError instanceof Error ? originalError.name : "Error";
+  if (originalErrorIsObject) {
+    if (spanSymbol in originalError) {
+      error.span = originalError[spanSymbol];
+    }
+    Object.keys(originalError).forEach(key => {
+      if (!(key in error)) {
+        // @ts-expect-error
+        error[key] = originalError[key];
+      }
+    });
+  }
+  error.stack = prettyErrorStack(`${error.name}: ${error.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", error.span);
+  return error;
+};
+/**
+ * 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.
+ * 2) If `u` is an Error instance with a message defined, it uses the message.
+ * 3) If `u` has a user-defined `toString()` method, it uses that method.
+ * 4) Otherwise, it uses `Inspectable.stringifyCircular` 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 u;
+  }
+  // 2)
+  if (typeof u === "object" && u !== null && u instanceof Error) {
+    return u.message;
+  }
+  // 3)
+  try {
+    if (hasProperty(u, "toString") && isFunction(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
+      return u["toString"]();
+    }
+  } catch {
+    // something's off, rollback to json
+  }
+  // 4)
+  return stringifyCircular(u);
+};
+const locationRegex = /\((.*)\)/g;
+/** @internal */
+const spanToTrace = /*#__PURE__*/globalValue("effect/Tracer/spanToTrace", () => new WeakMap());
+const prettyErrorStack = (message, stack, span) => {
+  const out = [message];
+  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
+      i++;
+      continue;
+    }
+    if (lines[i].includes("Generator.next")) {
+      break;
+    }
+    if (lines[i].includes("effect_internal_function")) {
+      break;
+    }
+    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
+  }
+  if (span) {
+    let current = span;
+    let i = 0;
+    while (current && current._tag === "Span" && i < 10) {
+      const stackFn = spanToTrace.get(current);
+      if (typeof stackFn === "function") {
+        const stack = stackFn();
+        if (typeof stack === "string") {
+          const locationMatchAll = stack.matchAll(locationRegex);
+          let match = false;
+          for (const [, location] of locationMatchAll) {
+            match = true;
+            out.push(`    at ${current.name} (${location})`);
+          }
+          if (!match) {
+            out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`);
+          }
+        } else {
+          out.push(`    at ${current.name}`);
+        }
+      } else {
+        out.push(`    at ${current.name}`);
+      }
+      current = getOrUndefined(current.parent);
+      i++;
+    }
+  }
+  return out.join("\n");
+};
+/** @internal */
+const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
+/** @internal */
+const prettyErrors = cause => reduceWithContext(cause, void 0, {
+  emptyCase: () => [],
+  dieCase: (_, unknownError) => {
+    return [makePrettyError(unknownError)];
+  },
+  failCase: (_, error) => {
+    return [makePrettyError(error)];
+  },
+  interruptCase: () => [],
+  parallelCase: (_, l, r) => [...l, ...r],
+  sequentialCase: (_, l, r) => [...l, ...r]
+});
+
+/** @internal */
+const OP_STATE_PENDING = "Pending";
+/** @internal */
+const OP_STATE_DONE = "Done";
+
+/** @internal */
+const DeferredSymbolKey = "effect/Deferred";
+/** @internal */
+const DeferredTypeId = /*#__PURE__*/Symbol.for(DeferredSymbolKey);
+/** @internal */
+const deferredVariance = {
+  /* c8 ignore next */
+  _E: _ => _,
+  /* c8 ignore next */
+  _A: _ => _
+};
+/** @internal */
+const pending = joiners => {
+  return {
+    _tag: OP_STATE_PENDING,
+    joiners
+  };
+};
+/** @internal */
+const done = effect => {
+  return {
+    _tag: OP_STATE_DONE,
+    effect
+  };
+};
+
+/** @internal */
+class SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  return(a) {
+    return {
+      value: a,
+      done: true
+    };
+  }
+  throw(e) {
+    throw e;
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this.self);
+  }
+}
+
+// -----------------------------------------------------------------------------
+// Effect
+// -----------------------------------------------------------------------------
+/**
+ * @internal
+ */
+const blocked = (blockedRequests, _continue) => {
+  const effect = new EffectPrimitive("Blocked");
+  effect.effect_instruction_i0 = blockedRequests;
+  effect.effect_instruction_i1 = _continue;
+  return effect;
+};
+/**
+ * @internal
+ */
+const runRequestBlock = blockedRequests => {
+  const effect = new EffectPrimitive("RunBlocked");
+  effect.effect_instruction_i0 = blockedRequests;
+  return effect;
+};
+/** @internal */
+const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
+/** @internal */
+class RevertFlags {
+  patch;
+  op;
+  _op = OP_REVERT_FLAGS;
+  constructor(patch, op) {
+    this.patch = patch;
+    this.op = op;
+  }
+}
+class EffectPrimitive {
+  _op;
+  effect_instruction_i0 = undefined;
+  effect_instruction_i1 = undefined;
+  effect_instruction_i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+  }
+  [symbol](that) {
+    return this === that;
+  }
+  [symbol$1]() {
+    return cached(this, random(this));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Effect",
+      _op: this._op,
+      effect_instruction_i0: toJSON(this.effect_instruction_i0),
+      effect_instruction_i1: toJSON(this.effect_instruction_i1),
+      effect_instruction_i2: toJSON(this.effect_instruction_i2)
+    };
+  }
+  toString() {
+    return format$1(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  }
+}
+/** @internal */
+class EffectPrimitiveFailure {
+  _op;
+  effect_instruction_i0 = undefined;
+  effect_instruction_i1 = undefined;
+  effect_instruction_i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    // @ts-expect-error
+    this._tag = _op;
+  }
+  [symbol](that) {
+    return exitIsExit(that) && that._op === "Failure" &&
+    // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol$1]() {
+    return pipe(
+    // @ts-expect-error
+    string(this._tag),
+    // @ts-expect-error
+    combine$5(hash(this.effect_instruction_i0)), cached(this));
+  }
+  get cause() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      cause: this.cause.toJSON()
+    };
+  }
+  toString() {
+    return format$1(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  }
+}
+/** @internal */
+class EffectPrimitiveSuccess {
+  _op;
+  effect_instruction_i0 = undefined;
+  effect_instruction_i1 = undefined;
+  effect_instruction_i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    // @ts-expect-error
+    this._tag = _op;
+  }
+  [symbol](that) {
+    return exitIsExit(that) && that._op === "Success" &&
+    // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol$1]() {
+    return pipe(
+    // @ts-expect-error
+    string(this._tag),
+    // @ts-expect-error
+    combine$5(hash(this.effect_instruction_i0)), cached(this));
+  }
+  get value() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      value: toJSON(this.value)
+    };
+  }
+  toString() {
+    return format$1(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  }
+}
+/** @internal */
+const isEffect = u => hasProperty(u, EffectTypeId);
+/* @internal */
+const withFiberRuntime = withRuntime => {
+  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
+  effect.effect_instruction_i0 = withRuntime;
+  return effect;
+};
+/* @internal */
+const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask$1(restore => flatMap$1(acquire, a => flatMap$1(exit(suspend$1(() => restore(use(a)))), exit => {
+  return suspend$1(() => release(a, exit)).pipe(matchCauseEffect$1({
+    onFailure: cause => {
+      switch (exit._tag) {
+        case OP_FAILURE:
+          return failCause$1(sequential(exit.effect_instruction_i0, cause));
+        case OP_SUCCESS:
+          return failCause$1(cause);
+      }
+    },
+    onSuccess: () => exit
+  }));
+}))));
+/* @internal */
+const as = /*#__PURE__*/dual(2, (self, value) => flatMap$1(self, () => succeed$1(value)));
+/* @internal */
+const asVoid = self => as(self, void 0);
+/* @internal */
+const custom = function () {
+  const wrapper = new EffectPrimitive(OP_COMMIT);
+  switch (arguments.length) {
+    case 2:
+      {
+        wrapper.effect_instruction_i0 = arguments[0];
+        wrapper.commit = arguments[1];
+        break;
+      }
+    case 3:
+      {
+        wrapper.effect_instruction_i0 = arguments[0];
+        wrapper.effect_instruction_i1 = arguments[1];
+        wrapper.commit = arguments[2];
+        break;
+      }
+    case 4:
+      {
+        wrapper.effect_instruction_i0 = arguments[0];
+        wrapper.effect_instruction_i1 = arguments[1];
+        wrapper.effect_instruction_i2 = arguments[2];
+        wrapper.commit = arguments[3];
+        break;
+      }
+    default:
+      {
+        throw new Error(getBugErrorMessage("you're not supposed to end up here"));
+      }
+  }
+  return wrapper;
+};
+/* @internal */
+const unsafeAsync = (register, blockingOn = none$1) => {
+  const effect = new EffectPrimitive(OP_ASYNC);
+  let cancelerRef = undefined;
+  effect.effect_instruction_i0 = resume => {
+    cancelerRef = register(resume);
+  };
+  effect.effect_instruction_i1 = blockingOn;
+  return onInterrupt(effect, _ => isEffect(cancelerRef) ? cancelerRef : void_$1);
+};
+/* @internal */
+const asyncInterrupt = (register, blockingOn = none$1) => suspend$1(() => unsafeAsync(register, blockingOn));
+const async_ = (resume, blockingOn = none$1) => {
+  return custom(resume, function () {
+    let backingResume = undefined;
+    let pendingEffect = undefined;
+    function proxyResume(effect) {
+      if (backingResume) {
+        backingResume(effect);
+      } else if (pendingEffect === undefined) {
+        pendingEffect = effect;
+      }
+    }
+    const effect = new EffectPrimitive(OP_ASYNC);
+    effect.effect_instruction_i0 = resume => {
+      backingResume = resume;
+      if (pendingEffect) {
+        resume(pendingEffect);
+      }
+    };
+    effect.effect_instruction_i1 = blockingOn;
+    let cancelerRef = undefined;
+    let controllerRef = undefined;
+    if (this.effect_instruction_i0.length !== 1) {
+      controllerRef = new AbortController();
+      cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume, controllerRef.signal));
+    } else {
+      cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume));
+    }
+    return cancelerRef || controllerRef ? onInterrupt(effect, _ => {
+      if (controllerRef) {
+        controllerRef.abort();
+      }
+      return cancelerRef ?? void_$1;
+    }) : effect;
+  });
+};
+/* @internal */
+const catchAllCause = /*#__PURE__*/dual(2, (self, f) => {
+  const effect = new EffectPrimitive(OP_ON_FAILURE);
+  effect.effect_instruction_i0 = self;
+  effect.effect_instruction_i1 = f;
+  return effect;
+});
+/* @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
+  onFailure: f,
+  onSuccess: succeed$1
+}));
+const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
+/* @internal */
+const capture = (obj, span) => {
+  if (isSome(span)) {
+    return new Proxy(obj, {
+      has(target, p) {
+        return p === spanSymbol || p === originalSymbol || p in target;
+      },
+      get(target, p) {
+        if (p === spanSymbol) {
+          return span.value;
+        }
+        if (p === originalSymbol) {
+          return obj;
+        }
+        // @ts-expect-error
+        return target[p];
+      }
+    });
+  }
+  return obj;
+};
+/* @internal */
+const die = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause$1(die$1(capture(defect, currentSpanFromFiber(fiber))))) : failCause$1(die$1(defect));
+/* @internal */
+const dieMessage = message => failCauseSync(() => die$1(new RuntimeException(message)));
+/* @internal */
+const either = self => matchEffect(self, {
+  onFailure: e => succeed$1(left(e)),
+  onSuccess: a => succeed$1(right(a))
+});
+/* @internal */
+const exit = self => matchCause(self, {
+  onFailure: exitFailCause$1,
+  onSuccess: exitSucceed$1
+});
+/* @internal */
+const fail$1 = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause$1(fail$2(capture(error, currentSpanFromFiber(fiber))))) : failCause$1(fail$2(error));
+/* @internal */
+const failSync = evaluate => flatMap$1(sync(evaluate), fail$1);
+/* @internal */
+const failCause$1 = cause => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.effect_instruction_i0 = cause;
+  return effect;
+};
+/* @internal */
+const failCauseSync = evaluate => flatMap$1(sync(evaluate), failCause$1);
+/* @internal */
+const fiberId = /*#__PURE__*/withFiberRuntime(state => succeed$1(state.id()));
+/* @internal */
+const fiberIdWith = f => withFiberRuntime(state => f(state.id()));
+/* @internal */
+const flatMap$1 = /*#__PURE__*/dual(2, (self, f) => {
+  const effect = new EffectPrimitive(OP_ON_SUCCESS);
+  effect.effect_instruction_i0 = self;
+  effect.effect_instruction_i1 = f;
+  return effect;
+});
+/* @internal */
+const step = self => {
+  const effect = new EffectPrimitive("OnStep");
+  effect.effect_instruction_i0 = self;
+  return effect;
+};
+/* @internal */
+const flatten = self => flatMap$1(self, identity);
+/* @internal */
+const matchCause = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$1(self, {
+  onFailure: cause => succeed$1(options.onFailure(cause)),
+  onSuccess: a => succeed$1(options.onSuccess(a))
+}));
+/* @internal */
+const matchCauseEffect$1 = /*#__PURE__*/dual(2, (self, options) => {
+  const effect = new EffectPrimitive(OP_ON_SUCCESS_AND_FAILURE);
+  effect.effect_instruction_i0 = self;
+  effect.effect_instruction_i1 = options.onFailure;
+  effect.effect_instruction_i2 = options.onSuccess;
+  return effect;
+});
+/* @internal */
+const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$1(self, {
+  onFailure: cause => {
+    const defects$1 = defects(cause);
+    if (defects$1.length > 0) {
+      return failCause$1(electFailures(cause));
+    }
+    const failures$1 = failures(cause);
+    if (failures$1.length > 0) {
+      return options.onFailure(unsafeHead(failures$1));
+    }
+    return failCause$1(cause);
+  },
+  onSuccess: options.onSuccess
+}));
+/* @internal */
+const forEachSequential = /*#__PURE__*/dual(2, (self, f) => suspend$1(() => {
+  const arr = fromIterable$5(self);
+  const ret = allocate(arr.length);
+  let i = 0;
+  return as(whileLoop({
+    while: () => i < arr.length,
+    body: () => f(arr[i], i),
+    step: b => {
+      ret[i++] = b;
+    }
+  }), ret);
+}));
+/* @internal */
+const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspend$1(() => {
+  const arr = fromIterable$5(self);
+  let i = 0;
+  return whileLoop({
+    while: () => i < arr.length,
+    body: () => f(arr[i], i),
+    step: () => {
+      i++;
+    }
+  });
+}));
+/* @internal */
+const interrupt = /*#__PURE__*/flatMap$1(fiberId, fiberId => interruptWith(fiberId));
+/* @internal */
+const interruptWith = fiberId => failCause$1(interrupt$1(fiberId));
+/* @internal */
+const interruptible$1 = self => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.effect_instruction_i0 = enable(Interruption);
+  effect.effect_instruction_i1 = () => self;
+  return effect;
+};
+/* @internal */
+const intoDeferred = /*#__PURE__*/dual(2, (self, deferred) => uninterruptibleMask$1(restore => flatMap$1(exit(restore(self)), exit => deferredDone(deferred, exit))));
+/* @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, a => sync(() => f(a))));
+/* @internal */
+const mapBoth = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
+  onFailure: e => failSync(() => options.onFailure(e)),
+  onSuccess: a => sync(() => options.onSuccess(a))
+}));
+/* @internal */
+const mapError = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$1(self, {
+  onFailure: cause => {
+    const either = failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return failSync(() => f(either.left));
+        }
+      case "Right":
+        {
+          return failCause$1(either.right);
         }
     }
+  },
+  onSuccess: succeed$1
+}));
+/* @internal */
+const onExit$1 = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask$1(restore => matchCauseEffect$1(restore(self), {
+  onFailure: cause1 => {
+    const result = exitFailCause$1(cause1);
+    return matchCauseEffect$1(cleanup(result), {
+      onFailure: cause2 => exitFailCause$1(sequential(cause1, cause2)),
+      onSuccess: () => result
+    });
+  },
+  onSuccess: success => {
+    const result = exitSucceed$1(success);
+    return zipRight(cleanup(result), result);
   }
-  if (accumulator.length === 0) {
-    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues");
+})));
+/* @internal */
+const onInterrupt = /*#__PURE__*/dual(2, (self, cleanup) => onExit$1(self, exitMatch({
+  onFailure: cause => isInterruptedOnly(cause) ? asVoid(cleanup(interruptors(cause))) : void_$1,
+  onSuccess: () => void_$1
+})));
+/* @internal */
+const orDie = self => orDieWith(self, identity);
+/* @internal */
+const orDieWith = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
+  onFailure: e => die(f(e)),
+  onSuccess: succeed$1
+}));
+/* @internal */
+const succeed$1 = value => {
+  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
+  effect.effect_instruction_i0 = value;
+  return effect;
+};
+/* @internal */
+const suspend$1 = evaluate => {
+  const effect = new EffectPrimitive(OP_COMMIT);
+  effect.commit = evaluate;
+  return effect;
+};
+/* @internal */
+const sync = thunk => {
+  const effect = new EffectPrimitive(OP_SYNC);
+  effect.effect_instruction_i0 = thunk;
+  return effect;
+};
+/* @internal */
+const tap = /*#__PURE__*/dual(args => args.length === 3 || args.length === 2 && !(isObject(args[1]) && "onlyEffect" in args[1]), (self, f) => flatMap$1(self, a => {
+  const b = typeof f === "function" ? f(a) : f;
+  if (isEffect(b)) {
+    return as(b, a);
+  } else if (isPromiseLike(b)) {
+    return unsafeAsync(resume => {
+      b.then(_ => resume(succeed$1(a)), e => resume(fail$1(new UnknownException(e, "An unknown error occurred in Effect.tap"))));
+    });
   }
-  return accumulator.pop();
+  return succeed$1(a);
+}));
+/* @internal */
+const transplant = f => withFiberRuntime(state => {
+  const scopeOverride = state.getFiberRef(currentForkScopeOverride);
+  const scope = pipe(scopeOverride, getOrElse(() => state.scope()));
+  return f(fiberRefLocally(currentForkScopeOverride, some(scope)));
+});
+/* @internal */
+const uninterruptible = self => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.effect_instruction_i0 = disable(Interruption);
+  effect.effect_instruction_i1 = () => self;
+  return effect;
+};
+/* @internal */
+const uninterruptibleMask$1 = f => custom(f, function () {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.effect_instruction_i0 = disable(Interruption);
+  effect.effect_instruction_i1 = oldFlags => interruption(oldFlags) ? internalCall(() => this.effect_instruction_i0(interruptible$1)) : internalCall(() => this.effect_instruction_i0(uninterruptible));
+  return effect;
+});
+const void_$1 = /*#__PURE__*/succeed$1(void 0);
+/* @internal */
+const updateRuntimeFlags = patch => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.effect_instruction_i0 = patch;
+  effect.effect_instruction_i1 = void 0;
+  return effect;
+};
+/* @internal */
+const whenEffect = /*#__PURE__*/dual(2, (self, condition) => flatMap$1(condition, b => {
+  if (b) {
+    return pipe(self, map(some));
+  }
+  return succeed$1(none$3());
+}));
+/* @internal */
+const whileLoop = options => {
+  const effect = new EffectPrimitive(OP_WHILE);
+  effect.effect_instruction_i0 = options.while;
+  effect.effect_instruction_i1 = options.body;
+  effect.effect_instruction_i2 = options.step;
+  return effect;
+};
+/* @internal */
+const fromIterator = iterator => suspend$1(() => {
+  const effect = new EffectPrimitive(OP_ITERATOR);
+  effect.effect_instruction_i0 = iterator();
+  return effect;
+});
+/* @internal */
+const gen = function () {
+  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0]);
+  return fromIterator(() => f(pipe));
+};
+/** @internal */
+const fnUntraced = (body, ...pipeables) => Object.defineProperty(pipeables.length === 0 ? function (...args) {
+  return fromIterator(() => body.apply(this, args));
+} : function (...args) {
+  let effect = fromIterator(() => body.apply(this, args));
+  for (const x of pipeables) {
+    effect = x(effect, ...args);
+  }
+  return effect;
+}, "length", {
+  value: body.length,
+  configurable: true
+});
+/* @internal */
+const yieldNow$1 = options => {
+  const effect = new EffectPrimitive(OP_YIELD);
+  return typeof options?.priority !== "undefined" ? withSchedulingPriority(effect, options.priority) : effect;
+};
+/* @internal */
+const zip = /*#__PURE__*/dual(2, (self, that) => flatMap$1(self, a => map(that, b => [a, b])));
+/* @internal */
+const zipLeft = /*#__PURE__*/dual(2, (self, that) => flatMap$1(self, a => as(that, a)));
+/* @internal */
+const zipRight = /*#__PURE__*/dual(2, (self, that) => flatMap$1(self, () => that));
+/* @internal */
+const zipWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap$1(self, a => map(that, b => f(a, b))));
+// -----------------------------------------------------------------------------
+// Fiber
+// -----------------------------------------------------------------------------
+/* @internal */
+const interruptFiber = self => flatMap$1(fiberId, fiberId => pipe(self, interruptAsFiber(fiberId)));
+/* @internal */
+const interruptAsFiber = /*#__PURE__*/dual(2, (self, fiberId) => flatMap$1(self.interruptAsFork(fiberId), () => self.await));
+// -----------------------------------------------------------------------------
+// LogLevel
+// -----------------------------------------------------------------------------
+/** @internal */
+const logLevelAll = {
+  _tag: "All",
+  syslog: 0,
+  label: "ALL",
+  ordinal: Number.MIN_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelFatal = {
+  _tag: "Fatal",
+  syslog: 2,
+  label: "FATAL",
+  ordinal: 50000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelError = {
+  _tag: "Error",
+  syslog: 3,
+  label: "ERROR",
+  ordinal: 40000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelWarning = {
+  _tag: "Warning",
+  syslog: 4,
+  label: "WARN",
+  ordinal: 30000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelInfo = {
+  _tag: "Info",
+  syslog: 6,
+  label: "INFO",
+  ordinal: 20000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelDebug = {
+  _tag: "Debug",
+  syslog: 7,
+  label: "DEBUG",
+  ordinal: 10000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelTrace = {
+  _tag: "Trace",
+  syslog: 7,
+  label: "TRACE",
+  ordinal: 0,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const logLevelNone = {
+  _tag: "None",
+  syslog: 7,
+  label: "OFF",
+  ordinal: Number.MAX_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+// -----------------------------------------------------------------------------
+// FiberRef
+// -----------------------------------------------------------------------------
+/** @internal */
+const FiberRefSymbolKey = "effect/FiberRef";
+/** @internal */
+const FiberRefTypeId = /*#__PURE__*/Symbol.for(FiberRefSymbolKey);
+const fiberRefVariance = {
+  /* c8 ignore next */
+  _A: _ => _
+};
+/* @internal */
+const fiberRefGet = self => withFiberRuntime(fiber => exitSucceed$1(fiber.getFiberRef(self)));
+/* @internal */
+const fiberRefGetWith = /*#__PURE__*/dual(2, (self, f) => flatMap$1(fiberRefGet(self), f));
+/* @internal */
+const fiberRefSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(self, () => [void 0, value]));
+/* @internal */
+const fiberRefModify = /*#__PURE__*/dual(2, (self, f) => withFiberRuntime(state => {
+  const [b, a] = f(state.getFiberRef(self));
+  state.setFiberRef(self, a);
+  return succeed$1(b);
+}));
+/* @internal */
+const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => acquireUseRelease(zipLeft(fiberRefGet(self), fiberRefSet(self, value)), () => use, oldValue => fiberRefSet(self, oldValue)));
+/* @internal */
+const fiberRefLocallyWith = /*#__PURE__*/dual(3, (use, self, f) => fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))));
+/** @internal */
+const fiberRefUnsafeMake = (initial, options) => fiberRefUnsafeMakePatch(initial, {
+  differ: update(),
+  fork: options?.fork ?? identity,
+  join: options?.join
+});
+/** @internal */
+const fiberRefUnsafeMakeHashSet = initial => {
+  const differ = hashSet();
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  });
+};
+/** @internal */
+const fiberRefUnsafeMakeReadonlyArray = initial => {
+  const differ = readonlyArray(update());
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  });
+};
+/** @internal */
+const fiberRefUnsafeMakeContext = initial => {
+  const differ = environment();
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  });
+};
+/** @internal */
+const fiberRefUnsafeMakePatch = (initial, options) => {
+  const _fiberRef = {
+    ...CommitPrototype,
+    [FiberRefTypeId]: fiberRefVariance,
+    initial,
+    commit() {
+      return fiberRefGet(this);
+    },
+    diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
+    combine: (first, second) => options.differ.combine(first, second),
+    patch: patch => oldValue => options.differ.patch(patch, oldValue),
+    fork: options.fork,
+    join: options.join ?? ((_, n) => n)
+  };
+  return _fiberRef;
+};
+/** @internal */
+const fiberRefUnsafeMakeRuntimeFlags = initial => fiberRefUnsafeMakePatch(initial, {
+  differ: differ,
+  fork: differ.empty
 });
+/** @internal */
+const currentContext = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(empty$b()));
+/** @internal */
+const currentSchedulingPriority = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentSchedulingPriority"), () => fiberRefUnsafeMake(0));
+/** @internal */
+const currentMaxOpsBeforeYield = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentMaxOpsBeforeYield"), () => fiberRefUnsafeMake(2048));
+/** @internal */
+const currentLogAnnotations = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLogAnnotation"), () => fiberRefUnsafeMake(empty$6()));
+/** @internal */
+const currentLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLogLevel"), () => fiberRefUnsafeMake(logLevelInfo));
+/** @internal */
+const currentLogSpan = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(empty$5()));
+/** @internal */
+const withSchedulingPriority = /*#__PURE__*/dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
+/** @internal */
+const currentConcurrency = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentConcurrency"), () => fiberRefUnsafeMake("unbounded"));
+/**
+ * @internal
+ */
+const currentRequestBatching = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestBatching"), () => fiberRefUnsafeMake(true));
+/** @internal */
+const currentUnhandledErrorLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"), () => fiberRefUnsafeMake(some(logLevelDebug)));
+/** @internal */
+const currentVersionMismatchErrorLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/versionMismatchErrorLogLevel"), () => fiberRefUnsafeMake(some(logLevelWarning)));
+/** @internal */
+const currentMetricLabels = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(empty$d()));
+/** @internal */
+const currentForkScopeOverride = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(none$3(), {
+  fork: () => none$3(),
+  join: (parent, _) => parent
+}));
+/** @internal */
+const currentInterruptedCause = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty, {
+  fork: () => empty,
+  join: (parent, _) => parent
+}));
 // -----------------------------------------------------------------------------
-// Pretty Printing
+// Scope
 // -----------------------------------------------------------------------------
 /** @internal */
-const pretty = (cause, options) => {
-  if (isInterruptedOnly(cause)) {
-    return "All fibers interrupted without errors.";
-  }
-  return prettyErrors(cause).map(function (e) {
-    if (options?.renderErrorCause !== true || e.cause === undefined) {
-      return e.stack;
+const ScopeTypeId = /*#__PURE__*/Symbol.for("effect/Scope");
+/** @internal */
+const CloseableScopeTypeId = /*#__PURE__*/Symbol.for("effect/CloseableScope");
+/* @internal */
+const scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asVoid(finalizer));
+/* @internal */
+const scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer);
+/* @internal */
+const scopeClose = (self, exit) => self.close(exit);
+/* @internal */
+const scopeFork = (self, strategy) => self.fork(strategy);
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+/** @internal */
+const YieldableError$1 = /*#__PURE__*/function () {
+  class YieldableError extends globalThis.Error {
+    commit() {
+      return fail$1(this);
+    }
+    toJSON() {
+      const obj = {
+        ...this
+      };
+      if (this.message) obj.message = this.message;
+      if (this.cause) obj.cause = this.cause;
+      return obj;
+    }
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
+      } else if ("Bun" in globalThis) {
+        return pretty(fail$2(this), {
+          renderErrorCause: true
+        });
+      }
+      return this;
     }
-    return `${e.stack} {\n${renderErrorCause(e.cause, "  ")}\n}`;
-  }).join("\n");
-};
-const renderErrorCause = (cause, prefix) => {
-  const lines = cause.stack.split("\n");
-  let stack = `${prefix}[cause]: ${lines[0]}`;
-  for (let i = 1, len = lines.length; i < len; i++) {
-    stack += `\n${prefix}${lines[i]}`;
   }
-  if (cause.cause) {
-    stack += ` {\n${renderErrorCause(cause.cause, `${prefix}  `)}\n${prefix}}`;
+  // @effect-diagnostics-next-line floatingEffect:off
+  Object.assign(YieldableError.prototype, StructuralCommitPrototype);
+  return YieldableError;
+}();
+const makeException = (proto, tag) => {
+  class Base extends YieldableError$1 {
+    _tag = tag;
   }
-  return stack;
+  Object.assign(Base.prototype, proto);
+  Base.prototype.name = tag;
+  return Base;
 };
 /** @internal */
-const makePrettyError = originalError => {
-  const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
-  const prevLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 1;
-  const error = new Error(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
-    cause: makePrettyError(originalError.cause)
-  } : undefined);
-  Error.stackTraceLimit = prevLimit;
-  if (error.message === "") {
-    error.message = "An error has occurred";
-  }
-  Error.stackTraceLimit = prevLimit;
-  error.name = originalError instanceof Error ? originalError.name : "Error";
-  if (originalErrorIsObject) {
-    if (spanSymbol in originalError) {
-      error.span = originalError[spanSymbol];
+const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
+/** @internal */
+const RuntimeException = /*#__PURE__*/makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+/** @internal */
+const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
+/** @internal */
+const isInterruptedException = u => hasProperty(u, InterruptedExceptionTypeId);
+/** @internal */
+const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
+/** @internal */
+const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+/** @internal */
+const UnknownExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/UnknownException");
+/** @internal */
+const UnknownException = /*#__PURE__*/function () {
+  class UnknownException extends YieldableError$1 {
+    _tag = "UnknownException";
+    error;
+    constructor(cause, message) {
+      super(message ?? "An unknown error occurred", {
+        cause
+      });
+      this.error = cause;
     }
-    Object.keys(originalError).forEach(key => {
-      if (!(key in error)) {
-        // @ts-expect-error
-        error[key] = originalError[key];
+  }
+  Object.assign(UnknownException.prototype, {
+    [UnknownExceptionTypeId]: UnknownExceptionTypeId,
+    name: "UnknownException"
+  });
+  return UnknownException;
+}();
+// -----------------------------------------------------------------------------
+// Exit
+// -----------------------------------------------------------------------------
+/** @internal */
+const exitIsExit = u => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
+/** @internal */
+const exitIsFailure = self => self._tag === "Failure";
+/** @internal */
+const exitIsSuccess = self => self._tag === "Success";
+/** @internal */
+const exitAs = /*#__PURE__*/dual(2, (self, value) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause$1(self.effect_instruction_i0);
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed$1(value);
       }
-    });
   }
-  error.stack = prettyErrorStack(`${error.name}: ${error.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", error.span);
-  return error;
+});
+/** @internal */
+const exitAsVoid = self => exitAs(self, void 0);
+/** @internal */
+const exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel : sequential);
+/** @internal */
+const exitDie$1 = defect => exitFailCause$1(die$1(defect));
+/** @internal */
+const exitFail = error => exitFailCause$1(fail$2(error));
+/** @internal */
+const exitFailCause$1 = cause => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.effect_instruction_i0 = cause;
+  return effect;
 };
-/**
- * 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.
- * 2) If `u` is an Error instance with a message defined, it uses the message.
- * 3) If `u` has a user-defined `toString()` method, it uses that method.
- * 4) Otherwise, it uses `Inspectable.stringifyCircular` 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 u;
+/** @internal */
+const exitInterrupt$1 = fiberId => exitFailCause$1(interrupt$1(fiberId));
+/** @internal */
+const exitMap = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      return exitFailCause$1(self.effect_instruction_i0);
+    case OP_SUCCESS:
+      return exitSucceed$1(f(self.effect_instruction_i0));
   }
-  // 2)
-  if (typeof u === "object" && u !== null && u instanceof Error) {
-    return u.message;
+});
+/** @internal */
+const exitMatch = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      return onFailure(self.effect_instruction_i0);
+    case OP_SUCCESS:
+      return onSuccess(self.effect_instruction_i0);
   }
-  // 3)
-  try {
-    if (hasProperty(u, "toString") && isFunction(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
-      return u["toString"]();
-    }
-  } catch {
-    // something's off, rollback to json
+});
+/** @internal */
+const exitMatchEffect = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      return onFailure(self.effect_instruction_i0);
+    case OP_SUCCESS:
+      return onSuccess(self.effect_instruction_i0);
   }
-  // 4)
-  return stringifyCircular(u);
+});
+/** @internal */
+const exitSucceed$1 = value => {
+  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
+  effect.effect_instruction_i0 = value;
+  return effect;
 };
-const locationRegex = /\((.*)\)/g;
 /** @internal */
-const spanToTrace = /*#__PURE__*/globalValue("effect/Tracer/spanToTrace", () => new WeakMap());
-const prettyErrorStack = (message, stack, span) => {
-  const out = [message];
-  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
-  for (let i = 1; i < lines.length; i++) {
-    if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
-      i++;
-      continue;
-    }
-    if (lines[i].includes("Generator.next")) {
-      break;
-    }
-    if (lines[i].includes("effect_internal_function")) {
-      break;
-    }
-    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
+const exitVoid$1 = /*#__PURE__*/exitSucceed$1(void 0);
+/** @internal */
+const exitZip = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (a, a2) => [a, a2],
+  onFailure: sequential
+}));
+/** @internal */
+const exitZipRight = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (_, a2) => a2,
+  onFailure: sequential
+}));
+/** @internal */
+const exitZipWith = /*#__PURE__*/dual(3, (self, that, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        switch (that._tag) {
+          case OP_SUCCESS:
+            return exitFailCause$1(self.effect_instruction_i0);
+          case OP_FAILURE:
+            {
+              return exitFailCause$1(onFailure(self.effect_instruction_i0, that.effect_instruction_i0));
+            }
+        }
+      }
+    case OP_SUCCESS:
+      {
+        switch (that._tag) {
+          case OP_SUCCESS:
+            return exitSucceed$1(onSuccess(self.effect_instruction_i0, that.effect_instruction_i0));
+          case OP_FAILURE:
+            return exitFailCause$1(that.effect_instruction_i0);
+        }
+      }
   }
-  if (span) {
-    let current = span;
-    let i = 0;
-    while (current && current._tag === "Span" && i < 10) {
-      const stackFn = spanToTrace.get(current);
-      if (typeof stackFn === "function") {
-        const stack = stackFn();
-        if (typeof stack === "string") {
-          const locationMatchAll = stack.matchAll(locationRegex);
-          let match = false;
-          for (const [, location] of locationMatchAll) {
-            match = true;
-            out.push(`    at ${current.name} (${location})`);
-          }
-          if (!match) {
-            out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`);
-          }
-        } else {
-          out.push(`    at ${current.name}`);
+});
+const exitCollectAllInternal = (exits, combineCauses) => {
+  const list = fromIterable$4(exits);
+  if (!isNonEmpty(list)) {
+    return none$3();
+  }
+  return pipe(tailNonEmpty(list), reduce$7(pipe(headNonEmpty(list), exitMap(of$1)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
+    onSuccess: (list, value) => pipe(list, prepend$1(value)),
+    onFailure: combineCauses
+  }))), exitMap(reverse$1), exitMap(chunk => toReadonlyArray(chunk)), some);
+};
+// -----------------------------------------------------------------------------
+// Deferred
+// -----------------------------------------------------------------------------
+/** @internal */
+const deferredUnsafeMake = fiberId => {
+  const _deferred = {
+    ...CommitPrototype,
+    [DeferredTypeId]: deferredVariance,
+    state: make$3(pending([])),
+    commit() {
+      return deferredAwait(this);
+    },
+    blockingOn: fiberId
+  };
+  return _deferred;
+};
+/* @internal */
+const deferredMake = () => flatMap$1(fiberId, id => deferredMakeAs(id));
+/* @internal */
+const deferredMakeAs = fiberId => sync(() => deferredUnsafeMake(fiberId));
+/* @internal */
+const deferredAwait = self => asyncInterrupt(resume => {
+  const state = get$1(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return resume(state.effect);
+      }
+    case OP_STATE_PENDING:
+      {
+        // we can push here as the internal state is mutable
+        state.joiners.push(resume);
+        return deferredInterruptJoiner(self, resume);
+      }
+  }
+}, self.blockingOn);
+/* @internal */
+const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync(() => {
+  const state = get$1(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return false;
+      }
+    case OP_STATE_PENDING:
+      {
+        set$1(self.state, done(effect));
+        for (let i = 0, len = state.joiners.length; i < len; i++) {
+          state.joiners[i](effect);
         }
-      } else {
-        out.push(`    at ${current.name}`);
+        return true;
       }
-      current = getOrUndefined(current.parent);
-      i++;
+  }
+}));
+/* @internal */
+const deferredDone = /*#__PURE__*/dual(2, (self, exit) => deferredCompleteWith(self, exit));
+/* @internal */
+const deferredFailCause = /*#__PURE__*/dual(2, (self, cause) => deferredCompleteWith(self, failCause$1(cause)));
+/* @internal */
+const deferredInterruptWith = /*#__PURE__*/dual(2, (self, fiberId) => deferredCompleteWith(self, interruptWith(fiberId)));
+/* @internal */
+const deferredIsDone = self => sync(() => get$1(self.state)._tag === OP_STATE_DONE);
+/* @internal */
+const deferredSucceed = /*#__PURE__*/dual(2, (self, value) => deferredCompleteWith(self, succeed$1(value)));
+/** @internal */
+const deferredUnsafeDone = (self, effect) => {
+  const state = get$1(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    set$1(self.state, done(effect));
+    for (let i = 0, len = state.joiners.length; i < len; i++) {
+      state.joiners[i](effect);
     }
   }
-  return out.join("\n");
 };
-/** @internal */
-const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
-/** @internal */
-const prettyErrors = cause => reduceWithContext(cause, void 0, {
-  emptyCase: () => [],
-  dieCase: (_, unknownError) => {
-    return [makePrettyError(unknownError)];
-  },
-  failCase: (_, error) => {
-    return [makePrettyError(error)];
-  },
-  interruptCase: () => [],
-  parallelCase: (_, l, r) => [...l, ...r],
-  sequentialCase: (_, l, r) => [...l, ...r]
+const deferredInterruptJoiner = (self, joiner) => sync(() => {
+  const state = get$1(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    const index = state.joiners.indexOf(joiner);
+    if (index >= 0) {
+      // we can splice here as the internal state is mutable
+      state.joiners.splice(index, 1);
+    }
+  }
 });
+// -----------------------------------------------------------------------------
+// Context
+// -----------------------------------------------------------------------------
+const constContext = /*#__PURE__*/withFiberRuntime(fiber => exitSucceed$1(fiber.currentContext));
+/* @internal */
+const context = () => constContext;
+/* @internal */
+const contextWithEffect = f => flatMap$1(context(), f);
+/* @internal */
+const provideContext$1 = /*#__PURE__*/dual(2, (self, context) => fiberRefLocally(currentContext, context)(self));
+/* @internal */
+const provideSomeContext = /*#__PURE__*/dual(2, (self, context) => fiberRefLocallyWith(currentContext, parent => merge(parent, context))(self));
+/* @internal */
+const mapInputContext = /*#__PURE__*/dual(2, (self, f) => contextWithEffect(context => provideContext$1(self, f(context))));
+// -----------------------------------------------------------------------------
+// Tracing
+// -----------------------------------------------------------------------------
+/** @internal */
+const currentSpanFromFiber = fiber => {
+  const span = fiber.currentSpan;
+  return span !== undefined && span._tag === "Span" ? some(span) : none$3();
+};
 
 /** @internal */
 /**
@@ -6392,7 +8481,7 @@ const MicroProto = {
     return pipeArguments(this, arguments);
   },
   [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
+    return new SingleShotGen$1(new YieldWrap(this));
   },
   toJSON() {
     return {
@@ -6448,7 +8537,7 @@ const makeExit = options => {
       return isMicroExit(that) && that._tag === options.op && equals(this[args], that[args]);
     },
     [symbol$1]() {
-      return cached(this, combine$1(string(options.op))(hash(this[args])));
+      return cached(this, combine$5(string(options.op))(hash(this[args])));
     }
   };
   return function (value) {
@@ -6833,36 +8922,52 @@ const uninterruptibleMask = f => withMicroFiber(fiber => {
  * @category execution
  */
 const runFork = (effect, options) => {
-  const fiber = new MicroFiberImpl(CurrentScheduler.context(new MicroSchedulerDefault()));
+  const fiber = new MicroFiberImpl(CurrentScheduler.context(options?.scheduler ?? new MicroSchedulerDefault()));
   fiber.evaluate(effect);
+  if (options?.signal) {
+    if (options.signal.aborted) {
+      fiber.unsafeInterrupt();
+    } else {
+      const abort = () => fiber.unsafeInterrupt();
+      options.signal.addEventListener("abort", abort, {
+        once: true
+      });
+      fiber.addObserver(() => options.signal.removeEventListener("abort", abort));
+    }
+  }
   return fiber;
 };
 /**
- * Execute the `Micro` effect and return a `Promise` that resolves with the
- * `MicroExit` of the computation.
+ * Attempt to execute the `Micro` effect synchronously and return the `MicroExit`.
+ *
+ * If any asynchronous effects are encountered, the function will return a
+ * `CauseDie` containing the `MicroFiber`.
  *
  * @since 3.4.6
  * @experimental
  * @category execution
  */
-const runPromiseExit = (effect, options) => new Promise((resolve, _reject) => {
-  const handle = runFork(effect);
-  handle.addObserver(resolve);
-});
+const runSyncExit = effect => {
+  const scheduler = new MicroSchedulerDefault();
+  const fiber = runFork(effect, {
+    scheduler
+  });
+  scheduler.flush();
+  return fiber._exit ?? exitDie(fiber);
+};
 /**
- * Execute the `Micro` effect and return a `Promise` that resolves with the
- * successful value of the computation.
+ * Attempt to execute the `Micro` effect synchronously and return the success
+ * value.
  *
  * @since 3.4.0
  * @experimental
  * @category execution
  */
-const runPromise = (effect, options) => runPromiseExit(effect).then(exit => {
-  if (exit._tag === "Failure") {
-    throw exit.cause;
-  }
+const runSync = effect => {
+  const exit = runSyncExit(effect);
+  if (exit._tag === "Failure") throw exit.cause;
   return exit.value;
-});
+};
 const YieldableError = /*#__PURE__*/function () {
   class YieldableError extends globalThis.Error {}
   // @effect-diagnostics-next-line floatingEffect:off
@@ -6962,7 +9067,7 @@ const format = (quoteValue, whitespace) => ({
   const append = (label, value) => " " + format(label, value);
   let out = format("timestamp", date.toISOString());
   out += append("level", logLevel.label);
-  out += append("fiber", threadName(fiberId));
+  out += append("fiber", threadName$1(fiberId));
   const messages = ensure(message);
   for (let i = 0; i < messages.length; i++) {
     out += append("message", toStringUnknown(messages[i], whitespace));
@@ -6987,4 +9092,4 @@ const stringLogger = /*#__PURE__*/makeLogger(/*#__PURE__*/format(escapeDoubleQuo
 const hasProcessStdout = typeof process === "object" && process !== null && typeof process.stdout === "object" && process.stdout !== null;
 hasProcessStdout && process.stdout.isTTY === true;
 
-export { add as $, set$1 as A, get$1 as B, isEmpty$1 as C, modifyAt as D, map$1 as E, keys as F, fromIterable$2 as G, string as H, format$1 as I, array as J, fromIterable$4 as K, mapInput as L, toJSON as M, NodeInspectSymbol as N, getEquivalence$1 as O, equals as P, of as Q, isNonEmpty as R, StructuralPrototype as S, TaggedError as T, headNonEmpty as U, tailNonEmpty as V, prepend as W, makeContext as X, reduce$1 as Y, has as Z, remove as _, right as a, OP_YIELD as a$, drop$1 as a0, isNonEmptyArray as a1, of$1 as a2, headNonEmpty$1 as a3, tailNonEmpty$1 as a4, constant as a5, appendAll as a6, orElseSome as a7, map$4 as a8, append as a9, interruptors as aA, OP_UPDATE_RUNTIME_FLAGS as aB, defects as aC, electFailures as aD, failures as aE, unsafeHead as aF, interrupt as aG, get as aH, set as aI, globalValue as aJ, getOrElse as aK, OP_ASYNC as aL, fromIterable$3 as aM, toReadonlyArray as aN, reverse as aO, reduce$5 as aP, allocate as aQ, sequential as aR, isPromiseLike as aS, OP_WHILE as aT, merge as aU, StructuralCommitPrototype as aV, empty as aW, die as aX, OP_REVERT_FLAGS as aY, pretty as aZ, isSome as a_, empty$4 as aa, OP_COMMIT as ab, effectVariance as ac, random as ad, YieldWrap as ae, OP_ON_SUCCESS as af, OP_ON_FAILURE as ag, isObject as ah, spanSymbol as ai, fail$1 as aj, failureOrCause as ak, getBugErrorMessage as al, OP_SYNC as am, OP_WITH_RUNTIME as an, OP_FAILURE as ao, pipe as ap, combine$1 as aq, hash as ar, OP_ON_SUCCESS_AND_FAILURE as as, OP_SUCCESS as at, internalCall as au, some as av, none$1 as aw, make as ax, CommitPrototype as ay, isInterruptedOnly as az, isRight as b, flipCauseOption as b$, OP_ITERATOR as b0, empty$5 as b1, empty$7 as b2, parallel as b3, isEqual as b4, GenericTag as b5, constFalse as b6, join as b7, contains as b8, head$1 as b9, lastNonEmpty as bA, span as bB, isNone as bC, getOrUndefined as bD, isTagged as bE, difference as bF, empty$1 as bG, union as bH, make$1 as bI, make$5 as bJ, isIterable as bK, compareAndSet as bL, isEmpty as bM, size as bN, withRedactableContext as bO, OP_TAG as bP, unsafeGet$1 as bQ, runFork as bR, provideContext as bS, stripFailures as bT, getCurrentVersion as bU, toStringUnknown as bV, yieldWrapGet as bW, getOption as bX, makeLogger as bY, stringLogger as bZ, isInterrupted as b_, prepend$1 as ba, map$3 as bb, isLeft as bc, zip as bd, append$1 as be, flatten as bf, last as bg, unfold as bh, merge$2 as bi, sort as bj, flatMap$3 as bk, unsafeGet$3 as bl, fromIterable as bm, PCGRandom as bn, Reference as bo, add$2 as bp, isNonEmptyReadonlyArray as bq, Class as br, constVoid as bs, get$3 as bt, unsafeFromArray as bu, makeBy as bv, dedupe as bw, appendAll$1 as bx, fromNullable as by, union$2 as bz, getRight as c, map as c0, isDieType as c1, head as c2, prettyErrors as c3, isContext as c4, mergeAll as c5, find as c6, splitAt$1 as c7, isEmpty$2 as c8, filter as c9, match$2 as ca, unsafeGet as cb, reduce$4 as cc, map$2 as cd, splitWhere as ce, filterMap as cf, dual as d, isNumber as e, isBigInt as f, getOrThrowWith as g, hasProperty as h, identity as i, isString as j, symbol$1 as k, left as l, match$1 as m, cached as n, structure as o, pipeArguments as p, none as q, runPromise as r, symbol as s, try_ as t, combine as u, unsafeMake as v, threadName as w, combineAll as x, empty$3 as y, reduce$3 as z };
+export { exitFail as $, cons as A, reduce$2 as B, set as C, get as D, appendAll$1 as E, isEmpty$1 as F, equals as G, modifyAt as H, orElseSome as I, map$6 as J, append as K, of$1 as L, map$2 as M, NodeInspectSymbol as N, keys as O, empty$a as P, deferredMake as Q, deferredAwait as R, deferredSucceed as S, TaggedError as T, deferredFailCause as U, deferredIsDone as V, exitIsFailure as W, exitIsSuccess as X, exitMatch as Y, exitFailCause$1 as Z, exitSucceed$1 as _, isRight as a, add$2 as a$, exitZipRight as a0, exitCollectAll as a1, exitVoid$1 as a2, exitDie$1 as a3, exitMap as a4, exitZip as a5, isEqual as a6, some as a7, none$3 as a8, isSome as a9, zip as aA, map as aB, of$2 as aC, fromIterable as aD, fromIterable$5 as aE, append$1 as aF, flatten$1 as aG, empty$d as aH, last as aI, getOrElse as aJ, mapError as aK, catchAll as aL, unfold as aM, merge$2 as aN, mapBoth as aO, sort as aP, flatMap$4 as aQ, unsafeGet$3 as aR, fromIterable$1 as aS, hash as aT, PCGRandom as aU, forEachSequentialDiscard as aV, as as aW, fromIterable$4 as aX, Reference as aY, globalValue as aZ, fiberRefUnsafeMakeContext as a_, toJSON as aa, format$1 as ab, prepend$1 as ac, reverse$1 as ad, GenericTag as ae, sync as af, succeed$1 as ag, async_ as ah, constFalse as ai, void_$1 as aj, asVoid as ak, pipe as al, join as am, isCons as an, contains as ao, head$1 as ap, tailNonEmpty$1 as aq, prepend$2 as ar, map$5 as as, flatMap$1 as at, fail$1 as au, suspend$1 as av, either as aw, isLeft as ax, zip$1 as ay, forEachSequential as az, getRight as b, uninterruptibleMask$1 as b$, empty$b as b0, withFiberRuntime as b1, headNonEmpty$1 as b2, isNonEmptyReadonlyArray as b3, logLevelWarning as b4, logLevelNone as b5, logLevelTrace as b6, logLevelInfo as b7, logLevelFatal as b8, logLevelError as b9, unsafeFromArray as bA, makeBy as bB, dedupe as bC, appendAll$2 as bD, array as bE, fromNullable as bF, getEquivalence$2 as bG, union$2 as bH, allocate as bI, lastNonEmpty as bJ, span as bK, isNone as bL, getOrUndefined as bM, tap as bN, currentMetricLabels as bO, deferredUnsafeDone as bP, isTagged as bQ, make$2 as bR, reduce$3 as bS, difference as bT, empty$7 as bU, union as bV, make$4 as bW, isNonEmpty as bX, headNonEmpty as bY, tailNonEmpty as bZ, onExit$1 as b_, logLevelDebug as ba, logLevelAll as bb, make$3 as bc, Class as bd, get$1 as be, set$1 as bf, string as bg, matchEffect as bh, matchCauseEffect$1 as bi, zipRight as bj, failCause$1 as bk, constVoid as bl, contextWithEffect as bm, provideContext$1 as bn, get$4 as bo, failCauseSync as bp, yieldNow$1 as bq, combine$5 as br, fiberRefUnsafeMake as bs, currentMaxOpsBeforeYield as bt, currentSchedulingPriority as bu, fiberRefGetWith as bv, currentConcurrency as bw, none$1 as bx, zipLeft as by, flatten as bz, runSync as c, blocked as c$, transplant as c0, CloseableScopeTypeId as c1, ScopeTypeId as c2, exitAsVoid as c3, exit as c4, sequential as c5, isEffect as c6, mapInputContext as c7, merge as c8, make$8 as c9, currentLogAnnotations as cA, size as cB, withRedactableContext as cC, interruptible$2 as cD, OP_YIELD as cE, cooperativeYielding as cF, OP_ASYNC as cG, enable$1 as cH, patch as cI, die$1 as cJ, OP_ON_FAILURE as cK, OP_ON_SUCCESS as cL, OP_WHILE as cM, OP_ITERATOR as cN, OP_TAG as cO, unsafeGet$1 as cP, NoSuchElementException as cQ, unsafeAsync as cR, runFork as cS, provideContext as cT, die as cU, OP_SYNC as cV, internalCall as cW, OP_REVERT_FLAGS as cX, stripFailures as cY, OP_ON_SUCCESS_AND_FAILURE as cZ, OP_WITH_RUNTIME as c_, OP_FAILURE as ca, OP_SUCCESS as cb, combine$3 as cc, currentRequestBatching as cd, isIterable as ce, unsafeMake as cf, currentContext as cg, currentForkScopeOverride as ch, compareAndSet as ci, runtimeMetrics as cj, currentInterruptedCause as ck, deferredUnsafeMake as cl, fiberRefUnsafeMakeRuntimeFlags as cm, exclude as cn, WindDown as co, Interruption as cp, diff as cq, updateRuntimeFlags as cr, interrupt$1 as cs, fiberRefUnsafeMakePatch as ct, isEmpty as cu, whileLoop as cv, currentUnhandledErrorLogLevel as cw, isInterruptedOnly as cx, currentLogLevel as cy, currentLogSpan as cz, dual as d, acquireUseRelease as d$, runRequestBlock as d0, OP_UPDATE_RUNTIME_FLAGS as d1, RevertFlags as d2, OP_COMMIT as d3, OpSupervision as d4, EffectTypeId as d5, currentVersionMismatchErrorLogLevel as d6, getCurrentVersion as d7, empty as d8, dieMessage as d9, failureOrCause as dA, flipCauseOption as dB, map$1 as dC, isDieType as dD, interruptors as dE, head as dF, scopeClose as dG, scopeAddFinalizerExit as dH, scopeAddFinalizer as dI, asyncInterrupt as dJ, make as dK, RuntimeMetrics as dL, CooperativeYielding as dM, prettyErrors as dN, isContext as dO, provideSomeContext as dP, whenEffect as dQ, mergeAll as dR, gen as dS, zipWith as dT, fnUntraced as dU, catchAllCause as dV, find as dW, orDie as dX, failSync as dY, interrupt as dZ, matchCause as d_, toStringUnknown as da, isInterruptedException as db, fiberRefUnsafeMakeHashSet as dc, yieldWrapGet as dd, exitIsExit as de, step as df, uninterruptible as dg, getOption as dh, scopeFork as di, none as dj, makeLogger as dk, threadName as dl, pretty as dm, fiberIdWith as dn, exitMatchEffect as dp, interruptAsFiber as dq, parallel as dr, toReadonlyArray as ds, fiberRefLocally as dt, stringLogger as du, interruptible$1 as dv, isInterrupted as dw, interruptFiber as dx, exitInterrupt$1 as dy, fail$2 as dz, isNumber as e, intoDeferred as e0, splitAt$1 as e1, isEmpty$3 as e2, onInterrupt as e3, filter as e4, deferredInterruptWith as e5, fiberId as e6, match$2 as e7, combineAll as e8, unsafeGet as e9, reduce$6 as ea, map$4 as eb, splitWhere as ec, filterMap as ed, isBigInt as f, getOrThrowWith as g, hasProperty as h, identity as i, isString as j, symbol$1 as k, left as l, match$1 as m, cached as n, structure as o, pipeArguments as p, of as q, right as r, symbol as s, try_ as t, reduce$1 as u, empty$5 as v, appendAll as w, isNil as x, reverse as y, empty$6 as z };