npm - @lmvz-ds/components - Versions diffs - 0.12.3-alpha.4 → 0.12.3 - Mend

@lmvz-ds/components 0.12.3-alpha.4 → 0.12.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (138) hide show

package/dist/cjs/{Effect-BIlTHtLK.js → Effect-CNhHt4Xb.js} RENAMED Viewed

@@ -275,19 +275,19 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
  * @category constructors
  * @since 2.0.0
  */
-const make$u = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
+const make$s = isEquivalent => (self, that) => self === that || isEquivalent(self, that);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => make$u((x, y) => self(f(x), f(y))));
+const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => make$s((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$u((self, that) => {
+const array$1 = item => make$s((self, that) => {
   if (self.length !== that.length) {
     return false;
   }
@@ -1325,10 +1325,10 @@ const Base$1 = /*#__PURE__*/function () {
 /**
  * @since 2.0.0
  */
-const TypeId$d = /*#__PURE__*/Symbol.for("effect/Option");
+const TypeId$b = /*#__PURE__*/Symbol.for("effect/Option");
 const CommonProto$1 = {
   ...EffectPrototype$1,
-  [TypeId$d]: {
+  [TypeId$b]: {
     _A: _ => _
   },
   [NodeInspectSymbol]() {
@@ -1373,7 +1373,7 @@ const NoneProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
   }
 });
 /** @internal */
-const isOption = input => hasProperty(input, TypeId$d);
+const isOption = input => hasProperty(input, TypeId$b);
 /** @internal */
 const isNone$1 = fa => fa._tag === "None";
 /** @internal */
@@ -1393,10 +1393,10 @@ const some$1 = value => {
 /**
  * @internal
  */
-const TypeId$c = /*#__PURE__*/Symbol.for("effect/Either");
+const TypeId$a = /*#__PURE__*/Symbol.for("effect/Either");
 const CommonProto = {
   ...EffectPrototype$1,
-  [TypeId$c]: {
+  [TypeId$a]: {
     _R: _ => _
   },
   [NodeInspectSymbol]() {
@@ -1441,7 +1441,7 @@ const LeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(CommonPr
   }
 });
 /** @internal */
-const isEither = input => hasProperty(input, TypeId$c);
+const isEither = input => hasProperty(input, TypeId$a);
 /** @internal */
 const isLeft$1 = ma => ma._tag === "Left";
 /** @internal */
@@ -1535,7 +1535,7 @@ const isRight = isRight$1;
  * @category pattern matching
  * @since 2.0.0
  */
-const match$7 = /*#__PURE__*/dual(2, (self, {
+const match$6 = /*#__PURE__*/dual(2, (self, {
   onLeft,
   onRight
 }) => isLeft(self) ? onLeft(self.left) : onRight(self.right));
@@ -1543,7 +1543,7 @@ const match$7 = /*#__PURE__*/dual(2, (self, {
  * @category getters
  * @since 2.0.0
  */
-const merge$3 = /*#__PURE__*/match$7({
+const merge$3 = /*#__PURE__*/match$6({
   onLeft: identity,
   onRight: identity
 });
@@ -1602,17 +1602,17 @@ const isNonEmptyArray$1 = self => self.length > 0;
  * @category constructors
  * @since 2.0.0
  */
-const make$t = compare => (self, that) => self === that ? 0 : compare(self, that);
+const make$r = compare => (self, that) => self === that ? 0 : compare(self, that);
 /**
  * @category instances
  * @since 2.0.0
  */
-const number = /*#__PURE__*/make$t((self, that) => self < that ? -1 : 1);
+const number = /*#__PURE__*/make$r((self, that) => self < that ? -1 : 1);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput = /*#__PURE__*/dual(2, (self, f) => make$t((b1, b2) => self(f(b1), f(b2))));
+const mapInput = /*#__PURE__*/dual(2, (self, f) => make$r((b1, b2) => self(f(b1), f(b2))));
 /**
  * Test whether one value is _strictly greater than_ another.
  *
@@ -1751,7 +1751,7 @@ const isSome = isSome$1;
  * @category Pattern matching
  * @since 2.0.0
  */
-const match$6 = /*#__PURE__*/dual(2, (self, {
+const match$5 = /*#__PURE__*/dual(2, (self, {
   onNone,
   onSome
 }) => isNone(self) ? onNone() : onSome(self.value));
@@ -1999,7 +1999,7 @@ const getOrThrow = /*#__PURE__*/getOrThrowWith(() => new Error("getOrThrow calle
  * @category Mapping
  * @since 2.0.0
  */
-const map$9 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$4() : some(f(self.value)));
+const map$8 = /*#__PURE__*/dual(2, (self, f) => isNone(self) ? none$4() : 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`.
@@ -2155,7 +2155,7 @@ const mergeWith = f => (o1, o2) => {
  * @category constructors
  * @since 2.0.0
  */
-const make$s = (...elements) => elements;
+const make$q = (...elements) => elements;
 /**
  * This module provides utility functions for working with arrays in TypeScript.
@@ -2269,7 +2269,7 @@ const prepend$2 = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
  * @category concatenating
  * @since 2.0.0
  */
-const append$2 = /*#__PURE__*/dual(2, (self, last) => [...self, last]);
+const append$1 = /*#__PURE__*/dual(2, (self, last) => [...self, last]);
 /**
  * Concatenates two arrays (or iterables), combining their elements.
  * If either array is non-empty, the result is also a non-empty array.
@@ -2519,7 +2519,7 @@ const sort = /*#__PURE__*/dual(2, (self, O) => {
  * @category zipping
  * @since 2.0.0
  */
-const zip$3 = /*#__PURE__*/dual(2, (self, that) => zipWith$2(self, that, make$s));
+const zip$2 = /*#__PURE__*/dual(2, (self, that) => zipWith$2(self, that, make$q));
 /**
  * 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.
@@ -2657,7 +2657,7 @@ const union$2 = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that, _equi
  * @category constructors
  * @since 2.0.0
  */
-const empty$m = () => [];
+const empty$l = () => [];
 /**
  * Constructs a new `NonEmptyArray<A>` from the specified value.
  *
@@ -2669,7 +2669,7 @@ const of$2 = a => [a];
  * @category mapping
  * @since 2.0.0
  */
-const map$8 = /*#__PURE__*/dual(2, (self, f) => self.map(f));
+const map$7 = /*#__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.
  *
@@ -3008,7 +3008,7 @@ const TagProto = {
     return self;
   },
   context(self) {
-    return make$r(this, self);
+    return make$p(this, self);
   }
 };
 const ReferenceProto = {
@@ -3048,10 +3048,10 @@ const Reference$1 = () => (id, options) => {
   return ReferenceClass;
 };
 /** @internal */
-const TypeId$b = /*#__PURE__*/Symbol.for("effect/Context");
+const TypeId$9 = /*#__PURE__*/Symbol.for("effect/Context");
 /** @internal */
 const ContextProto = {
-  [TypeId$b]: {
+  [TypeId$9]: {
     _Services: _ => _
   },
   [symbol](that) {
@@ -3111,14 +3111,14 @@ const serviceNotFoundError = tag => {
   return error;
 };
 /** @internal */
-const isContext$1 = u => hasProperty(u, TypeId$b);
+const isContext$1 = u => hasProperty(u, TypeId$9);
 /** @internal */
 const isReference = u => hasProperty(u, ReferenceTypeId);
 const _empty$6 = /*#__PURE__*/makeContext(/*#__PURE__*/new Map());
 /** @internal */
-const empty$l = () => _empty$6;
+const empty$k = () => _empty$6;
 /** @internal */
-const make$r = (tag, service) => makeContext(new Map([[tag.key, service]]));
+const make$p = (tag, service) => makeContext(new Map([[tag.key, service]]));
 /** @internal */
 const add$3 = /*#__PURE__*/dual(3, (self, tag, service) => {
   const map = new Map(self.unsafeMap);
@@ -3218,7 +3218,7 @@ const isContext = isContext$1;
  * @since 2.0.0
  * @category constructors
  */
-const empty$k = empty$l;
+const empty$j = empty$k;
 /**
  * Creates a new `Context` with a single service associated to the tag.
  *
@@ -3237,7 +3237,7 @@ const empty$k = empty$l;
  * @since 2.0.0
  * @category constructors
  */
-const make$q = make$r;
+const make$o = make$p;
 /**
  * Adds a service to a given `Context`.
  *
@@ -3442,7 +3442,7 @@ const Reference = Reference$1;
 /**
  * @since 2.0.0
  */
-const TypeId$a = /*#__PURE__*/Symbol.for("effect/Chunk");
+const TypeId$8 = /*#__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];
@@ -3456,10 +3456,10 @@ const emptyArray = [];
  * @category equivalence
  * @since 2.0.0
  */
-const getEquivalence$1 = isEquivalent => make$u((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
+const getEquivalence$1 = isEquivalent => make$s((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet(that, i))));
 const _equivalence$1 = /*#__PURE__*/getEquivalence$1(equals$1);
 const ChunkProto = {
-  [TypeId$a]: {
+  [TypeId$8]: {
     _A: _ => _
   },
   toString() {
@@ -3553,7 +3553,7 @@ const makeChunk = backing => {
  * @category constructors
  * @since 2.0.0
  */
-const isChunk = u => hasProperty(u, TypeId$a);
+const isChunk = u => hasProperty(u, TypeId$8);
 const _empty$5 = /*#__PURE__*/makeChunk({
   _tag: "IEmpty"
 });
@@ -3561,14 +3561,14 @@ const _empty$5 = /*#__PURE__*/makeChunk({
  * @category constructors
  * @since 2.0.0
  */
-const empty$j = () => _empty$5;
+const empty$i = () => _empty$5;
 /**
  * Builds a `NonEmptyChunk` from an non-empty collection of elements.
  *
  * @category constructors
  * @since 2.0.0
  */
-const make$p = (...as) => unsafeFromNonEmptyArray(as);
+const make$n = (...as) => unsafeFromNonEmptyArray(as);
 /**
  * Builds a `NonEmptyChunk` from a single element.
  *
@@ -3708,7 +3708,7 @@ const get$6 = /*#__PURE__*/dual(2, (self, index) => index < 0 || index >= self.l
  * @since 2.0.0
  * @category unsafe
  */
-const unsafeFromArray = self => self.length === 0 ? empty$j() : self.length === 1 ? of$1(self[0]) : makeChunk({
+const unsafeFromArray = self => self.length === 0 ? empty$i() : self.length === 1 ? of$1(self[0]) : makeChunk({
   _tag: "IArray",
   array: self
 });
@@ -3761,7 +3761,7 @@ const unsafeGet = /*#__PURE__*/dual(2, (self, index) => {
  * @category concatenating
  * @since 2.0.0
  */
-const append$1 = /*#__PURE__*/dual(2, (self, a) => appendAll$1(self, of$1(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`.
  *
@@ -3979,7 +3979,7 @@ const filter = /*#__PURE__*/dual(2, (self, predicate) => unsafeFromArray(filter$
  * @since 2.0.0
  * @category elements
  */
-const isEmpty$7 = self => self.length === 0;
+const isEmpty$5 = self => self.length === 0;
 /**
  * Determines if the chunk is not empty.
  *
@@ -4028,7 +4028,7 @@ const headNonEmpty = unsafeHead;
  * @since 2.0.0
  * @category mapping
  */
-const map$7 = /*#__PURE__*/dual(2, (self, f) => self.backing._tag === "ISingleton" ? of$1(f(self.backing.a, 0)) : unsafeFromArray(pipe(toReadonlyArray(self), map$8((a, i) => f(a, i)))));
+const map$6 = /*#__PURE__*/dual(2, (self, f) => self.backing._tag === "ISingleton" ? of$1(f(self.backing.a, 0)) : unsafeFromArray(pipe(toReadonlyArray(self), map$7((a, i) => f(a, i)))));
 /**
  *  Returns two splits of this chunk at the specified index.
  *
@@ -4070,7 +4070,7 @@ const reduce$6 = reduce$7;
 /**
  * @since 2.0.0
  */
-const TypeId$9 = /*#__PURE__*/Symbol.for("effect/Duration");
+const TypeId$7 = /*#__PURE__*/Symbol.for("effect/Duration");
 const bigint0$1 = /*#__PURE__*/BigInt(0);
 const bigint24 = /*#__PURE__*/BigInt(24);
 const bigint60 = /*#__PURE__*/BigInt(60);
@@ -4139,7 +4139,7 @@ const infinityValue = {
   _tag: "Infinity"
 };
 const DurationProto = {
-  [TypeId$9]: TypeId$9,
+  [TypeId$7]: TypeId$7,
   [symbol$1]() {
     return cached(this, structure(this.value));
   },
@@ -4177,7 +4177,7 @@ const DurationProto = {
     return pipeArguments(this, arguments);
   }
 };
-const make$o = input => {
+const make$m = input => {
   const duration = Object.create(DurationProto);
   if (isNumber(input)) {
     if (isNaN(input) || input <= 0) {
@@ -4209,7 +4209,7 @@ const make$o = input => {
  * @since 2.0.0
  * @category guards
  */
-const isDuration = u => hasProperty(u, TypeId$9);
+const isDuration = u => hasProperty(u, TypeId$7);
 /**
  * @since 3.5.0
  * @category guards
@@ -4234,57 +4234,57 @@ const isZero = self => {
  * @since 2.0.0
  * @category constructors
  */
-const zero = /*#__PURE__*/make$o(0);
+const zero = /*#__PURE__*/make$m(0);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const infinity = /*#__PURE__*/make$o(Infinity);
+const infinity = /*#__PURE__*/make$m(Infinity);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const nanos = nanos => make$o(nanos);
+const nanos = nanos => make$m(nanos);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const micros = micros => make$o(micros * bigint1e3);
+const micros = micros => make$m(micros * bigint1e3);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const millis = millis => make$o(millis);
+const millis = millis => make$m(millis);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const seconds = seconds => make$o(seconds * 1000);
+const seconds = seconds => make$m(seconds * 1000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const minutes = minutes => make$o(minutes * 60_000);
+const minutes = minutes => make$m(minutes * 60_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const hours = hours => make$o(hours * 3_600_000);
+const hours = hours => make$m(hours * 3_600_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const days = days => make$o(days * 86_400_000);
+const days = days => make$m(days * 86_400_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const weeks = weeks => make$o(weeks * 604_800_000);
+const weeks = weeks => make$m(weeks * 604_800_000);
 /**
  * @since 2.0.0
  * @category getters
  */
-const toMillis = self => match$5(self, {
+const toMillis = self => match$4(self, {
   onMillis: millis => millis,
   onNanos: nanos => Number(nanos) / 1_000_000
 });
@@ -4326,7 +4326,7 @@ const toHrTime = self => {
  * @since 2.0.0
  * @category pattern matching
  */
-const match$5 = /*#__PURE__*/dual(2, (self, options) => {
+const match$4 = /*#__PURE__*/dual(2, (self, options) => {
   const _self = decode(self);
   switch (_self.value._tag) {
     case "Nanos":
@@ -4498,7 +4498,7 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
-const make$n = (value, previous) => ({
+const make$l = (value, previous) => ({
   value,
   previous
 });
@@ -4784,7 +4784,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$n(res, stack);
+      stack = make$l(res, stack);
       currentShift = currentShift + SIZE;
     } else {
       let final = res;
@@ -4919,10 +4919,10 @@ const visitLazyChildren = (len, children, i, f, cont) => {
 };
 const _empty$4 = /*#__PURE__*/makeImpl$1(false, 0, /*#__PURE__*/new EmptyNode(), 0);
 /** @internal */
-const empty$i = () => _empty$4;
+const empty$h = () => _empty$4;
 /** @internal */
 const fromIterable$4 = entries => {
-  const map = beginMutation$1(empty$i());
+  const map = beginMutation$1(empty$h());
   for (const entry of entries) {
     set$4(map, entry[0], entry[1]);
   }
@@ -4931,7 +4931,7 @@ const fromIterable$4 = entries => {
 /** @internal */
 const isHashMap = u => hasProperty(u, HashMapTypeId);
 /** @internal */
-const isEmpty$6 = self => self && isEmptyNode(self._root);
+const isEmpty$4 = self => self && isEmptyNode(self._root);
 /** @internal */
 const get$5 = /*#__PURE__*/dual(2, (self, key) => getHash(self, key, hash(key)));
 /** @internal */
@@ -5017,14 +5017,14 @@ const modifyHash = /*#__PURE__*/dual(4, (self, key, hash, f) => {
   return pipe(self, setTree(newRoot, size.value));
 });
 /** @internal */
-const remove$4 = /*#__PURE__*/dual(2, (self, key) => modifyAt$1(self, key, none$4));
+const remove$3 = /*#__PURE__*/dual(2, (self, key) => modifyAt$1(self, key, none$4));
 /**
  * Maps over the entries of the `HashMap` using the specified function.
  *
  * @since 2.0.0
  * @category mapping
  */
-const map$6 = /*#__PURE__*/dual(2, (self, f) => reduce$5(self, empty$i(), (map, value, key) => set$4(map, key, f(value, key))));
+const map$5 = /*#__PURE__*/dual(2, (self, f) => reduce$5(self, empty$h(), (map, value, key) => set$4(map, key, f(value, key))));
 /** @internal */
 const forEach$3 = /*#__PURE__*/dual(2, (self, f) => reduce$5(self, void 0, (_, value, key) => f(value, key)));
 /** @internal */
@@ -5096,20 +5096,20 @@ const makeImpl = keyMap => {
 };
 /** @internal */
 const isHashSet = u => hasProperty(u, HashSetTypeId);
-const _empty$3 = /*#__PURE__*/makeImpl(/*#__PURE__*/empty$i());
+const _empty$3 = /*#__PURE__*/makeImpl(/*#__PURE__*/empty$h());
 /** @internal */
-const empty$h = () => _empty$3;
+const empty$g = () => _empty$3;
 /** @internal */
 const fromIterable$3 = elements => {
-  const set = beginMutation(empty$h());
+  const set = beginMutation(empty$g());
   for (const value of elements) {
     add$1(set, value);
   }
   return endMutation(set);
 };
 /** @internal */
-const make$m = (...elements) => {
-  const set = beginMutation(empty$h());
+const make$k = (...elements) => {
+  const set = beginMutation(empty$g());
   for (const value of elements) {
     add$1(set, value);
   }
@@ -5135,15 +5135,15 @@ const mutate = /*#__PURE__*/dual(2, (self, f) => {
 /** @internal */
 const add$1 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (set$4(value, true)(self._keyMap), self) : makeImpl(set$4(value, true)(self._keyMap)));
 /** @internal */
-const remove$3 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (remove$4(value)(self._keyMap), self) : makeImpl(remove$4(value)(self._keyMap)));
+const remove$2 = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (remove$3(value)(self._keyMap), self) : makeImpl(remove$3(value)(self._keyMap)));
 /** @internal */
 const difference$1 = /*#__PURE__*/dual(2, (self, that) => mutate(self, set => {
   for (const value of that) {
-    remove$3(set, value);
+    remove$2(set, value);
   }
 }));
 /** @internal */
-const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$h(), set => {
+const union$1 = /*#__PURE__*/dual(2, (self, that) => mutate(empty$g(), set => {
   forEach$2(self, value => add$1(set, value));
   for (const value of that) {
     add$1(set, value);
@@ -5434,7 +5434,7 @@ const reduce$4 = /*#__PURE__*/dual(3, (self, zero, f) => reduce$5(self._keyMap,
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.make} {@link module:HashSet.fromIterable}
  */
-const empty$g = empty$h;
+const empty$f = empty$g;
 /**
  * Creates a new `HashSet` from an iterable collection of values.
  *
@@ -5616,7 +5616,7 @@ const fromIterable$2 = fromIterable$3;
  *
  * @see Other `HashSet` constructors are {@link module:HashSet.fromIterable} {@link module:HashSet.empty}
  */
-const make$l = make$m;
+const make$j = make$k;
 /**
  * Checks if the specified value exists in the `HashSet`.
  *
@@ -5728,7 +5728,7 @@ const add = add$1;
  *
  * @see Other `HashSet` mutations are {@link module:HashSet.add} {@link module:HashSet.toggle} {@link module:HashSet.beginMutation} {@link module:HashSet.endMutation} {@link module:HashSet.mutate}
  */
-const remove$2 = remove$3;
+const remove$1 = remove$2;
 /**
  * Computes the set difference `(A - B)` between this `HashSet` and the
  * specified `Iterable<A>`.
@@ -5822,9 +5822,9 @@ const reduce$3 = reduce$4;
 /**
  * @since 2.0.0
  */
-const TypeId$8 = /*#__PURE__*/Symbol.for("effect/MutableRef");
+const TypeId$6 = /*#__PURE__*/Symbol.for("effect/MutableRef");
 const MutableRefProto = {
-  [TypeId$8]: TypeId$8,
+  [TypeId$6]: TypeId$6,
   toString() {
     return format$2(this.toJSON());
   },
@@ -5845,7 +5845,7 @@ const MutableRefProto = {
  * @since 2.0.0
  * @category constructors
  */
-const make$k = value => {
+const make$i = value => {
   const ref = Object.create(MutableRefProto);
   ref.current = value;
   return ref;
@@ -5997,11 +5997,11 @@ const ids = self => {
   switch (self._tag) {
     case OP_NONE:
       {
-        return empty$g();
+        return empty$f();
       }
     case OP_RUNTIME:
       {
-        return make$l(self.id);
+        return make$j(self.id);
       }
     case OP_COMPOSITE:
       {
@@ -6009,14 +6009,14 @@ const ids = self => {
       }
   }
 };
-const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make$k(0));
+const _fiberCounter = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make$i(0));
 /** @internal */
 const threadName$1 = self => {
   const identifiers = Array.from(ids(self)).map(n => `#${n}`).join(",");
   return identifiers;
 };
 /** @internal */
-const unsafeMake$6 = () => {
+const unsafeMake$5 = () => {
   const id = get$4(_fiberCounter);
   pipe(_fiberCounter, set$3(id + 1));
   return new Runtime(id, Date.now());
@@ -6055,7 +6055,7 @@ const threadName = threadName$1;
  * @since 2.0.0
  * @category unsafe
  */
-const unsafeMake$5 = unsafeMake$6;
+const unsafeMake$4 = unsafeMake$5;
 /**
  * @since 2.0.0
@@ -6066,7 +6066,7 @@ const unsafeMake$5 = unsafeMake$6;
  * @since 2.0.0
  * @category constructors
  */
-const empty$f = empty$i;
+const empty$e = empty$h;
 /**
  * Creates a new `HashMap` from an iterable collection of key/value pairs.
  *
@@ -6080,7 +6080,7 @@ const fromIterable$1 = fromIterable$4;
  * @since 2.0.0
  * @category elements
  */
-const isEmpty$5 = isEmpty$6;
+const isEmpty$3 = isEmpty$4;
 /**
  * Safely lookup the value for the specified key in the `HashMap` using the
  * internal hashing function.
@@ -6120,7 +6120,7 @@ const modifyAt = modifyAt$1;
  * @since 2.0.0
  * @category mapping
  */
-const map$5 = map$6;
+const map$4 = map$5;
 /**
  * Reduces the specified state over the entries of the `HashMap`.
  *
@@ -6155,7 +6155,7 @@ const reduce$2 = reduce$5;
  * @since 2.0.0
  * @category symbol
  */
-const TypeId$7 = /*#__PURE__*/Symbol.for("effect/List");
+const TypeId$5 = /*#__PURE__*/Symbol.for("effect/List");
 /**
  * Converts the specified `List` to an `Array`.
  *
@@ -6170,7 +6170,7 @@ const toArray = self => fromIterable$6(self);
 const getEquivalence = isEquivalent => mapInput$1(getEquivalence$2(isEquivalent), toArray);
 const _equivalence = /*#__PURE__*/getEquivalence(equals$1);
 const ConsProto = {
-  [TypeId$7]: TypeId$7,
+  [TypeId$5]: TypeId$5,
   _tag: "Cons",
   toString() {
     return format$2(this.toJSON());
@@ -6234,7 +6234,7 @@ const makeCons = (head, tail) => {
 };
 const NilHash = /*#__PURE__*/string("Nil");
 const NilProto = {
-  [TypeId$7]: TypeId$7,
+  [TypeId$5]: TypeId$5,
   _tag: "Nil",
   toString() {
     return format$2(this.toJSON());
@@ -6275,7 +6275,7 @@ const _Nil = /*#__PURE__*/Object.create(NilProto);
  * @since 2.0.0
  * @category refinements
  */
-const isList = u => hasProperty(u, TypeId$7);
+const isList = u => hasProperty(u, TypeId$5);
 /**
  * Returns `true` if the specified value is a `List.Nil<A>`, `false` otherwise.
  *
@@ -6312,7 +6312,7 @@ const cons = (head, tail) => makeCons(head, tail);
  * @since 2.0.0
  * @category constructors
  */
-const empty$e = nil;
+const empty$d = nil;
 /**
  * Constructs a new `List<A>` from the specified value.
  *
@@ -6405,7 +6405,7 @@ const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
  * @category elements
  */
 const reverse = self => {
-  let result = empty$e();
+  let result = empty$d();
   let these = self;
   while (!isNil(these)) {
     result = prepend(result, these.head);
@@ -6447,7 +6447,7 @@ const _empty$2 = /*#__PURE__*/Object.create(EmptyProto$2);
 /**
  * @internal
  */
-const empty$d = () => _empty$2;
+const empty$c = () => _empty$2;
 const AndThenProto$2 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
   _tag: "AndThen"
 });
@@ -6486,7 +6486,7 @@ const makeUpdateService = (key, update) => {
 /** @internal */
 const diff$6 = (oldValue, newValue) => {
   const missingServices = new Map(oldValue.unsafeMap);
-  let patch = empty$d();
+  let patch = empty$c();
   for (const [tag, newService] of newValue.unsafeMap.entries()) {
     if (missingServices.has(tag)) {
       const old = missingServices.get(tag);
@@ -6584,7 +6584,7 @@ const EmptyProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(Patch
 });
 const _empty$1 = /*#__PURE__*/Object.create(EmptyProto$1);
 /** @internal */
-const empty$c = () => _empty$1;
+const empty$b = () => _empty$1;
 const AndThenProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
   _tag: "AndThen"
 });
@@ -6615,9 +6615,9 @@ const makeRemove = value => {
 };
 /** @internal */
 const diff$5 = (oldValue, newValue) => {
-  const [removed, patch] = reduce$3([oldValue, empty$c()], ([set, patch], value) => {
+  const [removed, patch] = reduce$3([oldValue, empty$b()], ([set, patch], value) => {
     if (has$1(value)(set)) {
-      return [remove$2(value)(set), patch];
+      return [remove$1(value)(set), patch];
     }
     return [set, combine$3(makeAdd(value))(patch)];
   })(newValue);
@@ -6654,7 +6654,7 @@ const patch$6 = /*#__PURE__*/dual(2, (self, oldValue) => {
         }
       case "Remove":
         {
-          set = remove$2(head.value)(set);
+          set = remove$1(head.value)(set);
           patches = tail;
         }
     }
@@ -6681,7 +6681,7 @@ const _empty = /*#__PURE__*/Object.create(EmptyProto);
 /**
  * @internal
  */
-const empty$b = () => _empty;
+const empty$a = () => _empty;
 const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
   _tag: "AndThen"
 });
@@ -6720,7 +6720,7 @@ const makeUpdate = (index, patch) => {
 /** @internal */
 const diff$4 = options => {
   let i = 0;
-  let patch = empty$b();
+  let patch = empty$a();
   while (i < options.oldValue.length && i < options.newValue.length) {
     const oldElement = options.oldValue[i];
     const newElement = options.newValue[i];
@@ -6800,7 +6800,7 @@ const DifferProto = {
   }
 };
 /** @internal */
-const make$j = params => {
+const make$h = params => {
   const differ = Object.create(DifferProto);
   differ.empty = params.empty;
   differ.diff = params.diff;
@@ -6809,22 +6809,22 @@ const make$j = params => {
   return differ;
 };
 /** @internal */
-const environment = () => make$j({
-  empty: empty$d(),
+const environment = () => make$h({
+  empty: empty$c(),
   combine: (first, second) => combine$4(second)(first),
   diff: (oldValue, newValue) => diff$6(oldValue, newValue),
   patch: (patch, oldValue) => patch$7(oldValue)(patch)
 });
 /** @internal */
-const hashSet = () => make$j({
-  empty: empty$c(),
+const hashSet = () => make$h({
+  empty: empty$b(),
   combine: (first, second) => combine$3(second)(first),
   diff: (oldValue, newValue) => diff$5(oldValue, newValue),
   patch: (patch, oldValue) => patch$6(oldValue)(patch)
 });
 /** @internal */
-const readonlyArray = differ => make$j({
-  empty: empty$b(),
+const readonlyArray = differ => make$h({
+  empty: empty$a(),
   combine: (first, second) => combine$2(first, second),
   diff: (oldValue, newValue) => diff$4({
     oldValue,
@@ -6836,7 +6836,7 @@ const readonlyArray = differ => make$j({
 /** @internal */
 const update$2 = () => updateWith((_, a) => a);
 /** @internal */
-const updateWith = f => make$j({
+const updateWith = f => make$h({
   empty: identity,
   combine: (first, second) => {
     if (first === identity) {
@@ -6865,15 +6865,15 @@ const active = patch => patch & BIT_MASK;
 /** @internal */
 const enabled = patch => patch >> BIT_SHIFT & BIT_MASK;
 /** @internal */
-const make$i = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
+const make$g = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
 /** @internal */
-const empty$a = /*#__PURE__*/make$i(0, 0);
+const empty$9 = /*#__PURE__*/make$g(0, 0);
 /** @internal */
-const enable$2 = flag => make$i(flag, flag);
+const enable$2 = flag => make$g(flag, flag);
 /** @internal */
-const disable$1 = flag => make$i(flag, 0);
+const disable$1 = flag => make$g(flag, 0);
 /** @internal */
-const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$i(active(self) & ~flag, enabled(self)));
+const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$g(active(self) & ~flag, enabled(self)));
 /** @internal */
 const andThen = /*#__PURE__*/dual(2, (self, that) => self | that);
 /** @internal */
@@ -6902,19 +6902,19 @@ const interruption = self => isEnabled(self, Interruption);
 /** @internal */
 const isEnabled = /*#__PURE__*/dual(2, (self, flag) => (self & flag) !== 0);
 /** @internal */
-const make$h = (...flags) => flags.reduce((a, b) => a | b, 0);
+const make$f = (...flags) => flags.reduce((a, b) => a | b, 0);
 /** @internal */
-const none$1 = /*#__PURE__*/make$h(None$1);
+const none$1 = /*#__PURE__*/make$f(None$1);
 /** @internal */
 const runtimeMetrics = self => isEnabled(self, RuntimeMetrics);
 const windDown = self => isEnabled(self, WindDown);
 /** @internal */
-const diff$3 = /*#__PURE__*/dual(2, (self, that) => make$i(self ^ that, that));
+const diff$3 = /*#__PURE__*/dual(2, (self, that) => make$g(self ^ that, that));
 /** @internal */
 const patch$4 = /*#__PURE__*/dual(2, (self, patch) => self & (invert(active(patch)) | enabled(patch)) | active(patch) & enabled(patch));
 /** @internal */
-const differ$1 = /*#__PURE__*/make$j({
-  empty: empty$a,
+const differ$1 = /*#__PURE__*/make$h({
+  empty: empty$9,
   diff: (oldValue, newValue) => diff$3(oldValue, newValue),
   combine: (first, second) => andThen(second)(first),
   patch: (_patch, oldValue) => patch$4(oldValue, _patch)
@@ -6976,10 +6976,10 @@ const seq = (self, that) => ({
  */
 const flatten$2 = self => {
   let current = of(self);
-  let updated = empty$e();
+  let updated = empty$d();
   // eslint-disable-next-line no-constant-condition
   while (1) {
-    const [parallel, sequential] = reduce$1(current, [parallelCollectionEmpty(), empty$e()], ([parallel, sequential], blockedRequest) => {
+    const [parallel, sequential] = reduce$1(current, [parallelCollectionEmpty(), empty$d()], ([parallel, sequential], blockedRequest) => {
       const [par, seq] = step$1(blockedRequest);
       return [parallelCollectionCombine(parallel, par), appendAll(sequential, seq)];
     });
@@ -7000,8 +7000,8 @@ const flatten$2 = self => {
 const step$1 = requests => {
   let current = requests;
   let parallel = parallelCollectionEmpty();
-  let stack = empty$e();
-  let sequential = empty$e();
+  let stack = empty$d();
+  let sequential = empty$d();
   // eslint-disable-next-line no-constant-condition
   while (1) {
     switch (current._tag) {
@@ -7101,20 +7101,20 @@ class ParallelImpl {
   }
 }
 /** @internal */
-const parallelCollectionEmpty = () => new ParallelImpl(empty$f());
+const parallelCollectionEmpty = () => new ParallelImpl(empty$e());
 /** @internal */
-const parallelCollectionAdd = (self, blockedRequest) => new ParallelImpl(modifyAt(self.map, blockedRequest.dataSource, _ => orElseSome(map$9(_, append$1(blockedRequest.blockedRequest)), () => of$1(blockedRequest.blockedRequest))));
+const parallelCollectionAdd = (self, blockedRequest) => new ParallelImpl(modifyAt(self.map, blockedRequest.dataSource, _ => orElseSome(map$8(_, append(blockedRequest.blockedRequest)), () => of$1(blockedRequest.blockedRequest))));
 /** @internal */
-const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$2(self.map, that.map, (map, value, key) => set$2(map, key, match$6(get$3(map, key), {
+const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$2(self.map, that.map, (map, value, key) => set$2(map, key, match$5(get$3(map, key), {
   onNone: () => value,
   onSome: other => appendAll$1(value, other)
 }))));
 /** @internal */
-const parallelCollectionIsEmpty = self => isEmpty$5(self.map);
+const parallelCollectionIsEmpty = self => isEmpty$3(self.map);
 /** @internal */
 const parallelCollectionKeys = self => Array.from(keys(self.map));
 /** @internal */
-const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map$5(self.map, x => of$1(x)));
+const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map$4(self.map, x => of$1(x)));
 // TODO
 // /** @internal */
 // export const parallelCollectionToChunk = <R>(
@@ -7136,8 +7136,8 @@ class SequentialImpl {
 /** @internal */
 const sequentialCollectionMake = map => new SequentialImpl(map);
 /** @internal */
-const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$2(that.map, self.map, (map, value, key) => set$2(map, key, match$6(get$3(map, key), {
-  onNone: () => empty$j(),
+const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$2(that.map, self.map, (map, value, key) => set$2(map, key, match$5(get$3(map, key), {
+  onNone: () => empty$i(),
   onSome: a => appendAll$1(a, value)
 }))));
 /** @internal */
@@ -7227,27 +7227,27 @@ const proto$2 = {
 // Constructors
 // -----------------------------------------------------------------------------
 /** @internal */
-const empty$9 = /*#__PURE__*/(() => {
+const empty$8 = /*#__PURE__*/(() => {
   const o = /*#__PURE__*/Object.create(proto$2);
   o._tag = OP_EMPTY$2;
   return o;
 })();
 /** @internal */
-const fail$3 = error => {
+const fail$2 = error => {
   const o = Object.create(proto$2);
   o._tag = OP_FAIL$1;
   o.error = error;
   return o;
 };
 /** @internal */
-const die$2 = defect => {
+const die$1 = defect => {
   const o = Object.create(proto$2);
   o._tag = OP_DIE;
   o.defect = defect;
   return o;
 };
 /** @internal */
-const interrupt$3 = fiberId => {
+const interrupt$2 = fiberId => {
   const o = Object.create(proto$2);
   o._tag = OP_INTERRUPT;
   o.fiberId = fiberId;
@@ -7279,7 +7279,7 @@ const isEmptyType = self => self._tag === OP_EMPTY$2;
 /** @internal */
 const isDieType = self => self._tag === OP_DIE;
 /** @internal */
-const isEmpty$4 = self => {
+const isEmpty$2 = self => {
   if (self._tag === OP_EMPTY$2) {
     return true;
   }
@@ -7307,11 +7307,11 @@ const isInterrupted = self => isSome(interruptOption(self));
 /** @internal */
 const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
 /** @internal */
-const failures = self => reverse$1(reduce(self, empty$j(), (list, cause) => cause._tag === OP_FAIL$1 ? some(pipe(list, prepend$1(cause.error))) : none$4()));
+const failures = self => reverse$1(reduce(self, empty$i(), (list, cause) => cause._tag === OP_FAIL$1 ? some(pipe(list, prepend$1(cause.error))) : none$4()));
 /** @internal */
-const defects = self => reverse$1(reduce(self, empty$j(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend$1(cause.defect))) : none$4()));
+const defects = self => reverse$1(reduce(self, empty$i(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend$1(cause.defect))) : none$4()));
 /** @internal */
-const interruptors = self => reduce(self, empty$g(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none$4());
+const interruptors = self => reduce(self, empty$f(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none$4());
 /** @internal */
 const failureOption = self => find(self, cause => cause._tag === OP_FAIL$1 ? some(cause.error) : none$4());
 /** @internal */
@@ -7330,54 +7330,54 @@ const failureOrCause = self => {
   }
 };
 /** @internal */
-const flipCauseOption = self => match$4(self, {
-  onEmpty: some(empty$9),
-  onFail: map$9(fail$3),
-  onDie: defect => some(die$2(defect)),
-  onInterrupt: fiberId => some(interrupt$3(fiberId)),
+const flipCauseOption = self => match$3(self, {
+  onEmpty: some(empty$8),
+  onFail: map$8(fail$2),
+  onDie: defect => some(die$1(defect)),
+  onInterrupt: fiberId => some(interrupt$2(fiberId)),
   onSequential: mergeWith(sequential$2),
   onParallel: mergeWith(parallel$2)
 });
 /** @internal */
 const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? some(cause.fiberId) : none$4());
 /** @internal */
-const keepDefectsAndElectFailures = self => match$4(self, {
+const keepDefectsAndElectFailures = self => match$3(self, {
   onEmpty: none$4(),
-  onFail: failure => some(die$2(failure)),
-  onDie: defect => some(die$2(defect)),
+  onFail: failure => some(die$1(failure)),
+  onDie: defect => some(die$1(defect)),
   onInterrupt: () => none$4(),
   onSequential: mergeWith(sequential$2),
   onParallel: mergeWith(parallel$2)
 });
 /** @internal */
-const stripFailures = self => match$4(self, {
-  onEmpty: empty$9,
-  onFail: () => empty$9,
-  onDie: die$2,
-  onInterrupt: interrupt$3,
+const stripFailures = self => match$3(self, {
+  onEmpty: empty$8,
+  onFail: () => empty$8,
+  onDie: die$1,
+  onInterrupt: interrupt$2,
   onSequential: sequential$2,
   onParallel: parallel$2
 });
 /** @internal */
-const electFailures = self => match$4(self, {
-  onEmpty: empty$9,
-  onFail: die$2,
-  onDie: die$2,
-  onInterrupt: interrupt$3,
+const electFailures = self => match$3(self, {
+  onEmpty: empty$8,
+  onFail: die$1,
+  onDie: die$1,
+  onInterrupt: interrupt$2,
   onSequential: sequential$2,
   onParallel: parallel$2
 });
 /** @internal */
-const map$4 = /*#__PURE__*/dual(2, (self, f) => flatMap$3(self, e => fail$3(f(e))));
+const map$3 = /*#__PURE__*/dual(2, (self, f) => flatMap$3(self, e => fail$2(f(e))));
 // -----------------------------------------------------------------------------
 // Sequencing
 // -----------------------------------------------------------------------------
 /** @internal */
-const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => match$4(self, {
-  onEmpty: empty$9,
+const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => match$3(self, {
+  onEmpty: empty$8,
   onFail: error => f(error),
-  onDie: defect => die$2(defect),
-  onInterrupt: fiberId => interrupt$3(fiberId),
+  onDie: defect => die$1(defect),
+  onInterrupt: fiberId => interrupt$2(fiberId),
   onSequential: (left, right) => sequential$2(left, right),
   onParallel: (left, right) => parallel$2(left, right)
 }));
@@ -7386,11 +7386,11 @@ const causeEquals = (left, right) => {
   let leftStack = of$1(left);
   let rightStack = of$1(right);
   while (isNonEmpty$2(leftStack) && isNonEmpty$2(rightStack)) {
-    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce([empty$g(), empty$j()], ([parallel, sequential], cause) => {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce([empty$f(), empty$i()], ([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$g(), empty$j()], ([parallel, sequential], cause) => {
+    const [rightParallel, rightSequential] = pipe(headNonEmpty(rightStack), reduce([empty$f(), empty$i()], ([parallel, sequential], cause) => {
       const [par, seq] = evaluateCause(cause);
       return some([pipe(parallel, union(par)), pipe(sequential, appendAll$1(seq))]);
     }));
@@ -7413,18 +7413,18 @@ const causeEquals = (left, right) => {
  * @internal
  */
 const flattenCause = cause => {
-  return flattenCauseLoop(of$1(cause), empty$j());
+  return flattenCauseLoop(of$1(cause), empty$i());
 };
 /** @internal */
 const flattenCauseLoop = (causes, flattened) => {
   // eslint-disable-next-line no-constant-condition
   while (1) {
-    const [parallel, sequential] = pipe(causes, reduce$7([empty$g(), empty$j()], ([parallel, sequential], cause) => {
+    const [parallel, sequential] = pipe(causes, reduce$7([empty$f(), empty$i()], ([parallel, sequential], cause) => {
       const [par, seq] = evaluateCause(cause);
       return [pipe(parallel, union(par)), pipe(sequential, appendAll$1(seq))];
     }));
     const updated = size$1(parallel) > 0 ? pipe(flattened, prepend$1(parallel)) : flattened;
-    if (isEmpty$7(sequential)) {
+    if (isEmpty$5(sequential)) {
       return reverse$1(updated);
     }
     causes = sequential;
@@ -7475,8 +7475,8 @@ const find = /*#__PURE__*/dual(2, (self, pf) => {
 const evaluateCause = self => {
   let cause = self;
   const stack = [];
-  let _parallel = empty$g();
-  let _sequential = empty$j();
+  let _parallel = empty$f();
+  let _sequential = empty$i();
   while (cause !== undefined) {
     switch (cause._tag) {
       case OP_EMPTY$2:
@@ -7489,7 +7489,7 @@ const evaluateCause = self => {
         }
       case OP_FAIL$1:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.error));
+          _parallel = add(_parallel, make$n(cause._tag, cause.error));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7498,7 +7498,7 @@ const evaluateCause = self => {
         }
       case OP_DIE:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.defect));
+          _parallel = add(_parallel, make$n(cause._tag, cause.defect));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7507,7 +7507,7 @@ const evaluateCause = self => {
         }
       case OP_INTERRUPT:
         {
-          _parallel = add(_parallel, make$p(cause._tag, cause.fiberId));
+          _parallel = add(_parallel, make$n(cause._tag, cause.fiberId));
           if (stack.length === 0) {
             return [_parallel, _sequential];
           }
@@ -7563,7 +7563,7 @@ const IsInterruptedOnlyCauseReducer = {
 const OP_SEQUENTIAL_CASE = "SequentialCase";
 const OP_PARALLEL_CASE = "ParallelCase";
 /** @internal */
-const match$4 = /*#__PURE__*/dual(2, (self, {
+const match$3 = /*#__PURE__*/dual(2, (self, {
   onDie,
   onEmpty,
   onFail,
@@ -7874,7 +7874,7 @@ const pending = joiners => {
   };
 };
 /** @internal */
-const done$5 = effect => {
+const done$4 = effect => {
   return {
     _tag: OP_STATE_DONE,
     effect
@@ -8091,16 +8091,16 @@ const acquireUseRelease$1 = /*#__PURE__*/dual(3, (acquire, use, release) => unin
     onFailure: cause => {
       switch (exit._tag) {
         case OP_FAILURE:
-          return failCause$4(sequential$2(exit.effect_instruction_i0, cause));
+          return failCause$2(sequential$2(exit.effect_instruction_i0, cause));
         case OP_SUCCESS:
-          return failCause$4(cause);
+          return failCause$2(cause);
       }
     },
     onSuccess: () => exit
   }));
 }))));
 /* @internal */
-const as$1 = /*#__PURE__*/dual(2, (self, value) => flatMap$2(self, () => succeed$4(value)));
+const as$1 = /*#__PURE__*/dual(2, (self, value) => flatMap$2(self, () => succeed$2(value)));
 /* @internal */
 const asVoid$1 = self => as$1(self, void 0);
 /* @internal */
@@ -8143,7 +8143,7 @@ const unsafeAsync = (register, blockingOn = none$2) => {
     cancelerRef = register(resume);
   };
   effect.effect_instruction_i1 = blockingOn;
-  return onInterrupt(effect, _ => isEffect$1(cancelerRef) ? cancelerRef : void_$2);
+  return onInterrupt(effect, _ => isEffect$1(cancelerRef) ? cancelerRef : void_$1);
 };
 /* @internal */
 const asyncInterrupt = (register, blockingOn = none$2) => suspend$1(() => unsafeAsync(register, blockingOn));
@@ -8178,7 +8178,7 @@ const async_ = (resume, blockingOn = none$2) => {
       if (controllerRef) {
         controllerRef.abort();
       }
-      return cancelerRef ?? void_$2;
+      return cancelerRef ?? void_$1;
     }) : effect;
   });
 };
@@ -8192,7 +8192,7 @@ const catchAllCause$1 = /*#__PURE__*/dual(2, (self, f) => {
 /* @internal */
 const catchAll$1 = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
   onFailure: f,
-  onSuccess: succeed$4
+  onSuccess: succeed$2
 }));
 const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
 /* @internal */
@@ -8217,13 +8217,13 @@ const capture = (obj, span) => {
   return obj;
 };
 /* @internal */
-const die$1 = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime$1(fiber => failCause$4(die$2(capture(defect, currentSpanFromFiber(fiber))))) : failCause$4(die$2(defect));
+const die = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime$1(fiber => failCause$2(die$1(capture(defect, currentSpanFromFiber(fiber))))) : failCause$2(die$1(defect));
 /* @internal */
-const dieMessage$1 = message => failCauseSync(() => die$2(new RuntimeException(message)));
+const dieMessage$1 = message => failCauseSync(() => die$1(new RuntimeException(message)));
 /* @internal */
 const either = self => matchEffect(self, {
-  onFailure: e => succeed$4(left(e)),
-  onSuccess: a => succeed$4(right(a))
+  onFailure: e => succeed$2(left(e)),
+  onSuccess: a => succeed$2(right(a))
 });
 /* @internal */
 const exit$1 = self => matchCause$1(self, {
@@ -8231,19 +8231,19 @@ const exit$1 = self => matchCause$1(self, {
   onSuccess: exitSucceed$1
 });
 /* @internal */
-const fail$2 = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime$1(fiber => failCause$4(fail$3(capture(error, currentSpanFromFiber(fiber))))) : failCause$4(fail$3(error));
+const fail$1 = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime$1(fiber => failCause$2(fail$2(capture(error, currentSpanFromFiber(fiber))))) : failCause$2(fail$2(error));
 /* @internal */
-const failSync = evaluate => flatMap$2(sync$1(evaluate), fail$2);
+const failSync = evaluate => flatMap$2(sync$1(evaluate), fail$1);
 /* @internal */
-const failCause$4 = cause => {
+const failCause$2 = cause => {
   const effect = new EffectPrimitiveFailure(OP_FAILURE);
   effect.effect_instruction_i0 = cause;
   return effect;
 };
 /* @internal */
-const failCauseSync = evaluate => flatMap$2(sync$1(evaluate), failCause$4);
+const failCauseSync = evaluate => flatMap$2(sync$1(evaluate), failCause$2);
 /* @internal */
-const fiberId = /*#__PURE__*/withFiberRuntime$1(state => succeed$4(state.id()));
+const fiberId = /*#__PURE__*/withFiberRuntime$1(state => succeed$2(state.id()));
 /* @internal */
 const fiberIdWith$1 = f => withFiberRuntime$1(state => f(state.id()));
 /* @internal */
@@ -8263,8 +8263,8 @@ const step = self => {
 const flatten$1 = self => flatMap$2(self, identity);
 /* @internal */
 const matchCause$1 = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$2(self, {
-  onFailure: cause => succeed$4(options.onFailure(cause)),
-  onSuccess: a => succeed$4(options.onSuccess(a))
+  onFailure: cause => succeed$2(options.onFailure(cause)),
+  onSuccess: a => succeed$2(options.onSuccess(a))
 }));
 /* @internal */
 const matchCauseEffect$2 = /*#__PURE__*/dual(2, (self, options) => {
@@ -8279,13 +8279,13 @@ const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$2(s
   onFailure: cause => {
     const defects$1 = defects(cause);
     if (defects$1.length > 0) {
-      return failCause$4(electFailures(cause));
+      return failCause$2(electFailures(cause));
     }
     const failures$1 = failures(cause);
     if (failures$1.length > 0) {
       return options.onFailure(unsafeHead(failures$1));
     }
-    return failCause$4(cause);
+    return failCause$2(cause);
   },
   onSuccess: options.onSuccess
 }));
@@ -8315,9 +8315,9 @@ const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspend$1(()
   });
 }));
 /* @internal */
-const interrupt$2 = /*#__PURE__*/flatMap$2(fiberId, fiberId => interruptWith(fiberId));
+const interrupt$1 = /*#__PURE__*/flatMap$2(fiberId, fiberId => interruptWith(fiberId));
 /* @internal */
-const interruptWith = fiberId => failCause$4(interrupt$3(fiberId));
+const interruptWith = fiberId => failCause$2(interrupt$2(fiberId));
 /* @internal */
 const interruptible$2 = self => {
   const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
@@ -8328,7 +8328,7 @@ const interruptible$2 = self => {
 /* @internal */
 const intoDeferred$1 = /*#__PURE__*/dual(2, (self, deferred) => uninterruptibleMask$2(restore => flatMap$2(exit$1(restore(self)), exit => deferredDone(deferred, exit))));
 /* @internal */
-const map$3 = /*#__PURE__*/dual(2, (self, f) => flatMap$2(self, a => sync$1(() => f(a))));
+const map$2 = /*#__PURE__*/dual(2, (self, f) => flatMap$2(self, a => sync$1(() => f(a))));
 /* @internal */
 const mapBoth = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
   onFailure: e => failSync(() => options.onFailure(e)),
@@ -8345,11 +8345,11 @@ const mapError$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(self, {
         }
       case "Right":
         {
-          return failCause$4(either.right);
+          return failCause$2(either.right);
         }
     }
   },
-  onSuccess: succeed$4
+  onSuccess: succeed$2
 }));
 /* @internal */
 const onExit$1 = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask$2(restore => matchCauseEffect$2(restore(self), {
@@ -8362,25 +8362,25 @@ const onExit$1 = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask$2(r
   },
   onSuccess: success => {
     const result = exitSucceed$1(success);
-    return zipRight$2(cleanup(result), result);
+    return zipRight$1(cleanup(result), result);
   }
 })));
 /* @internal */
 const onInterrupt = /*#__PURE__*/dual(2, (self, cleanup) => onExit$1(self, exitMatch({
-  onFailure: cause => isInterruptedOnly(cause) ? asVoid$1(cleanup(interruptors(cause))) : void_$2,
-  onSuccess: () => void_$2
+  onFailure: cause => isInterruptedOnly(cause) ? asVoid$1(cleanup(interruptors(cause))) : void_$1,
+  onSuccess: () => void_$1
 })));
 /* @internal */
-const orElse = /*#__PURE__*/dual(2, (self, that) => attemptOrElse(self, that, succeed$4));
+const orElse = /*#__PURE__*/dual(2, (self, that) => attemptOrElse(self, that, succeed$2));
 /* @internal */
 const orDie = self => orDieWith(self, identity);
 /* @internal */
 const orDieWith = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
-  onFailure: e => die$1(f(e)),
-  onSuccess: succeed$4
+  onFailure: e => die(f(e)),
+  onSuccess: succeed$2
 }));
 /* @internal */
-const succeed$4 = value => {
+const succeed$2 = value => {
   const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
   effect.effect_instruction_i0 = value;
   return effect;
@@ -8404,10 +8404,10 @@ const tap$1 = /*#__PURE__*/dual(args => args.length === 3 || args.length === 2 &
     return as$1(b, a);
   } else if (isPromiseLike(b)) {
     return unsafeAsync(resume => {
-      b.then(_ => resume(succeed$4(a)), e => resume(fail$2(new UnknownException(e, "An unknown error occurred in Effect.tap"))));
+      b.then(_ => resume(succeed$2(a)), e => resume(fail$1(new UnknownException(e, "An unknown error occurred in Effect.tap"))));
     });
   }
-  return succeed$4(a);
+  return succeed$2(a);
 }));
 /* @internal */
 const transplant = f => withFiberRuntime$1(state => {
@@ -8420,7 +8420,7 @@ const attemptOrElse = /*#__PURE__*/dual(3, (self, that, onSuccess) => matchCause
   onFailure: cause => {
     const defects$1 = defects(cause);
     if (defects$1.length > 0) {
-      return failCause$4(getOrThrow(keepDefectsAndElectFailures(cause)));
+      return failCause$2(getOrThrow(keepDefectsAndElectFailures(cause)));
     }
     return that();
   },
@@ -8440,7 +8440,7 @@ const uninterruptibleMask$2 = f => custom(f, function () {
   effect.effect_instruction_i1 = oldFlags => interruption(oldFlags) ? internalCall(() => this.effect_instruction_i0(interruptible$2)) : internalCall(() => this.effect_instruction_i0(uninterruptible$1));
   return effect;
 });
-const void_$2 = /*#__PURE__*/succeed$4(void 0);
+const void_$1 = /*#__PURE__*/succeed$2(void 0);
 /* @internal */
 const updateRuntimeFlags = patch => {
   const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
@@ -8451,9 +8451,9 @@ const updateRuntimeFlags = patch => {
 /* @internal */
 const whenEffect = /*#__PURE__*/dual(2, (self, condition) => flatMap$2(condition, b => {
   if (b) {
-    return pipe(self, map$3(some));
+    return pipe(self, map$2(some));
   }
-  return succeed$4(none$4());
+  return succeed$2(none$4());
 }));
 /* @internal */
 const whileLoop = options => {
@@ -8493,13 +8493,13 @@ const yieldNow$2 = options => {
   return typeof options?.priority !== "undefined" ? withSchedulingPriority(effect, options.priority) : effect;
 };
 /* @internal */
-const zip$2 = /*#__PURE__*/dual(2, (self, that) => flatMap$2(self, a => map$3(that, b => [a, b])));
+const zip$1 = /*#__PURE__*/dual(2, (self, that) => flatMap$2(self, a => map$2(that, b => [a, b])));
 /* @internal */
 const zipLeft$1 = /*#__PURE__*/dual(2, (self, that) => flatMap$2(self, a => as$1(that, a)));
 /* @internal */
-const zipRight$2 = /*#__PURE__*/dual(2, (self, that) => flatMap$2(self, () => that));
+const zipRight$1 = /*#__PURE__*/dual(2, (self, that) => flatMap$2(self, () => that));
 /* @internal */
-const zipWith$1 = /*#__PURE__*/dual(3, (self, that, f) => flatMap$2(self, a => map$3(that, b => f(a, b))));
+const zipWith$1 = /*#__PURE__*/dual(3, (self, that, f) => flatMap$2(self, a => map$2(that, b => f(a, b))));
 // -----------------------------------------------------------------------------
 // Fiber
 // -----------------------------------------------------------------------------
@@ -8611,7 +8611,7 @@ const fiberRefSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(self, (
 const fiberRefModify = /*#__PURE__*/dual(2, (self, f) => withFiberRuntime$1(state => {
   const [b, a] = f(state.getFiberRef(self));
   state.setFiberRef(self, a);
-  return succeed$4(b);
+  return succeed$2(b);
 }));
 /* @internal */
 const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => acquireUseRelease$1(zipLeft$1(fiberRefGet(self), fiberRefSet(self, value)), () => use, oldValue => fiberRefSet(self, oldValue)));
@@ -8670,17 +8670,17 @@ const fiberRefUnsafeMakeRuntimeFlags = initial => fiberRefUnsafeMakePatch(initia
   fork: differ$1.empty
 });
 /** @internal */
-const currentContext = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(empty$k()));
+const currentContext = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(empty$j()));
 /** @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$f()));
+const currentLogAnnotations = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLogAnnotation"), () => fiberRefUnsafeMake(empty$e()));
 /** @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$e()));
+const currentLogSpan = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(empty$d()));
 /** @internal */
 const withSchedulingPriority = /*#__PURE__*/dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
 /** @internal */
@@ -8694,15 +8694,15 @@ const currentUnhandledErrorLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symb
 /** @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$m()));
+const currentMetricLabels = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(empty$l()));
 /** @internal */
 const currentForkScopeOverride = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(none$4(), {
   fork: () => none$4(),
   join: (parent, _) => parent
 }));
 /** @internal */
-const currentInterruptedCause = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty$9, {
-  fork: () => empty$9,
+const currentInterruptedCause = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty$8, {
+  fork: () => empty$8,
   join: (parent, _) => parent
 }));
 // -----------------------------------------------------------------------------
@@ -8727,7 +8727,7 @@ const scopeFork = (self, strategy) => self.fork(strategy);
 const YieldableError = /*#__PURE__*/function () {
   class YieldableError extends globalThis.Error {
     commit() {
-      return fail$2(this);
+      return fail$1(this);
     }
     toJSON() {
       const obj = {
@@ -8741,7 +8741,7 @@ const YieldableError = /*#__PURE__*/function () {
       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$3(this), {
+        return pretty(fail$2(this), {
           renderErrorCause: true
         });
       }
@@ -8823,9 +8823,9 @@ const exitAsVoid = self => exitAs(self, void 0);
 /** @internal */
 const exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel$2 : sequential$2);
 /** @internal */
-const exitDie$1 = defect => exitFailCause$1(die$2(defect));
+const exitDie$1 = defect => exitFailCause$1(die$1(defect));
 /** @internal */
-const exitFail = error => exitFailCause$1(fail$3(error));
+const exitFail = error => exitFailCause$1(fail$2(error));
 /** @internal */
 const exitFailCause$1 = cause => {
   const effect = new EffectPrimitiveFailure(OP_FAILURE);
@@ -8833,7 +8833,7 @@ const exitFailCause$1 = cause => {
   return effect;
 };
 /** @internal */
-const exitInterrupt$1 = fiberId => exitFailCause$1(interrupt$3(fiberId));
+const exitInterrupt$1 = fiberId => exitFailCause$1(interrupt$2(fiberId));
 /** @internal */
 const exitMap = /*#__PURE__*/dual(2, (self, f) => {
   switch (self._tag) {
@@ -8931,7 +8931,7 @@ const deferredUnsafeMake = fiberId => {
   const _deferred = {
     ...CommitPrototype,
     [DeferredTypeId]: deferredVariance,
-    state: make$k(pending([])),
+    state: make$i(pending([])),
     commit() {
       return deferredAwait(this);
     },
@@ -8969,7 +8969,7 @@ const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync$1(() =>
       }
     case OP_STATE_PENDING:
       {
-        set$3(self.state, done$5(effect));
+        set$3(self.state, done$4(effect));
         for (let i = 0, len = state.joiners.length; i < len; i++) {
           state.joiners[i](effect);
         }
@@ -8980,7 +8980,7 @@ const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync$1(() =>
 /* @internal */
 const deferredDone = /*#__PURE__*/dual(2, (self, exit) => deferredCompleteWith(self, exit));
 /* @internal */
-const deferredFailCause = /*#__PURE__*/dual(2, (self, cause) => deferredCompleteWith(self, failCause$4(cause)));
+const deferredFailCause = /*#__PURE__*/dual(2, (self, cause) => deferredCompleteWith(self, failCause$2(cause)));
 /* @internal */
 const deferredInterrupt = self => flatMap$2(fiberId, fiberId => deferredCompleteWith(self, interruptWith(fiberId)));
 /* @internal */
@@ -8988,12 +8988,12 @@ const deferredInterruptWith = /*#__PURE__*/dual(2, (self, fiberId) => deferredCo
 /* @internal */
 const deferredIsDone = self => sync$1(() => get$4(self.state)._tag === OP_STATE_DONE);
 /* @internal */
-const deferredSucceed = /*#__PURE__*/dual(2, (self, value) => deferredCompleteWith(self, succeed$4(value)));
+const deferredSucceed = /*#__PURE__*/dual(2, (self, value) => deferredCompleteWith(self, succeed$2(value)));
 /** @internal */
 const deferredUnsafeDone = (self, effect) => {
   const state = get$4(self.state);
   if (state._tag === OP_STATE_PENDING) {
-    set$3(self.state, done$5(effect));
+    set$3(self.state, done$4(effect));
     for (let i = 0, len = state.joiners.length; i < len; i++) {
       state.joiners[i](effect);
     }
@@ -9032,147 +9032,9 @@ const currentSpanFromFiber = fiber => {
   return span !== undefined && span._tag === "Span" ? some(span) : none$4();
 };
-/**
- * Creates a new `Deferred`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const make$g = deferredMake;
-const _await$1 = deferredAwait;
-/**
- * Exits the `Deferred` with the specified `Exit` value, which will be
- * propagated to all fibers waiting on the value of the `Deferred`.
- *
- * @since 2.0.0
- * @category utils
- */
-const done$4 = deferredDone;
-/**
- * Fails the `Deferred` with the specified `Cause`, which will be propagated to
- * all fibers waiting on the value of the `Deferred`.
- *
- * @since 2.0.0
- * @category utils
- */
-const failCause$3 = deferredFailCause;
-/**
- * Completes the `Deferred` with interruption. This will interrupt all fibers
- * waiting on the value of the `Deferred` with the `FiberId` of the fiber
- * calling this method.
- *
- * @since 2.0.0
- * @category utils
- */
-const interrupt$1 = deferredInterrupt;
-/**
- * Returns `true` if this `Deferred` has already been completed with a value or
- * an error, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isDone$4 = deferredIsDone;
-/**
- * Completes the `Deferred` with the specified value.
- *
- * @since 2.0.0
- * @category utils
- */
-const succeed$3 = deferredSucceed;
-/**
- * Unsafely creates a new `Deferred` from the specified `FiberId`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeMake$4 = deferredUnsafeMake;
-/**
- * Returns `true` if the specified `Exit` is a `Failure`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isFailure = exitIsFailure;
-/**
- * Returns `true` if the specified `Exit` is a `Success`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isSuccess = exitIsSuccess;
-/**
- * Collects all of the specified exit values into a `Some<Exit<List<A>, E>>`. If
- * the provided iterable contains no elements, `None` will be returned.
- *
- * @since 2.0.0
- * @category constructors
- */
-const all$2 = exitCollectAll;
-/**
- * Constructs a new `Exit.Failure` from the specified unrecoverable defect.
- *
- * @since 2.0.0
- * @category constructors
- */
-const die = exitDie$1;
-/**
- * Constructs a new `Exit.Failure` from the specified recoverable error of type
- * `E`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fail$1 = exitFail;
-/**
- * Constructs a new `Exit.Failure` from the specified `Cause` of type `E`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const failCause$2 = exitFailCause$1;
-/**
- * Maps over the `Success` value of the specified exit using the provided
- * function.
- *
- * @since 2.0.0
- * @category mapping
- */
-const map$2 = exitMap;
-/**
- * @since 2.0.0
- * @category folding
- */
-const match$3 = exitMatch;
-/**
- * Constructs a new `Exit.Success` containing the specified value of type `A`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeed$2 = exitSucceed$1;
-const void_$1 = exitVoid$1;
-/**
- * Sequentially zips the this result with the specified result or else returns
- * the failed `Cause<E | E2>`.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zip$1 = exitZip;
-/**
- * Sequentially zips the this result with the specified result discarding the
- * first element of the tuple or else returns the failed `Cause<E | E2>`.
- *
- * @since 2.0.0
- * @category zipping
- */
-const zipRight$1 = exitZipRight;
-const TypeId$6 = /*#__PURE__*/Symbol.for("effect/MutableHashMap");
+const TypeId$4 = /*#__PURE__*/Symbol.for("effect/MutableHashMap");
 const MutableHashMapProto = {
-  [TypeId$6]: TypeId$6,
+  [TypeId$4]: TypeId$4,
   [Symbol.iterator]() {
     return new MutableHashMapIterator(this);
   },
@@ -9241,7 +9103,7 @@ class BucketIterator {
  * @since 2.0.0
  * @category constructors
  */
-const empty$8 = () => {
+const empty$7 = () => {
   const self = Object.create(MutableHashMapProto);
   self.referential = new Map();
   self.buckets = new Map();
@@ -9313,7 +9175,7 @@ const removeFromBucket = (self, bucket, key) => {
 /**
  * @since 2.0.0
  */
-const remove$1 = /*#__PURE__*/dual(2, (self, key) => {
+const remove = /*#__PURE__*/dual(2, (self, key) => {
   if (isEqual(key) === false) {
     self.referential.delete(key);
     return self;
@@ -9337,296 +9199,6 @@ const size = self => {
   return self.referential.size + self.bucketsSize;
 };
-/**
- * @since 2.0.0
- */
-const TypeId$5 = /*#__PURE__*/Symbol.for("effect/MutableList");
-const MutableListProto = {
-  [TypeId$5]: TypeId$5,
-  [Symbol.iterator]() {
-    let done = false;
-    let head = this.head;
-    return {
-      next() {
-        if (done) {
-          return this.return();
-        }
-        if (head == null) {
-          done = true;
-          return this.return();
-        }
-        const value = head.value;
-        head = head.next;
-        return {
-          done,
-          value
-        };
-      },
-      return(value) {
-        if (!done) {
-          done = true;
-        }
-        return {
-          done: true,
-          value
-        };
-      }
-    };
-  },
-  toString() {
-    return format$2(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "MutableList",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const makeNode = value => ({
-  value,
-  removed: false,
-  prev: undefined,
-  next: undefined
-});
-/**
- * Creates an empty `MutableList`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const empty$7 = () => {
-  const list = Object.create(MutableListProto);
-  list.head = undefined;
-  list.tail = undefined;
-  list._length = 0;
-  return list;
-};
-/**
- * Returns `true` if the list contains zero elements, `false`, otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isEmpty$3 = self => length$1(self) === 0;
-/**
- * Returns the length of the list.
- *
- * @since 2.0.0
- * @category getters
- */
-const length$1 = self => self._length;
-/**
- * Appends the specified element to the end of the `MutableList`.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const append = /*#__PURE__*/dual(2, (self, value) => {
-  const node = makeNode(value);
-  if (self.head === undefined) {
-    self.head = node;
-  }
-  if (self.tail === undefined) {
-    self.tail = node;
-  } else {
-    self.tail.next = node;
-    node.prev = self.tail;
-    self.tail = node;
-  }
-  self._length += 1;
-  return self;
-});
-/**
- * Removes the first value from the list and returns it, if it exists.
- *
- * @since 0.0.1
- */
-const shift = self => {
-  const head = self.head;
-  if (head !== undefined) {
-    remove(self, head);
-    return head.value;
-  }
-  return undefined;
-};
-const remove = (self, node) => {
-  if (node.removed) {
-    return;
-  }
-  node.removed = true;
-  if (node.prev !== undefined && node.next !== undefined) {
-    node.prev.next = node.next;
-    node.next.prev = node.prev;
-  } else if (node.prev !== undefined) {
-    self.tail = node.prev;
-    node.prev.next = undefined;
-  } else if (node.next !== undefined) {
-    self.head = node.next;
-    node.next.prev = undefined;
-  } else {
-    self.tail = undefined;
-    self.head = undefined;
-  }
-  if (self._length > 0) {
-    self._length -= 1;
-  }
-};
-/**
- * @since 2.0.0
- */
-const TypeId$4 = /*#__PURE__*/Symbol.for("effect/MutableQueue");
-/**
- * @since 2.0.0
- * @category symbol
- */
-const EmptyMutableQueue = /*#__PURE__*/Symbol.for("effect/mutable/MutableQueue/Empty");
-const MutableQueueProto = {
-  [TypeId$4]: TypeId$4,
-  [Symbol.iterator]() {
-    return Array.from(this.queue)[Symbol.iterator]();
-  },
-  toString() {
-    return format$2(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "MutableQueue",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const make$f = capacity => {
-  const queue = Object.create(MutableQueueProto);
-  queue.queue = empty$7();
-  queue.capacity = capacity;
-  return queue;
-};
-/**
- * Creates a new bounded `MutableQueue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const bounded = capacity => make$f(capacity);
-/**
- * Creates a new unbounded `MutableQueue`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = () => make$f(undefined);
-/**
- * Returns the current number of elements in the queue.
- *
- * @since 2.0.0
- * @category getters
- */
-const length = self => length$1(self.queue);
-/**
- * Returns `true` if the queue is empty, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isEmpty$2 = self => isEmpty$3(self.queue);
-/**
- * The **maximum** number of elements that a queue can hold.
- *
- * **Note**: unbounded queues can still implement this interface with
- * `capacity = Infinity`.
- *
- * @since 2.0.0
- * @category getters
- */
-const capacity = self => self.capacity === undefined ? Infinity : self.capacity;
-/**
- * Offers an element to the queue.
- *
- * Returns whether the enqueue was successful or not.
- *
- * @since 2.0.0
- */
-const offer = /*#__PURE__*/dual(2, (self, value) => {
-  const queueLength = length$1(self.queue);
-  if (self.capacity !== undefined && queueLength === self.capacity) {
-    return false;
-  }
-  append(value)(self.queue);
-  return true;
-});
-/**
- * Enqueues a collection of values into the queue.
- *
- * Returns a `Chunk` of the values that were **not** able to be enqueued.
- *
- * @since 2.0.0
- */
-const offerAll = /*#__PURE__*/dual(2, (self, values) => {
-  const iterator = values[Symbol.iterator]();
-  let next;
-  let remainder = empty$j();
-  let offering = true;
-  while (offering && (next = iterator.next()) && !next.done) {
-    offering = offer(next.value)(self);
-  }
-  while (next != null && !next.done) {
-    remainder = prepend$1(next.value)(remainder);
-    next = iterator.next();
-  }
-  return reverse$1(remainder);
-});
-/**
- * Dequeues an element from the queue.
- *
- * Returns either an element from the queue, or the `def` param.
- *
- * **Note**: if there is no meaningful default for your type, you can always
- * use `poll(MutableQueue.EmptyMutableQueue)`.
- *
- * @since 2.0.0
- */
-const poll = /*#__PURE__*/dual(2, (self, def) => {
-  if (isEmpty$3(self.queue)) {
-    return def;
-  }
-  return shift(self.queue);
-});
-/**
- * Dequeues up to `n` elements from the queue.
- *
- * Returns a `List` of up to `n` elements.
- *
- * @since 2.0.0
- */
-const pollUpTo = /*#__PURE__*/dual(2, (self, n) => {
-  let result = empty$j();
-  let count = 0;
-  while (count < n) {
-    const element = poll(EmptyMutableQueue)(self);
-    if (element === EmptyMutableQueue) {
-      break;
-    }
-    result = prepend$1(element)(result);
-    count += 1;
-  }
-  return reverse$1(result);
-});
 /** @internal */
 const ClockSymbolKey = "effect/Clock";
 /** @internal */
@@ -9688,11 +9260,11 @@ class ClockImpl {
   currentTimeMillis = /*#__PURE__*/sync$1(() => this.unsafeCurrentTimeMillis());
   currentTimeNanos = /*#__PURE__*/sync$1(() => this.unsafeCurrentTimeNanos());
   scheduler() {
-    return succeed$4(globalClockScheduler);
+    return succeed$2(globalClockScheduler);
   }
   sleep(duration) {
     return async_(resume => {
-      const canceler = globalClockScheduler.unsafeSchedule(() => resume(void_$2), duration);
+      const canceler = globalClockScheduler.unsafeSchedule(() => resume(void_$1), duration);
       return asVoid$1(sync$1(canceler));
     });
   }
@@ -9884,7 +9456,7 @@ const patch$3 = /*#__PURE__*/dual(2, (path, patch) => {
         }
       case "MapName":
         {
-          output = map$8(output, patch.f);
+          output = map$7(output, patch.f);
           input = input.tail;
           break;
         }
@@ -9961,9 +9533,9 @@ const makeFlat = options => ({
 });
 /** @internal */
 const fromFlat = flat => make$d({
-  load: config => flatMap$2(fromFlatLoop(flat, empty$m(), config, false), chunk => match$6(head$1(chunk), {
-    onNone: () => fail$2(MissingData(empty$m(), `Expected a single value having structure: ${config}`)),
-    onSome: succeed$4
+  load: config => flatMap$2(fromFlatLoop(flat, empty$l(), config, false), chunk => match$5(head$1(chunk), {
+    onNone: () => fail$1(MissingData(empty$l(), `Expected a single value having structure: ${config}`)),
+    onSome: succeed$2
   })),
   flattened: flat
 });
@@ -10031,7 +9603,7 @@ const fromFlatLoop = (flat, prefix, config, split) => {
   switch (op._tag) {
     case OP_CONSTANT:
       {
-        return succeed$4(of$2(op.value));
+        return succeed$2(of$2(op.value));
       }
     case OP_DESCRIBED:
       {
@@ -10039,15 +9611,15 @@ const fromFlatLoop = (flat, prefix, config, split) => {
       }
     case OP_FAIL:
       {
-        return fail$2(MissingData(prefix, op.message));
+        return fail$1(MissingData(prefix, op.message));
       }
     case OP_FALLBACK:
       {
         return pipe(suspend$1(() => fromFlatLoop(flat, prefix, op.first, split)), catchAll$1(error1 => {
           if (op.condition(error1)) {
-            return pipe(fromFlatLoop(flat, prefix, op.second, split), catchAll$1(error2 => fail$2(Or(error1, error2))));
+            return pipe(fromFlatLoop(flat, prefix, op.second, split), catchAll$1(error2 => fail$1(Or(error1, error2))));
           }
-          return fail$2(error1);
+          return fail$1(error1);
         }));
       }
     case OP_LAZY:
@@ -10067,21 +9639,21 @@ const fromFlatLoop = (flat, prefix, config, split) => {
         return pipe(patch$3(prefix, flat.patch), flatMap$2(prefix => pipe(flat.load(prefix, op, split), flatMap$2(values => {
           if (values.length === 0) {
             const name = pipe(last(prefix), getOrElse(() => "<n/a>"));
-            return fail$2(MissingData([], `Expected ${op.description} with name ${name}`));
+            return fail$1(MissingData([], `Expected ${op.description} with name ${name}`));
           }
-          return succeed$4(values);
+          return succeed$2(values);
         }))));
       }
     case OP_SEQUENCE:
       {
         return pipe(patch$3(prefix, flat.patch), flatMap$2(patchedPrefix => pipe(flat.enumerateChildren(patchedPrefix), flatMap$2(indicesFrom), flatMap$2(indices => {
           if (indices.length === 0) {
-            return suspend$1(() => map$3(fromFlatLoop(flat, prefix, op.config, true), of$2));
+            return suspend$1(() => map$2(fromFlatLoop(flat, prefix, op.config, true), of$2));
           }
-          return pipe(forEachSequential(indices, index => fromFlatLoop(flat, append$2(prefix, `[${index}]`), op.config, true)), map$3(chunkChunk => {
+          return pipe(forEachSequential(indices, index => fromFlatLoop(flat, append$1(prefix, `[${index}]`), op.config, true)), map$2(chunkChunk => {
             const flattened = flatten$3(chunkChunk);
             if (flattened.length === 0) {
-              return of$2(empty$m());
+              return of$2(empty$l());
             }
             return of$2(flattened);
           }));
@@ -10090,11 +9662,11 @@ const fromFlatLoop = (flat, prefix, config, split) => {
     case OP_HASHMAP:
       {
         return suspend$1(() => pipe(patch$3(prefix, flat.patch), flatMap$2(prefix => pipe(flat.enumerateChildren(prefix), flatMap$2(keys => {
-          return pipe(keys, forEachSequential(key => fromFlatLoop(flat, concat(prefix, of$2(key)), op.valueConfig, split)), map$3(matrix => {
+          return pipe(keys, forEachSequential(key => fromFlatLoop(flat, concat(prefix, of$2(key)), op.valueConfig, split)), map$2(matrix => {
             if (matrix.length === 0) {
-              return of$2(empty$f());
+              return of$2(empty$e());
             }
-            return pipe(transpose(matrix), map$8(values => fromIterable$1(zip$3(fromIterable$6(keys), values))));
+            return pipe(transpose(matrix), map$7(values => fromIterable$1(zip$2(fromIterable$6(keys), values))));
           }));
         })))));
       }
@@ -10102,19 +9674,19 @@ const fromFlatLoop = (flat, prefix, config, split) => {
       {
         return suspend$1(() => pipe(fromFlatLoop(flat, prefix, op.left, split), either, flatMap$2(left => pipe(fromFlatLoop(flat, prefix, op.right, split), either, flatMap$2(right$1 => {
           if (isLeft(left) && isLeft(right$1)) {
-            return fail$2(And(left.left, right$1.left));
+            return fail$1(And(left.left, right$1.left));
           }
           if (isLeft(left) && isRight(right$1)) {
-            return fail$2(left.left);
+            return fail$1(left.left);
           }
           if (isRight(left) && isLeft(right$1)) {
-            return fail$2(right$1.left);
+            return fail$1(right$1.left);
           }
           if (isRight(left) && isRight(right$1)) {
             const path = pipe(prefix, join$1("."));
             const fail = fromFlatLoopFail(prefix, path);
-            const [lefts, rights] = extend$1(fail, fail, pipe(left.right, map$8(right)), pipe(right$1.right, map$8(right)));
-            return pipe(lefts, zip$3(rights), forEachSequential(([left, right]) => pipe(zip$2(left, right), map$3(([left, right]) => op.zip(left, right)))));
+            const [lefts, rights] = extend$1(fail, fail, pipe(left.right, map$7(right)), pipe(right$1.right, map$7(right)));
+            return pipe(lefts, zip$2(rights), forEachSequential(([left, right]) => pipe(zip$1(left, right), map$2(([left, right]) => op.zip(left, right)))));
           }
           throw new Error("BUG: ConfigProvider.fromFlatLoop - please report an issue at https://github.com/Effect-TS/effect/issues");
         })))));
@@ -10139,9 +9711,9 @@ const transpose = array => {
   return Object.keys(array[0]).map(column => array.map(row => row[column]));
 };
 const indicesFrom = quotedIndices => pipe(forEachSequential(quotedIndices, parseQuotedIndex), mapBoth({
-  onFailure: () => empty$m(),
+  onFailure: () => empty$l(),
   onSuccess: sort(Order$1)
-}), either, map$3(merge$3));
+}), either, map$2(merge$3));
 const QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/;
 const parseQuotedIndex = str => {
   const match = str.match(QUOTED_INDEX_REGEX);
@@ -10265,13 +9837,13 @@ class RandomImpl {
     return sync$1(() => this.PRNG.number());
   }
   get nextBoolean() {
-    return map$3(this.next, n => n > 0.5);
+    return map$2(this.next, n => n > 0.5);
   }
   get nextInt() {
     return sync$1(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER));
   }
   nextRange(min, max) {
-    return map$3(this.next, n => (max - min) * n + min);
+    return map$2(this.next, n => (max - min) * n + min);
   }
   nextIntBetween(min, max) {
     return sync$1(() => this.PRNG.integer(max - min) + min);
@@ -10286,7 +9858,7 @@ const shuffleWith = (elements, nextIntBounded) => {
     for (let i = buffer.length; i >= 2; i = i - 1) {
       numbers.push(i);
     }
-    return pipe(numbers, forEachSequentialDiscard(n => pipe(nextIntBounded(n), map$3(k => swap(buffer, n - 1, k)))), as$1(fromIterable$5(buffer)));
+    return pipe(numbers, forEachSequentialDiscard(n => pipe(nextIntBounded(n), map$2(k => swap(buffer, n - 1, k)))), as$1(fromIterable$5(buffer)));
   })));
 };
 const swap = (buffer, index1, index2) => {
@@ -10378,7 +9950,7 @@ const nativeTracer = /*#__PURE__*/make$b({
 });
 /** @internal */
-const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$k(), /*#__PURE__*/add$2(clockTag, /*#__PURE__*/make$e()), /*#__PURE__*/add$2(consoleTag, defaultConsole), /*#__PURE__*/add$2(randomTag, /*#__PURE__*/make$c(/*#__PURE__*/Math.random())), /*#__PURE__*/add$2(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add$2(tracerTag, nativeTracer));
+const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$j(), /*#__PURE__*/add$2(clockTag, /*#__PURE__*/make$e()), /*#__PURE__*/add$2(consoleTag, defaultConsole), /*#__PURE__*/add$2(randomTag, /*#__PURE__*/make$c(/*#__PURE__*/Math.random())), /*#__PURE__*/add$2(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add$2(tracerTag, nativeTracer));
 /**
  * The `FiberRef` holding the default `Effect` services.
  *
@@ -10754,7 +10326,7 @@ class RefImpl extends Class {
   }
 }
 /** @internal */
-const unsafeMake$2 = value => new RefImpl(make$k(value));
+const unsafeMake$2 = value => new RefImpl(make$i(value));
 /** @internal */
 const make$a = value => sync$1(() => unsafeMake$2(value));
 /** @internal */
@@ -10902,7 +10474,7 @@ const make$9 = (key, value) => {
 const isMetricLabel = u => hasProperty(u, MetricLabelTypeId);
 /* @internal */
-const asSome = self => map$3(self, some);
+const asSome = self => map$2(self, some);
 /* @internal */
 const try_$1 = arg => {
   let evaluate;
@@ -10915,9 +10487,9 @@ const try_$1 = arg => {
   }
   return suspend$1(() => {
     try {
-      return succeed$4(internalCall(evaluate));
+      return succeed$2(internalCall(evaluate));
     } catch (error) {
-      return fail$2(onFailure ? internalCall(() => onFailure(error)) : new UnknownException(error, "An unknown error occurred in Effect.try"));
+      return fail$1(onFailure ? internalCall(() => onFailure(error)) : new UnknownException(error, "An unknown error occurred in Effect.try"));
     }
   });
 };
@@ -10928,7 +10500,7 @@ const catchSomeCause$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(se
     switch (option._tag) {
       case "None":
         {
-          return failCause$4(cause);
+          return failCause$2(cause);
         }
       case "Some":
         {
@@ -10936,7 +10508,7 @@ const catchSomeCause$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(se
         }
     }
   },
-  onSuccess: succeed$4
+  onSuccess: succeed$2
 }));
 /* @internal */
 const clockWith = clockWith$1;
@@ -10944,8 +10516,8 @@ const clockWith = clockWith$1;
 const diffFiberRefs = self => summarized(self, fiberRefs, diff$2);
 /* @internal */
 const match$2 = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
-  onFailure: e => succeed$4(options.onFailure(e)),
-  onSuccess: a => succeed$4(options.onSuccess(a))
+  onFailure: e => succeed$2(options.onFailure(e)),
+  onSuccess: a => succeed$2(options.onSuccess(a))
 }));
 /* @internal */
 const forever$2 = self => {
@@ -10953,7 +10525,7 @@ const forever$2 = self => {
   return loop;
 };
 /* @internal */
-const fiberRefs = /*#__PURE__*/withFiberRuntime$1(state => succeed$4(state.getFiberRefs()));
+const fiberRefs = /*#__PURE__*/withFiberRuntime$1(state => succeed$2(state.getFiberRefs()));
 /* @internal */
 const ignore$1 = self => match$2(self, {
   onFailure: constVoid,
@@ -10976,11 +10548,11 @@ const logWithLevel = level => (...message) => {
     }
   }
   if (cause === undefined) {
-    cause = empty$9;
+    cause = empty$8;
   }
   return withFiberRuntime$1(fiberState => {
     fiberState.log(message, cause, levelOption);
-    return void_$2;
+    return void_$1;
   });
 };
 /** @internal */
@@ -10990,10 +10562,10 @@ const logError$1 = /*#__PURE__*/logWithLevel(Error$1);
 /* @internal */
 const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(self, {
   onFailure: c => failCauseSync(() => f(c)),
-  onSuccess: succeed$4
+  onSuccess: succeed$2
 }));
 /* @internal */
-const negate = self => map$3(self, b => !b);
+const negate = self => map$2(self, b => !b);
 /* @internal */
 const orElseSucceed$1 = /*#__PURE__*/dual(2, (self, evaluate) => orElse(self, () => sync$1(evaluate)));
 /* @internal */
@@ -11001,15 +10573,15 @@ const patchFiberRefs = patch => updateFiberRefs((fiberId, fiberRefs) => pipe(pat
 /* @internal */
 const promise$1 = evaluate => evaluate.length >= 1 ? async_((resolve, signal) => {
   try {
-    evaluate(signal).then(a => resolve(succeed$4(a)), e => resolve(die$1(e)));
+    evaluate(signal).then(a => resolve(succeed$2(a)), e => resolve(die(e)));
   } catch (e) {
-    resolve(die$1(e));
+    resolve(die(e));
   }
 }) : async_(resolve => {
   try {
-    evaluate().then(a => resolve(succeed$4(a)), e => resolve(die$1(e)));
+    evaluate().then(a => resolve(succeed$2(a)), e => resolve(die(e)));
   } catch (e) {
-    resolve(die$1(e));
+    resolve(die(e));
   }
 });
 /* @internal */
@@ -11019,26 +10591,26 @@ const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => context
 /* @internal */
 const sleep = sleep$1;
 /* @internal */
-const succeedNone = /*#__PURE__*/succeed$4(/*#__PURE__*/none$4());
+const succeedNone = /*#__PURE__*/succeed$2(/*#__PURE__*/none$4());
 /* @internal */
-const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap$2(summary, start => flatMap$2(self, value => map$3(summary, end => [f(start, end), value]))));
+const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap$2(summary, start => flatMap$2(self, value => map$2(summary, end => [f(start, end), value]))));
 /* @internal */
 const tapError$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(self, {
   onFailure: cause => {
     const either = failureOrCause(cause);
     switch (either._tag) {
       case "Left":
-        return zipRight$2(f(either.left), failCause$4(cause));
+        return zipRight$1(f(either.left), failCause$2(cause));
       case "Right":
-        return failCause$4(cause);
+        return failCause$2(cause);
     }
   },
-  onSuccess: succeed$4
+  onSuccess: succeed$2
 }));
 /* @internal */
 const tapErrorCause$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$2(self, {
-  onFailure: cause => zipRight$2(f(cause), failCause$4(cause)),
-  onSuccess: succeed$4
+  onFailure: cause => zipRight$1(f(cause), failCause$2(cause)),
+  onSuccess: succeed$2
 }));
 /* @internal */
 const tryPromise$1 = arg => {
@@ -11050,11 +10622,11 @@ const tryPromise$1 = arg => {
     evaluate = arg.try;
     catcher = arg.catch;
   }
-  const fail = e => catcher ? failSync(() => catcher(e)) : fail$2(new UnknownException(e, "An unknown error occurred in Effect.tryPromise"));
+  const fail = e => catcher ? failSync(() => catcher(e)) : fail$1(new UnknownException(e, "An unknown error occurred in Effect.tryPromise"));
   if (evaluate.length >= 1) {
     return async_((resolve, signal) => {
       try {
-        evaluate(signal).then(a => resolve(succeed$4(a)), e => resolve(fail(e)));
+        evaluate(signal).then(a => resolve(succeed$2(a)), e => resolve(fail(e)));
       } catch (e) {
         resolve(fail(e));
       }
@@ -11062,7 +10634,7 @@ const tryPromise$1 = arg => {
   }
   return async_(resolve => {
     try {
-      evaluate().then(a => resolve(succeed$4(a)), e => resolve(fail(e)));
+      evaluate().then(a => resolve(succeed$2(a)), e => resolve(fail(e)));
     } catch (e) {
       resolve(fail(e));
     }
@@ -11071,10 +10643,10 @@ const tryPromise$1 = arg => {
 /* @internal */
 const updateFiberRefs = f => withFiberRuntime$1(state => {
   state.setFiberRefs(f(state.id(), state.getFiberRefs()));
-  return void_$2;
+  return void_$1;
 });
 /* @internal */
-const when$1 = /*#__PURE__*/dual(2, (self, condition) => suspend$1(() => condition() ? map$3(self, some) : succeed$4(none$4())));
+const when$1 = /*#__PURE__*/dual(2, (self, condition) => suspend$1(() => condition() ? map$2(self, some) : succeed$2(none$4())));
 /** @internal */
 const OP_SEQUENTIAL = "Sequential";
@@ -11998,6 +11570,51 @@ class MixedScheduler {
  * @category schedulers
  */
 const defaultScheduler = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Scheduler/defaultScheduler"), () => new MixedScheduler(2048));
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+class SyncScheduler {
+  /**
+   * @since 2.0.0
+   */
+  tasks = /*#__PURE__*/new PriorityBuckets();
+  /**
+   * @since 2.0.0
+   */
+  deferred = false;
+  /**
+   * @since 2.0.0
+   */
+  scheduleTask(task, priority) {
+    if (this.deferred) {
+      defaultScheduler.scheduleTask(task, priority);
+    } else {
+      this.tasks.scheduleTask(task, priority);
+    }
+  }
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(fiber) {
+    return fiber.currentOpCount > fiber.getFiberRef(currentMaxOpsBeforeYield) ? fiber.getFiberRef(currentSchedulingPriority) : false;
+  }
+  /**
+   * @since 2.0.0
+   */
+  flush() {
+    while (this.tasks.buckets.length > 0) {
+      const tasks = this.tasks.buckets;
+      this.tasks.buckets = [];
+      for (const [_, toRun] of tasks) {
+        for (let i = 0; i < toRun.length; i++) {
+          toRun[i]();
+        }
+      }
+    }
+    this.deferred = true;
+  }
+}
 /** @internal */
 const currentScheduler = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentScheduler"), () => fiberRefUnsafeMake(defaultScheduler));
@@ -12597,7 +12214,7 @@ const histogram$1 = key => {
   let sum = 0;
   let min = Number.MAX_VALUE;
   let max = Number.MIN_VALUE;
-  pipe(bounds, sort(Order$1), map$8((n, i) => {
+  pipe(bounds, sort(Order$1), map$7((n, i) => {
     boundaries[i] = n;
   }));
   // Insert the value into the right bucket with a binary search
@@ -12727,7 +12344,7 @@ const calculateQuantiles = (error, sortedQuantiles, sortedSamples) => {
   // The number of samples examined
   const sampleCount = sortedSamples.length;
   if (!isNonEmptyReadonlyArray(sortedQuantiles)) {
-    return empty$m();
+    return empty$l();
   }
   const head = sortedQuantiles[0];
   const tail = sortedQuantiles.slice(1);
@@ -12736,7 +12353,7 @@ const calculateQuantiles = (error, sortedQuantiles, sortedSamples) => {
   tail.forEach(quantile => {
     resolved.push(resolveQuantile(error, sampleCount, resolvedHead.value, resolvedHead.consumed, quantile, resolvedHead.rest));
   });
-  return map$8(resolved, rq => [rq.quantile, rq.value]);
+  return map$7(resolved, rq => [rq.quantile, rq.value]);
 };
 /** @internal */
 const resolveQuantile = (error, sampleCount, current, consumed, quantile, rest) => {
@@ -12888,7 +12505,7 @@ const MetricRegistryTypeId = /*#__PURE__*/Symbol.for(MetricRegistrySymbolKey);
 /** @internal */
 class MetricRegistryImpl {
   [MetricRegistryTypeId] = MetricRegistryTypeId;
-  map = /*#__PURE__*/empty$8();
+  map = /*#__PURE__*/empty$7();
   snapshot() {
     const result = [];
     for (const [key, hook] of this.map) {
@@ -13095,7 +12712,7 @@ class ProxySupervisor {
     this.underlying.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$3(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$2(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -13112,7 +12729,7 @@ class Zip {
     this.right = right;
   }
   get value() {
-    return zip$2(this.left.value, this.right.value);
+    return zip$1(this.left.value, this.right.value);
   }
   onStart(context, effect, parent, fiber) {
     this.left.onStart(context, effect, parent, fiber);
@@ -13135,7 +12752,7 @@ class Zip {
     this.right.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$3(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$2(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -13169,7 +12786,7 @@ class Const {
     //
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$3(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$2(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -13183,7 +12800,7 @@ const fromEffect = effect => {
   return new Const(effect);
 };
 /** @internal */
-const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect(void_$2));
+const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect(void_$1));
 /**
  * Constructs a new `Differ`.
@@ -13191,7 +12808,7 @@ const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect
  * @since 2.0.0
  * @category constructors
  */
-const make$5 = make$j;
+const make$5 = make$h;
 /** @internal */
 const OP_EMPTY = "Empty";
@@ -13278,12 +12895,12 @@ const removeSupervisor = (self, that) => {
 /** @internal */
 const toSet = self => {
   if (equals$1(self, none)) {
-    return empty$g();
+    return empty$f();
   } else {
     if (isZip(self)) {
       return pipe(toSet(self.left), union(toSet(self.right)));
     } else {
-      return make$l(self);
+      return make$j(self);
     }
   }
 };
@@ -13375,7 +12992,7 @@ const contOpSuccess = {
       self.pushStack(cont);
       return internalCall(() => cont.effect_instruction_i1());
     } else {
-      return void_$2;
+      return void_$1;
     }
   },
   [OP_ITERATOR]: (self, cont, value) => {
@@ -13565,7 +13182,7 @@ class FiberRuntime extends Class {
   }
   get await() {
     return async_(resume => {
-      const cb = exit => resume(succeed$4(exit));
+      const cb = exit => resume(succeed$2(exit));
       this.tell(stateful((fiber, _) => {
         if (fiber._exitValue !== null) {
           cb(this._exitValue);
@@ -13611,13 +13228,13 @@ class FiberRuntime extends Class {
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   interruptAsFork(fiberId) {
-    return sync$1(() => this.tell(interruptSignal(interrupt$3(fiberId))));
+    return sync$1(() => this.tell(interruptSignal(interrupt$2(fiberId))));
   }
   /**
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   unsafeInterruptAsFork(fiberId) {
-    this.tell(interruptSignal(interrupt$3(fiberId)));
+    this.tell(interruptSignal(interrupt$2(fiberId)));
   }
   /**
    * Adds an observer to the list of observers.
@@ -13811,7 +13428,7 @@ class FiberRuntime extends Class {
    * log annotations and log level) may not be up-to-date.
    */
   isInterrupted() {
-    return !isEmpty$4(this.getFiberRef(currentInterruptedCause));
+    return !isEmpty$2(this.getFiberRef(currentInterruptedCause));
   }
   /**
    * Adds an interruptor to the set of interruptors that are interrupting this
@@ -13845,7 +13462,7 @@ class FiberRuntime extends Class {
     }
     let told = false;
     for (const child of this._children) {
-      child.tell(interruptSignal(interrupt$3(this.id())));
+      child.tell(interruptSignal(interrupt$2(this.id())));
       told = true;
     }
     return told;
@@ -14112,7 +13729,7 @@ class FiberRuntime extends Class {
     try {
       asyncRegister(callback);
     } catch (e) {
-      callback(failCause$4(die$2(e)));
+      callback(failCause$2(die$1(e)));
     }
   }
   pushStack(cont) {
@@ -14156,10 +13773,10 @@ class FiberRuntime extends Class {
     return sync$1(() => unsafeGet$1(this.currentContext, op));
   }
   ["Left"](op) {
-    return fail$2(op.left);
+    return fail$1(op.left);
   }
   ["None"](_) {
-    return fail$2(new NoSuchElementException());
+    return fail$1(new NoSuchElementException());
   }
   ["Right"](op) {
     return exitSucceed$1(op.right);
@@ -14178,21 +13795,21 @@ class FiberRuntime extends Class {
         switch (exit.cause._tag) {
           case "Interrupt":
             {
-              return resume(exitFailCause$1(interrupt$3(none$2)));
+              return resume(exitFailCause$1(interrupt$2(none$2)));
             }
           case "Fail":
             {
-              return resume(fail$2(exit.cause.error));
+              return resume(fail$1(exit.cause.error));
             }
           case "Die":
             {
-              return resume(die$1(exit.cause.defect));
+              return resume(die(exit.cause.defect));
             }
         }
       });
       return unsafeAsync(abortResume => {
         resume = _ => {
-          abortResume(void_$2);
+          abortResume(void_$1);
         };
         fiber.unsafeInterrupt();
       });
@@ -14401,7 +14018,7 @@ class FiberRuntime extends Class {
             const level = this.getFiberRef(currentVersionMismatchErrorLogLevel);
             if (level._tag === "Some") {
               const effectVersion = cur[EffectTypeId]._V;
-              this.log(`Executing an Effect versioned ${effectVersion} with a Runtime of version ${getCurrentVersion()}, you may want to dedupe the effect dependencies, you can use the language service plugin to detect this at compile time: https://github.com/Effect-TS/language-service`, empty$9, level);
+              this.log(`Executing an Effect versioned ${effectVersion} with a Runtime of version ${getCurrentVersion()}, you may want to dedupe the effect dependencies, you can use the language service plugin to detect this at compile time: https://github.com/Effect-TS/language-service`, empty$8, level);
             }
           }
           // @ts-expect-error
@@ -14413,15 +14030,15 @@ class FiberRuntime extends Class {
             return YieldedOp;
           }
           yieldedOpChannel.currentOp = null;
-          return op._op === OP_SUCCESS || op._op === OP_FAILURE ? op : exitFailCause$1(die$2(op));
+          return op._op === OP_SUCCESS || op._op === OP_FAILURE ? op : exitFailCause$1(die$1(op));
         }
       } catch (e) {
         if (cur !== YieldedOp && !hasProperty(cur, "_op") || !(cur._op in this)) {
           cur = dieMessage$1(`Not a valid effect: ${toStringUnknown(cur)}`);
         } else if (isInterruptedException(e)) {
-          cur = exitFailCause$1(sequential$2(die$2(e), interrupt$3(none$2)));
+          cur = exitFailCause$1(sequential$2(die$1(e), interrupt$2(none$2)));
         } else {
-          cur = die$1(e);
+          cur = die(e);
         }
       }
     }
@@ -14468,7 +14085,7 @@ const tracerLogger = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Lo
   span.value.event(toStringUnknown(Array.isArray(message) && message.length === 1 ? message[0] : message), clockService.unsafeCurrentTimeNanos(), attributes);
 }));
 /** @internal */
-const currentLoggers = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make$l(defaultLogger, tracerLogger)));
+const currentLoggers = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make$j(defaultLogger, tracerLogger)));
 // === all
 const allResolveInput = input => {
   if (Array.isArray(input) || isIterable(input)) {
@@ -14510,11 +14127,11 @@ const allValidate = (effects, reconcile, options) => {
       }
     }
     if (errored) {
-      return reconcile._tag === "Some" ? fail$2(reconcile.value(errors)) : fail$2(errors);
+      return reconcile._tag === "Some" ? fail$1(reconcile.value(errors)) : fail$1(errors);
     } else if (options?.discard) {
-      return void_$2;
+      return void_$1;
     }
-    return reconcile._tag === "Some" ? succeed$4(reconcile.value(successes)) : succeed$4(successes);
+    return reconcile._tag === "Some" ? succeed$2(reconcile.value(successes)) : succeed$2(successes);
   });
 };
 const allEither = (effects, reconcile, options) => {
@@ -14530,7 +14147,7 @@ const allEither = (effects, reconcile, options) => {
       concurrentFinalizers: options?.concurrentFinalizers
     });
   }
-  return map$3(forEach$1(eitherEffects, identity, {
+  return map$2(forEach$1(eitherEffects, identity, {
     concurrency: options?.concurrency,
     batching: options?.batching,
     concurrentFinalizers: options?.concurrentFinalizers
@@ -14544,7 +14161,7 @@ const all$1 = (arg, options) => {
   } else if (options?.mode === "either") {
     return allEither(effects, reconcile, options);
   }
-  return options?.discard !== true && reconcile._tag === "Some" ? map$3(forEach$1(effects, identity, options), reconcile.value) : forEach$1(effects, identity, options);
+  return options?.discard !== true && reconcile._tag === "Some" ? map$2(forEach$1(effects, identity, options), reconcile.value) : forEach$1(effects, identity, options);
 };
 /* @internal */
 const forEach$1 = /*#__PURE__*/dual(args => isIterable(args[0]), (self, f, options) => withFiberRuntime$1(r => {
@@ -14559,14 +14176,14 @@ const forEachParUnbounded = (self, f, batching) => suspend$1(() => {
   const as = fromIterable$6(self);
   const array = new Array(as.length);
   const fn = (a, i) => flatMap$2(f(a, i), b => sync$1(() => array[i] = b));
-  return zipRight$2(forEachConcurrentDiscard(as, fn, batching, false), succeed$4(array));
+  return zipRight$1(forEachConcurrentDiscard(as, fn, batching, false), succeed$2(array));
 });
 /** @internal */
 const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterruptibleMask$2(restore => transplant(graft => withFiberRuntime$1(parent => {
   let todos = Array.from(self).reverse();
   let target = todos.length;
   if (target === 0) {
-    return void_$2;
+    return void_$1;
   }
   let counter = 0;
   let interrupted = false;
@@ -14642,7 +14259,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
               return returnNextElement();
             }
           }
-          return succeed$4(res);
+          return succeed$2(res);
         };
         const todo = flatMap$2(stepOrExit(restore(f(a, index))), onRes);
         const fiber = runFiber(todo);
@@ -14664,13 +14281,13 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
           fibers.delete(fiber);
           pushResult(exit, index);
           if (results.length === target) {
-            resume(succeed$4(getOrElse(exitCollectAll(collectExits(), {
+            resume(succeed$2(getOrElse(exitCollectAll(collectExits(), {
               parallel: true
             }), () => exitVoid$1)));
           } else if (residual.length + results.length === target) {
             const exits = collectExits();
             const requests = residual.map(blocked => blocked.effect_instruction_i0).reduce(par);
-            resume(succeed$4(blocked(requests, forEachConcurrentDiscard([getOrElse(exitCollectAll(exits, {
+            resume(succeed$2(blocked(requests, forEachConcurrentDiscard([getOrElse(exitCollectAll(exits, {
               parallel: true
             }), () => exitVoid$1), ...residual.map(blocked => blocked.effect_instruction_i1)], i => i, batching, true, n))));
           } else {
@@ -14719,8 +14336,8 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
 const forEachParN = (self, n, f, batching) => suspend$1(() => {
   const as = fromIterable$6(self);
   const array = new Array(as.length);
-  const fn = (a, i) => map$3(f(a, i), b => array[i] = b);
-  return zipRight$2(forEachConcurrentDiscard(as, fn, batching, false, n), succeed$4(array));
+  const fn = (a, i) => map$2(f(a, i), b => array[i] = b);
+  return zipRight$1(forEachConcurrentDiscard(as, fn, batching, false, n), succeed$2(array));
 });
 /* @internal */
 const forkDaemon$1 = self => forkWithScopeOverride(self, globalScope);
@@ -14737,7 +14354,7 @@ const unsafeForkUnstarted = (effect, parentFiber, parentRuntimeFlags, overrideSc
 };
 /** @internal */
 const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
-  const childId = unsafeMake$5();
+  const childId = unsafeMake$4();
   const parentFiberRefs = parentFiber.getFiberRefs();
   const childFiberRefs = forkAs(parentFiberRefs, childId);
   const childFiber = new FiberRuntime(childId, childFiberRefs, parentRuntimeFlags);
@@ -14750,9 +14367,9 @@ const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideS
   return childFiber;
 };
 /* @internal */
-const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime$1((parentFiber, parentStatus) => succeed$4(unsafeFork$1(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
+const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime$1((parentFiber, parentStatus) => succeed$2(unsafeFork$1(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
 /* @internal */
-const parallelFinalizers = self => contextWithEffect(context => match$6(getOption(context, scopeTag), {
+const parallelFinalizers = self => contextWithEffect(context => match$5(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     switch (scope.strategy._tag) {
@@ -14765,7 +14382,7 @@ const parallelFinalizers = self => contextWithEffect(context => match$6(getOptio
   }
 }));
 /* @internal */
-const parallelNFinalizers = parallelism => self => contextWithEffect(context => match$6(getOption(context, scopeTag), {
+const parallelNFinalizers = parallelism => self => contextWithEffect(context => match$5(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     if (scope.strategy._tag === "ParallelN" && scope.strategy.parallelism === parallelism) {
@@ -14775,7 +14392,7 @@ const parallelNFinalizers = parallelism => self => contextWithEffect(context =>
   }
 }));
 /* @internal */
-const finalizersMaskInternal = (strategy, concurrentFinalizers) => self => contextWithEffect(context => match$6(getOption(context, scopeTag), {
+const finalizersMaskInternal = (strategy, concurrentFinalizers) => self => contextWithEffect(context => match$5(getOption(context, scopeTag), {
   onNone: () => self(identity),
   onSome: scope => {
     if (concurrentFinalizers === true) {
@@ -14798,7 +14415,7 @@ const scopeWith = f => flatMap$2(scopeTag, f);
 /** @internal */
 const scopedWith$1 = f => flatMap$2(scopeMake(), scope => onExit$1(f(scope), exit => scope.close(exit)));
 /* @internal */
-const sequentialFinalizers = self => contextWithEffect(context => match$6(getOption(context, scopeTag), {
+const sequentialFinalizers = self => contextWithEffect(context => match$5(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     switch (scope.strategy._tag) {
@@ -14822,12 +14439,12 @@ const zipLeftOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, tha
 /** @internal */
 const zipRightOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, that, options) => {
   if (options?.concurrent !== true && (options?.batching === undefined || options.batching === false)) {
-    return zipRight$2(self, that);
+    return zipRight$1(self, that);
   }
   return zipWithOptions(self, that, (_, b) => b, options);
 });
 /** @internal */
-const zipWithOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, that, f, options) => map$3(all$1([self, that], {
+const zipWithOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, that, f, options) => map$2(all$1([self, that], {
   concurrency: options?.concurrent ? 2 : 1,
   batching: options?.batching,
   concurrentFinalizers: options?.concurrentFinalizers
@@ -14869,7 +14486,7 @@ const ScopeImplProto = {
   close(exit) {
     return suspend$1(() => {
       if (this.state._tag === "Closed") {
-        return void_$2;
+        return void_$1;
       }
       const finalizers = Array.from(this.state.finalizers.values()).reverse();
       this.state = {
@@ -14877,13 +14494,13 @@ const ScopeImplProto = {
         exit
       };
       if (finalizers.length === 0) {
-        return void_$2;
+        return void_$1;
       }
-      return isSequential(this.strategy) ? pipe(forEachSequential(finalizers, fin => exit$1(fin(exit))), flatMap$2(results => pipe(exitCollectAll(results), map$9(exitAsVoid), getOrElse(() => exitVoid$1)))) : isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit$1(fin(exit)), false), flatMap$2(results => pipe(exitCollectAll(results, {
+      return isSequential(this.strategy) ? pipe(forEachSequential(finalizers, fin => exit$1(fin(exit))), flatMap$2(results => pipe(exitCollectAll(results), map$8(exitAsVoid), getOrElse(() => exitVoid$1)))) : isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit$1(fin(exit)), false), flatMap$2(results => pipe(exitCollectAll(results, {
         parallel: true
-      }), map$9(exitAsVoid), getOrElse(() => exitVoid$1)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => exit$1(fin(exit)), false), flatMap$2(results => pipe(exitCollectAll(results, {
+      }), map$8(exitAsVoid), getOrElse(() => exitVoid$1)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => exit$1(fin(exit)), false), flatMap$2(results => pipe(exitCollectAll(results, {
         parallel: true
-      }), map$9(exitAsVoid), getOrElse(() => exitVoid$1))));
+      }), map$8(exitAsVoid), getOrElse(() => exitVoid$1))));
     });
   },
   addFinalizer(fin) {
@@ -14892,7 +14509,7 @@ const ScopeImplProto = {
         return fin(this.state.exit);
       }
       this.state.finalizers.set({}, fin);
-      return void_$2;
+      return void_$1;
     });
   }
 };
@@ -14910,7 +14527,7 @@ const scopeMake = (strategy = sequential$1) => sync$1(() => scopeUnsafeMake(stra
 /* @internal */
 const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => mapInputContext(effect,
 // @ts-expect-error
-merge$1(make$q(scopeTag, scope))));
+merge$1(make$o(scopeTag, scope))));
 // circular with Supervisor
 /** @internal */
 const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial, {
@@ -14965,7 +14582,7 @@ const race$1 = /*#__PURE__*/dual(2, (self, that) => fiberIdWith$1(parentFiberId
 /** @internal */
 const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberRuntime$1((parentFiber, parentStatus) => {
   const parentRuntimeFlags = parentStatus.runtimeFlags;
-  const raceIndicator = make$k(true);
+  const raceIndicator = make$i(true);
   const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
   const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
   return async_(cb => {
@@ -14983,8 +14600,8 @@ const completeRace = (winner, loser, cont, ab, cb) => {
 /** @internal */
 const ensuring$1 = /*#__PURE__*/dual(2, (self, finalizer) => uninterruptibleMask$2(restore => matchCauseEffect$2(restore(self), {
   onFailure: cause1 => matchCauseEffect$2(finalizer, {
-    onFailure: cause2 => failCause$4(sequential$2(cause1, cause2)),
-    onSuccess: () => failCause$4(cause1)
+    onFailure: cause2 => failCause$2(sequential$2(cause1, cause2)),
+    onSuccess: () => failCause$2(cause1)
   }),
   onSuccess: a => as$1(finalizer, a)
 })));
@@ -15132,7 +14749,7 @@ const make$3 = intervals => {
   };
 };
 /** @internal */
-const intersect$2 = /*#__PURE__*/dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$j()));
+const intersect$2 = /*#__PURE__*/dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$i()));
 /** @internal */
 const intersectLoop = (_left, _right, _acc) => {
   let left = _left;
@@ -15345,7 +14962,7 @@ class Semaphore {
         }
         this.waiters.delete(observer);
         this.taken += n;
-        resume(succeed$4(n));
+        resume(succeed$2(n));
       };
       this.waiters.add(observer);
       return sync$1(() => {
@@ -15353,7 +14970,7 @@ class Semaphore {
       });
     }
     this.taken += n;
-    return resume(succeed$4(n));
+    return resume(succeed$2(n));
   });
   updateTakenUnsafe(fiber, f) {
     this.taken = f(this.taken);
@@ -15367,7 +14984,7 @@ class Semaphore {
         }
       }, fiber.getFiberRef(currentSchedulingPriority));
     }
-    return succeed$4(this.free);
+    return succeed$2(this.free);
   }
   updateTaken(f) {
     return withFiberRuntime$1(fiber => this.updateTakenUnsafe(fiber, f));
@@ -15375,7 +14992,7 @@ class Semaphore {
   resize = permits => asVoid$1(withFiberRuntime$1(fiber => {
     this.permits = permits;
     if (this.free < 0) {
-      return void_$2;
+      return void_$1;
     }
     return this.updateTakenUnsafe(fiber, taken => taken);
   }));
@@ -15399,7 +15016,7 @@ const forkIn$1 = /*#__PURE__*/dual(2, (self, scope) => withFiberRuntime$1((paren
   const scopeImpl = scope;
   const fiber = unsafeFork$1(self, parent, parentStatus.runtimeFlags, globalScope);
   if (scopeImpl.state._tag === "Open") {
-    const finalizer = () => fiberIdWith$1(fiberId => equals$1(fiberId, fiber.id()) ? void_$2 : asVoid$1(interruptFiber(fiber)));
+    const finalizer = () => fiberIdWith$1(fiberId => equals$1(fiberId, fiber.id()) ? void_$1 : asVoid$1(interruptFiber(fiber)));
     const key = {};
     scopeImpl.state.finalizers.set(key, finalizer);
     fiber.addObserver(() => {
@@ -15409,7 +15026,7 @@ const forkIn$1 = /*#__PURE__*/dual(2, (self, scope) => withFiberRuntime$1((paren
   } else {
     fiber.unsafeInterruptAsFork(parent.id());
   }
-  return succeed$4(fiber);
+  return succeed$2(fiber);
 }));
 /** @internal */
 const raceFirst$1 = /*#__PURE__*/dual(2, (self, that) => pipe(exit$1(self), race$1(exit$1(that)), effect => flatten$1(effect)));
@@ -15441,7 +15058,7 @@ class SynchronizedImpl extends Class {
     return this.get;
   }
   modify(f) {
-    return this.modifyEffect(a => succeed$4(f(a)));
+    return this.modifyEffect(a => succeed$2(f(a)));
   }
   modifyEffect(f) {
     return this.withLock(pipe(flatMap$2(get(this.ref), f), flatMap$2(([b, a]) => as$1(set(this.ref, a), b))));
@@ -15475,7 +15092,7 @@ const makeDual = f => function () {
 };
 /** @internal */
 const unsafeFork = /*#__PURE__*/makeDual((runtime, self, options) => {
-  const fiberId = unsafeMake$5();
+  const fiberId = unsafeMake$4();
   const fiberRefUpdates = [[currentContext, [[fiberId, runtime.context]]]];
   if (options?.scheduler) {
     fiberRefUpdates.push([currentScheduler, [[fiberId, options.scheduler]]]);
@@ -15490,7 +15107,7 @@ const unsafeFork = /*#__PURE__*/makeDual((runtime, self, options) => {
   const fiberRuntime = new FiberRuntime(fiberId, fiberRefs, runtime.runtimeFlags);
   let effect = self;
   if (options?.scope) {
-    effect = flatMap$2(fork(options.scope, sequential$1), closeableScope => zipRight$2(scopeAddFinalizer(closeableScope, fiberIdWith$1(id => equals$1(id, fiberRuntime.id()) ? void_$2 : interruptAsFiber(fiberRuntime, id))), onExit$1(self, exit => close(closeableScope, exit))));
+    effect = flatMap$2(fork(options.scope, sequential$1), closeableScope => zipRight$1(scopeAddFinalizer(closeableScope, fiberIdWith$1(id => equals$1(id, fiberRuntime.id()) ? void_$1 : interruptAsFiber(fiberRuntime, id))), onExit$1(self, exit => close(closeableScope, exit))));
   }
   const supervisor = fiberRuntime.currentSupervisor;
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
@@ -15508,6 +15125,31 @@ const unsafeFork = /*#__PURE__*/makeDual((runtime, self, options) => {
   return fiberRuntime;
 });
 /** @internal */
+const unsafeRunSync = /*#__PURE__*/makeDual((runtime, effect) => {
+  const result = unsafeRunSyncExit(runtime)(effect);
+  if (result._tag === "Failure") {
+    throw fiberFailure(result.effect_instruction_i0);
+  }
+  return result.effect_instruction_i0;
+});
+class AsyncFiberExceptionImpl extends Error {
+  fiber;
+  _tag = "AsyncFiberException";
+  constructor(fiber) {
+    super(`Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`);
+    this.fiber = fiber;
+    this.name = this._tag;
+    this.stack = this.message;
+  }
+}
+const asyncFiberException = fiber => {
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 0;
+  const error = new AsyncFiberExceptionImpl(fiber);
+  Error.stackTraceLimit = limit;
+  return error;
+};
+/** @internal */
 const FiberFailureId = /*#__PURE__*/Symbol.for("effect/Runtime/FiberFailure");
 /** @internal */
 const FiberFailureCauseId = /*#__PURE__*/Symbol.for("effect/Runtime/FiberFailure/Cause");
@@ -15576,6 +15218,23 @@ const fastPath = effect => {
   }
 };
 /** @internal */
+const unsafeRunSyncExit = /*#__PURE__*/makeDual((runtime, effect) => {
+  const op = fastPath(effect);
+  if (op) {
+    return op;
+  }
+  const scheduler = new SyncScheduler();
+  const fiberRuntime = unsafeFork(runtime)(effect, {
+    scheduler
+  });
+  scheduler.flush();
+  const result = fiberRuntime.unsafePoll();
+  if (result) {
+    return result;
+  }
+  return exitDie$1(capture(asyncFiberException(fiberRuntime), currentSpanFromFiber(fiberRuntime)));
+});
+/** @internal */
 const unsafeRunPromise = /*#__PURE__*/makeDual((runtime, effect, options) => unsafeRunPromiseExit(runtime, effect, options).then(result => {
   switch (result._tag) {
     case OP_SUCCESS:
@@ -15627,12 +15286,12 @@ class RuntimeImpl {
 /** @internal */
 const make = options => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs);
 /** @internal */
-const runtime$1 = () => withFiberRuntime$1((state, status) => succeed$4(new RuntimeImpl(state.getFiberRef(currentContext), status.runtimeFlags, state.getFiberRefs())));
+const runtime$1 = () => withFiberRuntime$1((state, status) => succeed$2(new RuntimeImpl(state.getFiberRef(currentContext), status.runtimeFlags, state.getFiberRefs())));
 /** @internal */
-const defaultRuntimeFlags = /*#__PURE__*/make$h(Interruption, CooperativeYielding, RuntimeMetrics);
+const defaultRuntimeFlags = /*#__PURE__*/make$f(Interruption, CooperativeYielding, RuntimeMetrics);
 /** @internal */
 const defaultRuntime = /*#__PURE__*/make({
-  context: /*#__PURE__*/empty$k(),
+  context: /*#__PURE__*/empty$j(),
   runtimeFlags: defaultRuntimeFlags,
   fiberRefs: /*#__PURE__*/empty$4()
 });
@@ -15640,6 +15299,8 @@ const defaultRuntime = /*#__PURE__*/make({
 const unsafeForkEffect = /*#__PURE__*/unsafeFork(defaultRuntime);
 /** @internal */
 const unsafeRunPromiseEffect = /*#__PURE__*/unsafeRunPromise(defaultRuntime);
+/** @internal */
+const unsafeRunSyncEffect = /*#__PURE__*/unsafeRunSync(defaultRuntime);
 /** @internal */
 const modifyEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(f));
@@ -15699,26 +15360,26 @@ class MemoMapImpl {
       if (inMap !== undefined) {
         const [acquire, release] = inMap;
         const cached = pipe(acquire, flatMap$2(([patch, b]) => pipe(patchFiberRefs(patch), as$1(b))), onExit$1(exitMatch({
-          onFailure: () => void_$2,
+          onFailure: () => void_$1,
           onSuccess: () => scopeAddFinalizerExit(scope, release)
         })));
-        return succeed$4([cached, map]);
+        return succeed$2([cached, map]);
       }
-      return pipe(make$a(0), flatMap$2(observers => pipe(deferredMake(), flatMap$2(deferred => pipe(make$a(() => void_$2), map$3(finalizerRef => {
+      return pipe(make$a(0), flatMap$2(observers => pipe(deferredMake(), flatMap$2(deferred => pipe(make$a(() => void_$1), map$2(finalizerRef => {
         const resource = uninterruptibleMask$2(restore => pipe(scopeMake(), flatMap$2(innerScope => pipe(restore(flatMap$2(makeBuilder(layer, innerScope, true), f => diffFiberRefs(f(this)))), exit$1, flatMap$2(exit => {
           switch (exit._tag) {
             case OP_FAILURE:
               {
-                return pipe(deferredFailCause(deferred, exit.effect_instruction_i0), zipRight$2(scopeClose(innerScope, exit)), zipRight$2(failCause$4(exit.effect_instruction_i0)));
+                return pipe(deferredFailCause(deferred, exit.effect_instruction_i0), zipRight$1(scopeClose(innerScope, exit)), zipRight$1(failCause$2(exit.effect_instruction_i0)));
               }
             case OP_SUCCESS:
               {
-                return pipe(set(finalizerRef, exit => pipe(scopeClose(innerScope, exit), whenEffect(modify(observers, n => [n === 1, n - 1])), asVoid$1)), zipRight$2(update$1(observers, n => n + 1)), zipRight$2(scopeAddFinalizerExit(scope, exit => pipe(sync$1(() => map.delete(layer)), zipRight$2(get(finalizerRef)), flatMap$2(finalizer => finalizer(exit))))), zipRight$2(deferredSucceed(deferred, exit.effect_instruction_i0)), as$1(exit.effect_instruction_i0[1]));
+                return pipe(set(finalizerRef, exit => pipe(scopeClose(innerScope, exit), whenEffect(modify(observers, n => [n === 1, n - 1])), asVoid$1)), zipRight$1(update$1(observers, n => n + 1)), zipRight$1(scopeAddFinalizerExit(scope, exit => pipe(sync$1(() => map.delete(layer)), zipRight$1(get(finalizerRef)), flatMap$2(finalizer => finalizer(exit))))), zipRight$1(deferredSucceed(deferred, exit.effect_instruction_i0)), as$1(exit.effect_instruction_i0[1]));
               }
           }
         })))));
         const memoized = [pipe(deferredAwait(deferred), onExit$1(exitMatchEffect({
-          onFailure: () => void_$2,
+          onFailure: () => void_$1,
           onSuccess: () => update$1(observers, n => n + 1)
         }))), exit => pipe(get(finalizerRef), flatMap$2(finalizer => finalizer(exit)))];
         return [resource, isFresh(layer) ? map : map.set(layer, memoized)];
@@ -15727,7 +15388,7 @@ class MemoMapImpl {
   }
 }
 /** @internal */
-const makeMemoMap = /*#__PURE__*/suspend$1(() => map$3(makeSynchronized(new Map()), ref => new MemoMapImpl(ref)));
+const makeMemoMap = /*#__PURE__*/suspend$1(() => map$2(makeSynchronized(new Map()), ref => new MemoMapImpl(ref)));
 /** @internal */
 const unsafeMakeMemoMap = () => new MemoMapImpl(unsafeMakeSynchronized(new Map()));
 /** @internal */
@@ -15790,9 +15451,9 @@ const makeBuilder = (self, scope, inMemoMap = false) => {
     case "MergeAll":
       {
         const layers = op.layers;
-        return map$3(scopeFork(scope, parallel$1), parallelScope => memoMap => {
+        return map$2(scopeFork(scope, parallel$1), parallelScope => memoMap => {
           const contexts = new Array(layers.length);
-          return map$3(forEachConcurrentDiscard(layers, fnUntraced(function* (layer, i) {
+          return map$2(forEachConcurrentDiscard(layers, fnUntraced(function* (layer, i) {
             const scope = yield* scopeFork(parallelScope, sequential$1);
             const context = yield* memoMap.getOrElseMemoize(layer, scope);
             contexts[i] = context;
@@ -15826,7 +15487,7 @@ const provideSomeRuntime = /*#__PURE__*/dual(2, (self, rt) => {
     return ensuring$1(provideSomeContext(restore(self), merge$1(oldContext, rt.context)), withFiberRuntime$1(fiber => {
       fiber.setFiberRefs(patch$1(fiber.id(), fiber.getFiberRefs())(rollbackRefs));
       fiber.currentRuntimeFlags = patch$4(rollbackFlags)(fiber.currentRuntimeFlags);
-      return void_$2;
+      return void_$1;
     }));
   }));
 });
@@ -15927,7 +15588,7 @@ class ScheduleDriverImpl {
     this.ref = ref;
   }
   get state() {
-    return map$3(get(this.ref), tuple => tuple[1]);
+    return map$2(get(this.ref), tuple => tuple[1]);
   }
   get last() {
     return flatMap$2(get(this.ref), ([element, _]) => {
@@ -15938,7 +15599,7 @@ class ScheduleDriverImpl {
           }
         case "Some":
           {
-            return succeed$4(element.value);
+            return succeed$2(element.value);
           }
       }
     });
@@ -15948,17 +15609,17 @@ class ScheduleDriverImpl {
     return set(this.ref, [none$4(), this.schedule.initial]).pipe(zipLeft$1(set(this.iterationMeta, defaultIterationMetadata)));
   }
   next(input) {
-    return pipe(map$3(get(this.ref), tuple => tuple[1]), flatMap$2(state => pipe(currentTimeMillis, flatMap$2(now => pipe(suspend$1(() => this.schedule.step(now, input, state)), flatMap$2(([state, out, decision]) => {
+    return pipe(map$2(get(this.ref), tuple => tuple[1]), flatMap$2(state => pipe(currentTimeMillis, flatMap$2(now => pipe(suspend$1(() => this.schedule.step(now, input, state)), flatMap$2(([state, out, decision]) => {
       const setState = set(this.ref, [some(out), state]);
       if (isDone(decision)) {
-        return setState.pipe(zipRight$2(fail$2(none$4())));
+        return setState.pipe(zipRight$1(fail$1(none$4())));
       }
       const millis$1 = start(decision.intervals) - now;
       if (millis$1 <= 0) {
-        return setState.pipe(zipRight$2(updateInfo(this.iterationMeta, now, input, out)), as$1(out));
+        return setState.pipe(zipRight$1(updateInfo(this.iterationMeta, now, input, out)), as$1(out));
       }
       const duration = millis(millis$1);
-      return pipe(setState, zipRight$2(updateInfo(this.iterationMeta, now, input, out)), zipRight$2(sleep(duration)), as$1(out));
+      return pipe(setState, zipRight$1(updateInfo(this.iterationMeta, now, input, out)), zipRight$1(sleep(duration)), as$1(out));
     }))))));
   }
 }
@@ -15969,12 +15630,12 @@ const check = /*#__PURE__*/dual(2, (self, test) => checkEffect(self, (input, out
 /** @internal */
 const checkEffect = /*#__PURE__*/dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => flatMap$2(self.step(now, input, state), ([state, out, decision]) => {
   if (isDone(decision)) {
-    return succeed$4([state, out, done]);
+    return succeed$2([state, out, done]);
   }
-  return map$3(test(input, out), cont => cont ? [state, out, decision] : [state, out, done]);
+  return map$2(test(input, out), cont => cont ? [state, out, decision] : [state, out, done]);
 })));
 /** @internal */
-const driver = self => pipe(make$a([none$4(), self.initial]), map$3(ref => new ScheduleDriverImpl(self, ref)));
+const driver = self => pipe(make$a([none$4(), self.initial]), map$2(ref => new ScheduleDriverImpl(self, ref)));
 /** @internal */
 const intersect = /*#__PURE__*/dual(2, (self, that) => intersectWith(self, that, intersect$1));
 /** @internal */
@@ -15982,25 +15643,25 @@ const intersectWith = /*#__PURE__*/dual(3, (self, that, f) => makeWithState([sel
   if (isContinue(lDecision) && isContinue(rDecision)) {
     return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
   }
-  return succeed$4([[lState, rState], [out, out2], done]);
+  return succeed$2([[lState, rState], [out, out2], done]);
 }))));
 /** @internal */
 const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, out2, rInterval, f) => {
   const combined = f(lInterval, rInterval);
   if (isNonEmpty(combined)) {
-    return succeed$4([[lState, rState], [out, out2], _continue(combined)]);
+    return succeed$2([[lState, rState], [out, out2], _continue(combined)]);
   }
   if (pipe(lInterval, lessThan(rInterval))) {
     return flatMap$2(self.step(end(lInterval), input, lState), ([lState, out, decision]) => {
       if (isDone(decision)) {
-        return succeed$4([[lState, rState], [out, out2], done]);
+        return succeed$2([[lState, rState], [out, out2], done]);
       }
       return intersectWithLoop(self, that, input, lState, out, decision.intervals, rState, out2, rInterval, f);
     });
   }
   return flatMap$2(that.step(end(rInterval), input, rState), ([rState, out2, decision]) => {
     if (isDone(decision)) {
-      return succeed$4([[lState, rState], [out, out2], done]);
+      return succeed$2([[lState, rState], [out, out2], done]);
     }
     return intersectWithLoop(self, that, input, lState, out, lInterval, rState, out2, decision.intervals, f);
   });
@@ -16008,9 +15669,9 @@ const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, ou
 /** @internal */
 const map$1 = /*#__PURE__*/dual(2, (self, f) => mapEffect(self, out => sync$1(() => f(out))));
 /** @internal */
-const mapEffect = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap$2(self.step(now, input, state), ([state, out, decision]) => map$3(f(out), out2 => [state, out2, decision]))));
+const mapEffect = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap$2(self.step(now, input, state), ([state, out, decision]) => map$2(f(out), out2 => [state, out2, decision]))));
 /** @internal */
-const passthrough = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), map$3(([state, _, decision]) => [state, input, decision])));
+const passthrough = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), map$2(([state, _, decision]) => [state, input, decision])));
 /** @internal */
 const recurs = n => whileOutput(forever$1, out => out < n);
 /** @internal */
@@ -16032,16 +15693,16 @@ class ScheduleDefect {
   }
 }
 const isScheduleDefect = u => hasProperty(u, ScheduleDefectTypeId);
-const scheduleDefectWrap = self => catchAll$1(self, e => die$1(new ScheduleDefect(e)));
+const scheduleDefectWrap = self => catchAll$1(self, e => die(new ScheduleDefect(e)));
 /** @internal */
-const scheduleDefectRefailCause = cause => match$6(find(cause, _ => isDieType(_) && isScheduleDefect(_.defect) ? some(_.defect) : none$4()), {
+const scheduleDefectRefailCause = cause => match$5(find(cause, _ => isDieType(_) && isScheduleDefect(_.defect) ? some(_.defect) : none$4()), {
   onNone: () => cause,
-  onSome: error => fail$3(error.error)
+  onSome: error => fail$2(error.error)
 });
 /** @internal */
-const scheduleDefectRefail = effect => catchAllCause$1(effect, cause => failCause$4(scheduleDefectRefailCause(cause)));
+const scheduleDefectRefail = effect => catchAllCause$1(effect, cause => failCause$2(scheduleDefectRefailCause(cause)));
 /** @internal */
-const repeat_Effect = /*#__PURE__*/dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => fail$2(e)));
+const repeat_Effect = /*#__PURE__*/dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => fail$1(e)));
 /** @internal */
 const repeat_combined = /*#__PURE__*/dual(2, (self, options) => {
   if (isSchedule(options)) {
@@ -16051,14 +15712,14 @@ const repeat_combined = /*#__PURE__*/dual(2, (self, options) => {
   const withWhile = options.while ? whileInputEffect(base, a => {
     const applied = options.while(a);
     if (typeof applied === "boolean") {
-      return succeed$4(applied);
+      return succeed$2(applied);
     }
     return scheduleDefectWrap(applied);
   }) : base;
   const withUntil = options.until ? untilInputEffect(withWhile, a => {
     const applied = options.until(a);
     if (typeof applied === "boolean") {
-      return succeed$4(applied);
+      return succeed$2(applied);
     }
     return scheduleDefectWrap(applied);
   }) : withWhile;
@@ -16542,14 +16203,14 @@ const withFiberRuntime = withFiberRuntime$1;
  * @since 2.0.0
  * @category Creating Effects
  */
-const fail = fail$2;
+const fail = fail$1;
 /**
  * Creates an `Effect` that fails with the specified `Cause`.
  *
  * @since 2.0.0
  * @category Creating Effects
  */
-const failCause = failCause$4;
+const failCause = failCause$2;
 /**
  * Creates an effect that terminates a fiber with a `RuntimeException`
  * containing the specified message.
@@ -16720,7 +16381,7 @@ const promise = promise$1;
  * @since 2.0.0
  * @category Creating Effects
  */
-const succeed = succeed$4;
+const succeed = succeed$2;
 /**
  * Delays the creation of an `Effect` until it is actually needed.
  *
@@ -16858,7 +16519,7 @@ const suspend = suspend$1;
  * @category Creating Effects
  */
 const sync = sync$1;
-const _void = void_$2;
+const _void = void_$1;
 /**
  * Handles all errors in an effect by providing a fallback effect.
  *
@@ -17108,7 +16769,7 @@ const tryPromise = tryPromise$1;
  * @since 2.0.0
  * @category Interruption
  */
-const interrupt = interrupt$2;
+const interrupt = interrupt$1;
 /**
  * Marks an effect as interruptible.
  *
@@ -17220,7 +16881,7 @@ const asVoid = asVoid$1;
  * @since 2.0.0
  * @category Mapping
  */
-const map = map$3;
+const map = map$2;
 /**
  * Transforms or modifies the error produced by an effect without affecting its
  * success value.
@@ -18741,6 +18402,84 @@ const runFork = unsafeForkEffect;
  * @category Running Effects
  */
 const runPromise = unsafeRunPromiseEffect;
+/**
+ * Executes an effect synchronously, running it immediately and returning the
+ * result.
+ *
+ * **Details**
+ *
+ * This function evaluates the provided effect synchronously, returning its
+ * result directly. It is ideal for effects that do not fail or include
+ * asynchronous operations. If the effect does fail or involves async tasks, it
+ * will throw an error. Execution stops at the point of failure or asynchronous
+ * operation, making it unsuitable for effects that require asynchronous
+ * handling.
+ *
+ * **Important**: Attempting to run effects that involve asynchronous operations
+ * or failures will result in exceptions being thrown, so use this function with
+ * care for purely synchronous and error-free effects.
+ *
+ * **When to Use**
+ *
+ * Use this function when:
+ * - You are sure that the effect will not fail or involve asynchronous
+ *   operations.
+ * - You need a direct, synchronous result from the effect.
+ * - You are working within a context where asynchronous effects are not
+ *   allowed.
+ *
+ * Avoid using this function for effects that can fail or require asynchronous
+ * handling. For such cases, consider using {@link runPromise} or
+ * {@link runSyncExit}.
+ *
+ * **Example** (Synchronous Logging)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.sync(() => {
+ *   console.log("Hello, World!")
+ *   return 1
+ * })
+ *
+ * const result = Effect.runSync(program)
+ * // Output: Hello, World!
+ *
+ * console.log(result)
+ * // Output: 1
+ * ```
+ *
+ * **Example** (Incorrect Usage with Failing or Async Effects)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * try {
+ *   // Attempt to run an effect that fails
+ *   Effect.runSync(Effect.fail("my error"))
+ * } catch (e) {
+ *   console.error(e)
+ * }
+ * // Output:
+ * // (FiberFailure) Error: my error
+ *
+ * try {
+ *   // Attempt to run an effect that involves async work
+ *   Effect.runSync(Effect.promise(() => Promise.resolve(1)))
+ * } catch (e) {
+ *   console.error(e)
+ * }
+ * // Output:
+ * // (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work
+ * ```
+ *
+ * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
+ * throwing an error.
+ *
+ * @since 2.0.0
+ * @category Running Effects
+ */
+const runSync = unsafeRunSyncEffect;
 /**
  * Combines two effects into a single effect, producing a tuple of their
  * results.
@@ -18963,26 +18702,22 @@ const zipRight = zipRightOptions;
 const zipWith = zipWithOptions;
 exports.Class = Class;
-exports.EmptyMutableQueue = EmptyMutableQueue;
+exports.NodeInspectSymbol = NodeInspectSymbol;
 exports.YieldableError = YieldableError;
-exports._await = _await$1;
-exports._await$1 = _await;
+exports._await = _await;
 exports._void = _void;
 exports.acquireUseRelease = acquireUseRelease;
 exports.addFinalizer = addFinalizer;
 exports.addFinalizerExit = addFinalizerExit;
 exports.all = all$1;
-exports.all$1 = all$2;
-exports.all$2 = all;
-exports.append = append$1;
+exports.all$1 = all;
+exports.append = append;
 exports.appendAll = appendAll$1;
 exports.as = as;
 exports.asVoid = asVoid$1;
 exports.asVoid$1 = asVoid;
 exports.async = async;
-exports.bounded = bounded;
 exports.cached = cached;
-exports.capacity = capacity;
 exports.catchAll = catchAll;
 exports.catchAll$1 = catchAll$1;
 exports.catchAllCause = catchAllCause;
@@ -18996,30 +18731,41 @@ exports.constVoid = constVoid;
 exports.context = context;
 exports.decode = decode;
 exports.deferredAwait = deferredAwait;
+exports.deferredDone = deferredDone;
+exports.deferredFailCause = deferredFailCause;
+exports.deferredInterrupt = deferredInterrupt;
 exports.deferredInterruptWith = deferredInterruptWith;
+exports.deferredIsDone = deferredIsDone;
 exports.deferredMake = deferredMake;
 exports.deferredSucceed = deferredSucceed;
 exports.deferredUnsafeDone = deferredUnsafeDone;
 exports.deferredUnsafeMake = deferredUnsafeMake;
-exports.die = die$2;
-exports.die$1 = die;
+exports.die = die$1;
 exports.dieMessage = dieMessage;
-exports.done = done$4;
 exports.dual = dual;
-exports.empty = empty$8;
-exports.empty$1 = empty$m;
-exports.empty$2 = empty$j;
+exports.empty = empty$7;
+exports.empty$1 = empty$l;
+exports.empty$2 = empty$i;
 exports.ensuring = ensuring;
 exports.equals = equals$1;
 exports.exit = exit$1;
 exports.exit$1 = exit;
+exports.exitCollectAll = exitCollectAll;
+exports.exitDie = exitDie$1;
+exports.exitFail = exitFail;
+exports.exitFailCause = exitFailCause$1;
+exports.exitIsFailure = exitIsFailure;
+exports.exitIsSuccess = exitIsSuccess;
+exports.exitMap = exitMap;
+exports.exitMatch = exitMatch;
+exports.exitSucceed = exitSucceed$1;
+exports.exitVoid = exitVoid$1;
+exports.exitZip = exitZip;
+exports.exitZipRight = exitZipRight;
 exports.extend = extend;
-exports.fail = fail$3;
-exports.fail$1 = fail$1;
-exports.fail$2 = fail;
-exports.failCause = failCause$2;
-exports.failCause$1 = failCause;
-exports.failCause$2 = failCause$3;
+exports.fail = fail$2;
+exports.fail$1 = fail;
+exports.failCause = failCause;
 exports.failureOrCause = failureOrCause;
 exports.fiberId = fiberId;
 exports.fiberIdWith = fiberIdWith;
@@ -19035,6 +18781,7 @@ exports.forever = forever;
 exports.fork = fork;
 exports.forkDaemon = forkDaemon;
 exports.forkIn = forkIn;
+exports.format = format$2;
 exports.fromIterable = fromIterable$6;
 exports.fromIterable$1 = fromIterable$5;
 exports.gen = gen;
@@ -19053,60 +18800,47 @@ exports.identity = identity;
 exports.ignore = ignore;
 exports.infinity = infinity;
 exports.inheritAll = inheritAll;
-exports.interrupt = interrupt$1;
-exports.interrupt$1 = interrupt$3;
-exports.interrupt$2 = interrupt$2;
-exports.interrupt$3 = interrupt;
+exports.interrupt = interrupt$2;
+exports.interrupt$1 = interrupt$1;
+exports.interrupt$2 = interrupt;
 exports.interruptAsFiber = interruptAsFiber;
 exports.interruptFiber = interruptFiber;
 exports.interruptible = interruptible;
 exports.interruptors = interruptors;
 exports.intoDeferred = intoDeferred;
 exports.isDieType = isDieType;
-exports.isDone = isDone$4;
 exports.isEffect = isEffect;
-exports.isEmpty = isEmpty$7;
-exports.isEmpty$1 = isEmpty$2;
-exports.isFailure = isFailure;
+exports.isEmpty = isEmpty$5;
 exports.isInterrupted = isInterrupted;
 exports.isInterruptedOnly = isInterruptedOnly;
 exports.isRight = isRight;
 exports.isSome = isSome;
-exports.isSuccess = isSuccess;
 exports.join = join;
 exports.left = left;
-exports.length = length;
 exports.logError = logError;
 exports.logWarning = logWarning;
-exports.make = make$k;
+exports.make = make$i;
 exports.make$1 = make$a;
-exports.make$2 = make$g;
-exports.make$3 = make$1;
+exports.make$2 = make$1;
 exports.makeSemaphore = makeSemaphore;
-exports.map = map$3;
-exports.map$1 = map$4;
+exports.map = map$2;
+exports.map$1 = map$3;
 exports.map$2 = map;
-exports.map$3 = map$2;
-exports.map$4 = map$7;
+exports.map$3 = map$6;
 exports.mapError = mapError;
-exports.match = match$6;
-exports.match$1 = match$7;
-exports.match$2 = match$3;
-exports.match$3 = match;
+exports.match = match$5;
+exports.match$1 = match$6;
+exports.match$2 = match;
 exports.matchCause = matchCause;
 exports.matchCauseEffect = matchCauseEffect;
 exports.merge = merge$3;
 exports.modify = modify;
 exports.none = none$4;
 exports.of = of$1;
-exports.offer = offer;
-exports.offerAll = offerAll;
 exports.onInterrupt = onInterrupt;
 exports.orElseSucceed = orElseSucceed;
 exports.pipe = pipe;
 exports.pipeArguments = pipeArguments;
-exports.poll = poll;
-exports.pollUpTo = pollUpTo;
 exports.prepend = prepend$1;
 exports.promise = promise;
 exports.provide = provide;
@@ -19115,11 +18849,13 @@ exports.race = race;
 exports.raceFirst = raceFirst;
 exports.raceWith = raceWith;
 exports.reduce = reduce$6;
-exports.remove = remove$1;
+exports.remove = remove;
 exports.repeat = repeat;
+exports.reverse = reverse$1;
 exports.right = right;
 exports.runFork = runFork;
 exports.runPromise = runPromise;
+exports.runSync = runSync;
 exports.runtime = runtime;
 exports.scope = scope;
 exports.scopedWith = scopedWith;
@@ -19133,9 +18869,7 @@ exports.splitAt = splitAt$1;
 exports.splitWhere = splitWhere;
 exports.struct = struct;
 exports.succeed = succeed;
-exports.succeed$1 = succeed$4;
-exports.succeed$2 = succeed$2;
-exports.succeed$3 = succeed$3;
+exports.succeed$1 = succeed$2;
 exports.suspend = suspend$1;
 exports.suspend$1 = suspend;
 exports.symbol = symbol$1;
@@ -19145,28 +18879,24 @@ exports.sync$1 = sync;
 exports.tap = tap;
 exports.tapError = tapError;
 exports.tapErrorCause = tapErrorCause;
+exports.toJSON = toJSON;
 exports.toMillis = toMillis;
 exports.tryPromise = tryPromise;
 exports.try_ = try_;
-exports.unbounded = unbounded;
 exports.uninterruptible = uninterruptible$1;
 exports.uninterruptible$1 = uninterruptible;
 exports.uninterruptibleMask = uninterruptibleMask;
 exports.unsafeFromArray = unsafeFromArray;
 exports.unsafeGet = unsafeGet;
-exports.unsafeMake = unsafeMake$4;
 exports.update = update$1;
-exports.void_ = void_$2;
-exports.void_$1 = void_$1;
+exports.void_ = void_$1;
 exports.when = when$1;
 exports.when$1 = when;
 exports.whenEffect = whenEffect;
 exports.withFiberRuntime = withFiberRuntime$1;
 exports.withFiberRuntime$1 = withFiberRuntime;
 exports.zip = zip;
-exports.zip$1 = zip$1;
 exports.zipLeft = zipLeft;
-exports.zipRight = zipRight$2;
-exports.zipRight$1 = zipRight$1;
-exports.zipRight$2 = zipRight;
+exports.zipRight = zipRight$1;
+exports.zipRight$1 = zipRight;
 exports.zipWith = zipWith;