@lmvz-ds/components 0.18.2 → 0.20.0

package/esm/{index-7Ru1khgk.js → index-Dh_9sN0q.js}

@@ -1,4 +1,4 @@
-import { d as dual, h as hasProperty, e as isNumber, f as isBigInt, j as isString, p as pipeArguments, N as NodeInspectSymbol, s as symbol, k as symbol$1, n as cached, o as structure, q as none$3, u as combine$6, v as unsafeMake$6, w as threadName$1, x as combineAll$1, y as empty$f, z as reduce$2, A as set$3, B as get$5, C as isEmpty$5, D as modifyAt$1, E as map$8, F as keys$1, G as fromIterable$2, H as string, I as format$1, J as array, K as fromIterable$3, L as mapInput$1, M as toJSON, O as getEquivalence$1, P as equals$1, S as StructuralPrototype, Q as of$2, R as isNonEmpty$2, U as headNonEmpty, V as tailNonEmpty, W as prepend$1, X as makeContext, Y as reduce$3, Z as has$1, _ as remove$1, $ as add, a0 as drop, a1 as isNonEmptyArray, a2 as of$3, a3 as headNonEmpty$1, a4 as tailNonEmpty$1, i as identity, a5 as constant, m as match$6, a6 as appendAll$1, a7 as orElseSome, a8 as map$9, a9 as append$1, aa as empty$g, ab as OP_COMMIT, ac as effectVariance, ad as random, ae as YieldWrap, af as OP_ON_SUCCESS, ag as OP_ON_FAILURE, ah as isObject, ai as spanSymbol, aj as fail$5, ak as failureOrCause$1, al as getBugErrorMessage, am as OP_SYNC, an as OP_WITH_RUNTIME, ao as OP_FAILURE, ap as pipe, aq as combine$7, ar as hash, as as OP_ON_SUCCESS_AND_FAILURE, at as OP_SUCCESS, au as internalCall, av as some, aw as none$4, ax as make$q, ay as CommitPrototype, az as isInterruptedOnly$1, aA as interruptors$1, aB as OP_UPDATE_RUNTIME_FLAGS, aC as defects, aD as electFailures, aE as failures, aF as unsafeHead, aG as interrupt$4, aH as get$6, aI as set$4, aJ as globalValue, aK as getOrElse, aL as OP_ASYNC, aM as fromIterable$4, aN as toReadonlyArray, aO as reverse$1, aP as reduce$4, aQ as allocate, aR as sequential$2, aS as isPromiseLike, aT as OP_WHILE, aU as merge$1, r as right, l as left, aV as StructuralCommitPrototype, aW as empty$h, aX as die$3, aY as OP_REVERT_FLAGS, aZ as pretty, a_ as isSome, a$ as OP_YIELD$1, b0 as OP_ITERATOR, b1 as empty$i, b2 as empty$j, b3 as parallel$2, b4 as isEqual, b5 as GenericTag, b6 as constFalse, b7 as join$2, b8 as contains, b9 as head, ba as prepend$2, bb as map$a, bc as isLeft, a as isRight, bd as zip$4, be as append$2, bf as flatten$5, bg as last, bh as unfold$1, bi as merge$2, bj as sort, bk as flatMap$4, bl as unsafeGet, bm as fromIterable$5, bn as PCGRandom, bo as Reference, bp as add$1, bq as isNonEmptyReadonlyArray, br as Class, bs as constVoid, bt as get$7, bu as unsafeFromArray, bv as makeBy, bw as dedupe, bx as appendAll$2, by as fromNullable, bz as union, bA as lastNonEmpty, bB as span, bC as isNone, bD as getOrUndefined, bE as isTagged, bF as difference, bG as empty$k, bH as union$1, bI as make$r, bJ as make$s, bK as isIterable, bL as compareAndSet, bM as isEmpty$6, bN as size$2, bO as withRedactableContext, bP as OP_TAG, bQ as unsafeGet$1, bR as runFork$1, bS as provideContext$1, bT as stripFailures, bU as getCurrentVersion, bV as toStringUnknown, bW as yieldWrapGet, bX as getOption, bY as makeLogger, bZ as stringLogger, b_ as isInterrupted$1, b$ as flipCauseOption$1, c0 as map$b, c1 as isDieType$1, c2 as head$1, c3 as prettyErrors, c4 as isContext, c5 as mergeAll$2, c6 as find, c7 as splitAt, c8 as isEmpty$7, c9 as filter, ca as match$7, cb as unsafeGet$2, cc as reduce$5, cd as map$c, ce as splitWhere, cf as filterMap } from './logger-fiRXhuXK.js';
+import { d as dual, h as hasProperty, e as isNumber, f as isBigInt, j as isString, p as pipeArguments, N as NodeInspectSymbol, s as symbol, k as symbol$1, n as cached, o as structure, q as of$1, u as reduce, v as empty$9, w as appendAll, x as isNil, y as reverse, z as empty$a, A as cons, B as reduce$1, C as set$2, m as match$6, D as get$4, E as appendAll$1, F as isEmpty$4, G as equals$1, H as modifyAt, I as orElseSome, J as map$6, K as append$1, L as of$2, M as map$7, O as keys, P as empty$b, Q as deferredMake, R as deferredAwait, S as deferredSucceed, U as deferredFailCause, V as deferredIsDone, W as exitIsFailure, X as exitIsSuccess, Y as exitMatch, Z as exitFailCause, _ as exitSucceed, $ as exitFail, a0 as exitZipRight, a1 as exitCollectAll, a2 as exitVoid, a3 as exitDie, a4 as exitMap, a5 as exitZip, a6 as isEqual, a7 as some, a8 as none$1, a9 as isSome, aa as toJSON, ab as format$1, ac as prepend, ad as reverse$1, ae as GenericTag, af as sync$2, ag as succeed$4, ah as async_, ai as constFalse, aj as void_$2, ak as asVoid$1, al as pipe, am as join$2, an as isCons, ao as contains, ap as head, aq as tailNonEmpty, l as left, ar as prepend$1, as as map$8, r as right, at as flatMap$3, au as fail$4, av as suspend$3, aw as either, ax as isLeft, a as isRight, ay as zip$3, az as forEachSequential, aA as zip$4, aB as map$9, aC as of$3, aD as fromIterable$1, aE as fromIterable$2, aF as append$2, aG as flatten$4, aH as empty$c, aI as last, aJ as getOrElse, aK as mapError$1, aL as catchAll$1, aM as unfold$1, aN as merge$1, aO as mapBoth, aP as sort, aQ as flatMap$4, aR as unsafeGet, aS as fromIterable$3, aT as hash, aU as PCGRandom, aV as forEachSequentialDiscard, aW as as$1, aX as fromIterable$4, aY as Reference, aZ as globalValue, a_ as fiberRefUnsafeMakeContext, a$ as add, b0 as empty$d, b1 as withFiberRuntime$1, b2 as headNonEmpty, b3 as isNonEmptyReadonlyArray, b4 as logLevelWarning, b5 as logLevelNone, b6 as logLevelTrace, b7 as logLevelInfo, b8 as logLevelFatal, b9 as logLevelError, ba as logLevelDebug, bb as logLevelAll, bc as make$n, bd as Class, be as get$5, bf as set$3, bg as string, bh as matchEffect, bi as matchCauseEffect$1, bj as zipRight$3, bk as failCause$6, bl as constVoid, bm as contextWithEffect, bn as provideContext, bo as get$6, bp as failCauseSync$1, bq as yieldNow$1, br as combine$2, bs as fiberRefUnsafeMake, bt as currentMaxOpsBeforeYield, bu as currentSchedulingPriority, bv as fiberRefGetWith, bw as currentConcurrency, bx as none$2, by as zipLeft$1, bz as flatten$5, bA as unsafeFromArray, bB as makeBy, bC as dedupe, bD as appendAll$2, bE as array, bF as fromNullable, bG as getEquivalence, bH as union, bI as allocate, bJ as lastNonEmpty, bK as span, bL as isNone, bM as getOrUndefined, bN as tap$1, bO as currentMetricLabels, bP as deferredUnsafeDone, bQ as isTagged, bR as make$o, bS as reduce$2, bT as difference, bU as empty$e, bV as union$1, bW as make$p, bX as isNonEmpty$2, bY as headNonEmpty$1, bZ as tailNonEmpty$1, b_ as onExit, b$ as uninterruptibleMask$1, c0 as transplant, c1 as CloseableScopeTypeId, c2 as ScopeTypeId, c3 as exitAsVoid, c4 as exit$1, c5 as sequential$2, c6 as isEffect$1, c7 as mapInputContext, c8 as merge$2, c9 as make$q, ca as OP_FAILURE, cb as OP_SUCCESS, i as identity, cc as combine$3, cd as currentRequestBatching, ce as isIterable, cf as unsafeMake$5, cg as currentContext, ch as currentForkScopeOverride, ci as compareAndSet, cj as runtimeMetrics, ck as currentInterruptedCause, cl as deferredUnsafeMake, cm as fiberRefUnsafeMakeRuntimeFlags, cn as exclude, co as WindDown, cp as Interruption, cq as diff$3, cr as updateRuntimeFlags, cs as interrupt$3, ct as fiberRefUnsafeMakePatch, cu as isEmpty$5, cv as whileLoop, cw as currentUnhandledErrorLogLevel, cx as isInterruptedOnly$1, cy as currentLogLevel, cz as currentLogSpan, cA as currentLogAnnotations, cB as size$2, cC as withRedactableContext, cD as interruptible$1, cE as OP_YIELD$1, cF as cooperativeYielding, cG as OP_ASYNC, cH as enable, cI as patch$4, cJ as die$2, cK as OP_ON_FAILURE, cL as OP_ON_SUCCESS, cM as OP_WHILE, cN as OP_ITERATOR, cO as OP_TAG, cP as unsafeGet$1, cQ as NoSuchElementException, cR as unsafeAsync, cS as runFork$1, cT as provideContext$1, cU as die$3, cV as OP_SYNC, cW as internalCall, cX as OP_REVERT_FLAGS, cY as stripFailures, cZ as OP_ON_SUCCESS_AND_FAILURE, c_ as OP_WITH_RUNTIME, c$ as blocked, d0 as runRequestBlock, d1 as OP_UPDATE_RUNTIME_FLAGS, d2 as RevertFlags, d3 as OP_COMMIT, d4 as OpSupervision, d5 as EffectTypeId, d6 as currentVersionMismatchErrorLogLevel, d7 as getCurrentVersion, d8 as empty$f, d9 as dieMessage$1, da as toStringUnknown, db as isInterruptedException, dc as fiberRefUnsafeMakeHashSet, dd as yieldWrapGet, de as exitIsExit, df as step$1, dg as uninterruptible$1, dh as getOption, di as scopeFork, dj as none$3, dk as makeLogger, dl as threadName, dm as pretty, dn as fiberIdWith$1, dp as exitMatchEffect, dq as interruptAsFiber, dr as parallel$2, ds as toReadonlyArray, dt as fiberRefLocally, du as stringLogger, dv as interruptible$2, dw as isInterrupted$1, dx as interruptFiber, dy as exitInterrupt, dz as fail$5, dA as failureOrCause$1, dB as flipCauseOption$1, dC as map$a, dD as isDieType$1, dE as interruptors$1, dF as head$1, dG as scopeClose, dH as scopeAddFinalizerExit, dI as scopeAddFinalizer, dJ as asyncInterrupt, dK as make$r, dL as RuntimeMetrics, dM as CooperativeYielding, dN as prettyErrors, dO as isContext, dP as provideSomeContext, dQ as whenEffect, dR as mergeAll$2, dS as gen$1, dT as zipWith$1, dU as fnUntraced, dV as catchAllCause$1, dW as find, dX as orDie, dY as failSync, dZ as interrupt$4, d_ as matchCause$1, d$ as acquireUseRelease$1, e0 as intoDeferred$1, e1 as splitAt, e2 as isEmpty$6, e3 as onInterrupt, e4 as filter, e5 as deferredInterruptWith, e6 as fiberId, e7 as match$7, e8 as combineAll, e9 as unsafeGet$2, ea as reduce$3, eb as map$b, ec as splitWhere, ed as filterMap } from './logger-CGmJG63p.js';
 
 /**
  * This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
@@ -22,17 +22,17 @@ import { d as dual, h as hasProperty, e as isNumber, f as isBigInt, j as isStrin
  * @category constructors
  * @since 2.0.0
  */
-const make$p = compare => (self, that) => self === that ? 0 : compare(self, that);
+const make$m = compare => (self, that) => self === that ? 0 : compare(self, that);
 /**
  * @category instances
  * @since 2.0.0
  */
-const number = /*#__PURE__*/make$p((self, that) => self < that ? -1 : 1);
+const number = /*#__PURE__*/make$m((self, that) => self < that ? -1 : 1);
 /**
  * @category mapping
  * @since 2.0.0
  */
-const mapInput = /*#__PURE__*/dual(2, (self, f) => make$p((b1, b2) => self(f(b1), f(b2))));
+const mapInput = /*#__PURE__*/dual(2, (self, f) => make$m((b1, b2) => self(f(b1), f(b2))));
 /**
  * Test whether one value is _strictly greater than_ another.
  *
@@ -166,7 +166,7 @@ const escape = string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
 /**
  * @since 2.0.0
  */
-const TypeId$7 = /*#__PURE__*/Symbol.for("effect/Duration");
+const TypeId$6 = /*#__PURE__*/Symbol.for("effect/Duration");
 const bigint0$1 = /*#__PURE__*/BigInt(0);
 const bigint24 = /*#__PURE__*/BigInt(24);
 const bigint60 = /*#__PURE__*/BigInt(60);
@@ -235,7 +235,7 @@ const infinityValue = {
   _tag: "Infinity"
 };
 const DurationProto = {
-  [TypeId$7]: TypeId$7,
+  [TypeId$6]: TypeId$6,
   [symbol$1]() {
     return cached(this, structure(this.value));
   },
@@ -273,7 +273,7 @@ const DurationProto = {
     return pipeArguments(this, arguments);
   }
 };
-const make$o = input => {
+const make$l = input => {
   const duration = Object.create(DurationProto);
   if (isNumber(input)) {
     if (isNaN(input) || input <= 0) {
@@ -305,7 +305,7 @@ const make$o = input => {
  * @since 2.0.0
  * @category guards
  */
-const isDuration = u => hasProperty(u, TypeId$7);
+const isDuration = u => hasProperty(u, TypeId$6);
 /**
  * @since 3.5.0
  * @category guards
@@ -330,52 +330,52 @@ const isZero = self => {
  * @since 2.0.0
  * @category constructors
  */
-const zero = /*#__PURE__*/make$o(0);
+const zero = /*#__PURE__*/make$l(0);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const infinity = /*#__PURE__*/make$o(Infinity);
+const infinity = /*#__PURE__*/make$l(Infinity);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const nanos = nanos => make$o(nanos);
+const nanos = nanos => make$l(nanos);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const micros = micros => make$o(micros * bigint1e3);
+const micros = micros => make$l(micros * bigint1e3);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const millis = millis => make$o(millis);
+const millis = millis => make$l(millis);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const seconds = seconds => make$o(seconds * 1000);
+const seconds = seconds => make$l(seconds * 1000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const minutes = minutes => make$o(minutes * 60_000);
+const minutes = minutes => make$l(minutes * 60_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const hours = hours => make$o(hours * 3_600_000);
+const hours = hours => make$l(hours * 3_600_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const days = days => make$o(days * 86_400_000);
+const days = days => make$l(days * 86_400_000);
 /**
  * @since 2.0.0
  * @category constructors
  */
-const weeks = weeks => make$o(weeks * 604_800_000);
+const weeks = weeks => make$l(weeks * 604_800_000);
 /**
  * @since 2.0.0
  * @category getters
@@ -556,2292 +556,203 @@ const format = self => {
 };
 
 /**
- * @since 2.0.0
- * @category constructors
- */
-const none$2 = none$3;
-/**
- * Combine two `FiberId`s.
- *
- * @since 2.0.0
- * @category constructors
- */
-const combine$5 = combine$6;
-/**
- * Combines a set of `FiberId`s into a single `FiberId`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const combineAll = combineAll$1;
-/**
- * Creates a string representing the name of the current thread of execution
- * represented by the specified `FiberId`.
- *
- * @since 2.0.0
- * @category destructors
- */
-const threadName = threadName$1;
-/**
- * Unsafely creates a new `FiberId`.
- *
- * @since 2.0.0
- * @category unsafe
- */
-const unsafeMake$5 = unsafeMake$6;
-
-/**
- * @since 2.0.0
- */
-/**
- * Creates a new `HashMap`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const empty$e = empty$f;
-/**
- * Creates a new `HashMap` from an iterable collection of key/value pairs.
- *
- * @since 2.0.0
- * @category constructors
- */
-const fromIterable$1 = fromIterable$2;
-/**
- * Checks if the `HashMap` contains any entries.
- *
- * @since 2.0.0
- * @category elements
- */
-const isEmpty$4 = isEmpty$5;
-/**
- * Safely lookup the value for the specified key in the `HashMap` using the
- * internal hashing function.
- *
- * @since 2.0.0
- * @category elements
- */
-const get$4 = get$5;
-/**
- * Sets the specified key to the specified value using the internal hashing
- * function.
- *
- * @since 2.0.0
- */
-const set$2 = set$3;
-/**
- * Returns an `IterableIterator` of the keys within the `HashMap`.
- *
- * @since 2.0.0
- * @category getters
- */
-const keys = keys$1;
-/**
- * Set or remove the specified key in the `HashMap` using the specified
- * update function. The value of the specified key will be computed using the
- * provided hash.
- *
- * The update function will be invoked with the current value of the key if it
- * exists, or `None` if no such value exists.
- *
- * @since 2.0.0
- */
-const modifyAt = modifyAt$1;
-/**
- * Maps over the entries of the `HashMap` using the specified function.
- *
- * @since 2.0.0
- * @category mapping
- */
-const map$7 = map$8;
-/**
- * Reduces the specified state over the entries of the `HashMap`.
- *
- * @since 2.0.0
- * @category folding
- */
-const reduce$1 = reduce$2;
-
-/**
- * A data type for immutable linked lists representing ordered collections of elements of type `A`.
- *
- * This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
- *
- * **Performance**
- *
- * - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`.
- * - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in parallel.
  *
- * @since 2.0.0
+ * @internal
  */
+const par = (self, that) => ({
+  _tag: "Par",
+  left: self,
+  right: that
+});
 /**
- * This file is ported from
- *
- * Scala (https://www.scala-lang.org)
- *
- * Copyright EPFL and Lightbend, Inc.
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in sequence.
  *
- * Licensed under Apache License 2.0
- * (http://www.apache.org/licenses/LICENSE-2.0).
- */
-/**
- * @since 2.0.0
- * @category symbol
+ * @internal
  */
-const TypeId$6 = /*#__PURE__*/Symbol.for("effect/List");
+const seq = (self, that) => ({
+  _tag: "Seq",
+  left: self,
+  right: that
+});
 /**
- * Converts the specified `List` to an `Array`.
+ * Flattens a collection of blocked requests into a collection of pipelined
+ * and batched requests that can be submitted for execution.
  *
- * @category conversions
- * @since 2.0.0
+ * @internal
  */
-const toArray = self => fromIterable$3(self);
+const flatten$3 = self => {
+  let current = of$1(self);
+  let updated = empty$9();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = reduce(current, [parallelCollectionEmpty(), empty$9()], ([parallel, sequential], blockedRequest) => {
+      const [par, seq] = step(blockedRequest);
+      return [parallelCollectionCombine(parallel, par), appendAll(sequential, seq)];
+    });
+    updated = merge(updated, parallel);
+    if (isNil(sequential)) {
+      return reverse(updated);
+    }
+    current = sequential;
+  }
+  throw new Error("BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/effect/issues");
+};
 /**
- * @category equivalence
- * @since 2.0.0
+ * Takes one step in evaluating a collection of blocked requests, returning a
+ * collection of blocked requests that can be performed in parallel and a list
+ * of blocked requests that must be performed sequentially after those
+ * requests.
  */
-const getEquivalence = isEquivalent => mapInput$1(getEquivalence$1(isEquivalent), toArray);
-const _equivalence = /*#__PURE__*/getEquivalence(equals$1);
-const ConsProto = {
-  [TypeId$6]: TypeId$6,
-  _tag: "Cons",
-  toString() {
-    return format$1(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "List",
-      _tag: "Cons",
-      values: toArray(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol](that) {
-    return isList(that) && this._tag === that._tag && _equivalence(this, that);
-  },
-  [symbol$1]() {
-    return cached(this, array(toArray(this)));
-  },
-  [Symbol.iterator]() {
-    let done = false;
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let self = this;
-    return {
-      next() {
-        if (done) {
-          return this.return();
+const step = requests => {
+  let current = requests;
+  let parallel = parallelCollectionEmpty();
+  let stack = empty$9();
+  let sequential = empty$9();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    switch (current._tag) {
+      case "Empty":
+        {
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
         }
-        if (self._tag === "Nil") {
-          done = true;
-          return this.return();
+      case "Par":
+        {
+          stack = cons(current.right, stack);
+          current = current.left;
+          break;
         }
-        const value = self.head;
-        self = self.tail;
-        return {
-          done,
-          value
-        };
-      },
-      return(value) {
-        if (!done) {
-          done = true;
+      case "Seq":
+        {
+          const left = current.left;
+          const right = current.right;
+          switch (left._tag) {
+            case "Empty":
+              {
+                current = right;
+                break;
+              }
+            case "Par":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = par(seq(l, right), seq(r, right));
+                break;
+              }
+            case "Seq":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = seq(l, seq(r, right));
+                break;
+              }
+            case "Single":
+              {
+                current = left;
+                sequential = cons(right, sequential);
+                break;
+              }
+          }
+          break;
         }
-        return {
-          done: true,
-          value
-        };
-      }
-    };
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const makeCons = (head, tail) => {
-  const cons = Object.create(ConsProto);
-  cons.head = head;
-  cons.tail = tail;
-  return cons;
-};
-const NilHash = /*#__PURE__*/string("Nil");
-const NilProto = {
-  [TypeId$6]: TypeId$6,
-  _tag: "Nil",
-  toString() {
-    return format$1(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "List",
-      _tag: "Nil"
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  [symbol$1]() {
-    return NilHash;
-  },
-  [symbol](that) {
-    return isList(that) && this._tag === that._tag;
-  },
-  [Symbol.iterator]() {
-    return {
-      next() {
-        return {
-          done: true,
-          value: undefined
-        };
-      }
-    };
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const _Nil = /*#__PURE__*/Object.create(NilProto);
-/**
- * Returns `true` if the specified value is a `List`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isList = u => hasProperty(u, TypeId$6);
-/**
- * Returns `true` if the specified value is a `List.Nil<A>`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isNil = self => self._tag === "Nil";
-/**
- * Returns `true` if the specified value is a `List.Cons<A>`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-const isCons = self => self._tag === "Cons";
-/**
- * Constructs a new empty `List<A>`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const nil = () => _Nil;
-/**
- * Constructs a new `List.Cons<A>` from the specified `head` and `tail` values.
- *
- * @since 2.0.0
- * @category constructors
- */
-const cons = (head, tail) => makeCons(head, tail);
-/**
- * Constructs a new empty `List<A>`.
- *
- * Alias of {@link nil}.
- *
- * @since 2.0.0
- * @category constructors
- */
-const empty$d = nil;
-/**
- * Constructs a new `List<A>` from the specified value.
- *
- * @since 2.0.0
- * @category constructors
- */
-const of$1 = value => makeCons(value, _Nil);
-/**
- * Concatenates two lists, combining their elements.
- * If either list is non-empty, the result is also a non-empty list.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { List } from "effect"
- *
- * assert.deepStrictEqual(
- *   List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray),
- *   [1, 2, "a", "b"]
- * )
- * ```
- *
- * @category concatenating
- * @since 2.0.0
- */
-const appendAll = /*#__PURE__*/dual(2, (self, that) => prependAll(that, self));
-/**
- * Prepends the specified element to the beginning of the list.
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prepend = /*#__PURE__*/dual(2, (self, element) => cons(element, self));
-/**
- * Prepends the specified prefix list to the beginning of the specified list.
- * If either list is non-empty, the result is also a non-empty list.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { List } from "effect"
- *
- * assert.deepStrictEqual(
- *   List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray),
- *   ["a", "b", 1, 2]
- * )
- * ```
- *
- * @category concatenating
- * @since 2.0.0
- */
-const prependAll = /*#__PURE__*/dual(2, (self, prefix) => {
-  if (isNil(self)) {
-    return prefix;
-  } else if (isNil(prefix)) {
-    return self;
-  } else {
-    const result = makeCons(prefix.head, self);
-    let curr = result;
-    let that = prefix.tail;
-    while (!isNil(that)) {
-      const temp = makeCons(that.head, self);
-      curr.tail = temp;
-      curr = temp;
-      that = that.tail;
-    }
-    return result;
-  }
-});
-/**
- * Folds over the elements of the list using the specified function, using the
- * specified initial value.
- *
- * @since 2.0.0
- * @category folding
- */
-const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {
-  let acc = zero;
-  let these = self;
-  while (!isNil(these)) {
-    acc = f(acc, these.head);
-    these = these.tail;
-  }
-  return acc;
-});
-/**
- * Returns a new list with the elements of the specified list in reverse order.
- *
- * @since 2.0.0
- * @category elements
- */
-const reverse = self => {
-  let result = empty$d();
-  let these = self;
-  while (!isNil(these)) {
-    result = prepend(result, these.head);
-    these = these.tail;
-  }
-  return result;
-};
-
-/** @internal */
-const Structural = /*#__PURE__*/function () {
-  function Structural(args) {
-    if (args) {
-      Object.assign(this, args);
-    }
-  }
-  Structural.prototype = StructuralPrototype;
-  return Structural;
-}();
-
-/** @internal */
-const ContextPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferContextPatch");
-function variance$2(a) {
-  return a;
-}
-/** @internal */
-const PatchProto$2 = {
-  ...Structural.prototype,
-  [ContextPatchTypeId]: {
-    _Value: variance$2,
-    _Patch: variance$2
-  }
-};
-const EmptyProto$2 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
-  _tag: "Empty"
-});
-const _empty$2 = /*#__PURE__*/Object.create(EmptyProto$2);
-/**
- * @internal
- */
-const empty$c = () => _empty$2;
-const AndThenProto$2 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
-  _tag: "AndThen"
-});
-const makeAndThen$2 = (first, second) => {
-  const o = Object.create(AndThenProto$2);
-  o.first = first;
-  o.second = second;
-  return o;
-};
-const AddServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
-  _tag: "AddService"
-});
-const makeAddService = (key, service) => {
-  const o = Object.create(AddServiceProto);
-  o.key = key;
-  o.service = service;
-  return o;
-};
-const RemoveServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
-  _tag: "RemoveService"
-});
-const makeRemoveService = key => {
-  const o = Object.create(RemoveServiceProto);
-  o.key = key;
-  return o;
-};
-const UpdateServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$2), {
-  _tag: "UpdateService"
-});
-const makeUpdateService = (key, update) => {
-  const o = Object.create(UpdateServiceProto);
-  o.key = key;
-  o.update = update;
-  return o;
-};
-/** @internal */
-const diff$6 = (oldValue, newValue) => {
-  const missingServices = new Map(oldValue.unsafeMap);
-  let patch = empty$c();
-  for (const [tag, newService] of newValue.unsafeMap.entries()) {
-    if (missingServices.has(tag)) {
-      const old = missingServices.get(tag);
-      missingServices.delete(tag);
-      if (!equals$1(old, newService)) {
-        patch = combine$4(makeUpdateService(tag, () => newService))(patch);
-      }
-    } else {
-      missingServices.delete(tag);
-      patch = combine$4(makeAddService(tag, newService))(patch);
-    }
-  }
-  for (const [tag] of missingServices.entries()) {
-    patch = combine$4(makeRemoveService(tag))(patch);
-  }
-  return patch;
-};
-/** @internal */
-const combine$4 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$2(self, that));
-/** @internal */
-const patch$7 = /*#__PURE__*/dual(2, (self, context) => {
-  if (self._tag === "Empty") {
-    return context;
-  }
-  let wasServiceUpdated = false;
-  let patches = of$2(self);
-  const updatedContext = new Map(context.unsafeMap);
-  while (isNonEmpty$2(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AddService":
-        {
-          updatedContext.set(head.key, head.service);
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend$1(prepend$1(tail, head.second), head.first);
-          break;
-        }
-      case "RemoveService":
-        {
-          updatedContext.delete(head.key);
-          patches = tail;
-          break;
-        }
-      case "UpdateService":
-        {
-          updatedContext.set(head.key, head.update(updatedContext.get(head.key)));
-          wasServiceUpdated = true;
-          patches = tail;
-          break;
-        }
-    }
-  }
-  if (!wasServiceUpdated) {
-    return makeContext(updatedContext);
-  }
-  const map = new Map();
-  for (const [tag] of context.unsafeMap) {
-    if (updatedContext.has(tag)) {
-      map.set(tag, updatedContext.get(tag));
-      updatedContext.delete(tag);
-    }
-  }
-  for (const [tag, s] of updatedContext) {
-    map.set(tag, s);
-  }
-  return makeContext(map);
-});
-
-/** @internal */
-const HashSetPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashSetPatch");
-function variance$1(a) {
-  return a;
-}
-/** @internal */
-const PatchProto$1 = {
-  ...Structural.prototype,
-  [HashSetPatchTypeId]: {
-    _Value: variance$1,
-    _Key: variance$1,
-    _Patch: variance$1
-  }
-};
-const EmptyProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
-  _tag: "Empty"
-});
-const _empty$1 = /*#__PURE__*/Object.create(EmptyProto$1);
-/** @internal */
-const empty$b = () => _empty$1;
-const AndThenProto$1 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
-  _tag: "AndThen"
-});
-/** @internal */
-const makeAndThen$1 = (first, second) => {
-  const o = Object.create(AndThenProto$1);
-  o.first = first;
-  o.second = second;
-  return o;
-};
-const AddProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
-  _tag: "Add"
-});
-/** @internal */
-const makeAdd = value => {
-  const o = Object.create(AddProto);
-  o.value = value;
-  return o;
-};
-const RemoveProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto$1), {
-  _tag: "Remove"
-});
-/** @internal */
-const makeRemove = value => {
-  const o = Object.create(RemoveProto);
-  o.value = value;
-  return o;
-};
-/** @internal */
-const diff$5 = (oldValue, newValue) => {
-  const [removed, patch] = reduce$3([oldValue, empty$b()], ([set, patch], value) => {
-    if (has$1(value)(set)) {
-      return [remove$1(value)(set), patch];
-    }
-    return [set, combine$3(makeAdd(value))(patch)];
-  })(newValue);
-  return reduce$3(patch, (patch, value) => combine$3(makeRemove(value))(patch))(removed);
-};
-/** @internal */
-const combine$3 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$1(self, that));
-/** @internal */
-const patch$6 = /*#__PURE__*/dual(2, (self, oldValue) => {
-  if (self._tag === "Empty") {
-    return oldValue;
-  }
-  let set = oldValue;
-  let patches = of$2(self);
-  while (isNonEmpty$2(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend$1(head.first)(prepend$1(head.second)(tail));
-          break;
-        }
-      case "Add":
-        {
-          set = add(head.value)(set);
-          patches = tail;
-          break;
-        }
-      case "Remove":
-        {
-          set = remove$1(head.value)(set);
-          patches = tail;
-        }
-    }
-  }
-  return set;
-});
-
-/** @internal */
-const ReadonlyArrayPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferReadonlyArrayPatch");
-function variance(a) {
-  return a;
-}
-const PatchProto = {
-  ...Structural.prototype,
-  [ReadonlyArrayPatchTypeId]: {
-    _Value: variance,
-    _Patch: variance
-  }
-};
-const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
-  _tag: "Empty"
-});
-const _empty = /*#__PURE__*/Object.create(EmptyProto);
-/**
- * @internal
- */
-const empty$a = () => _empty;
-const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
-  _tag: "AndThen"
-});
-const makeAndThen = (first, second) => {
-  const o = Object.create(AndThenProto);
-  o.first = first;
-  o.second = second;
-  return o;
-};
-const AppendProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
-  _tag: "Append"
-});
-const makeAppend = values => {
-  const o = Object.create(AppendProto);
-  o.values = values;
-  return o;
-};
-const SliceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
-  _tag: "Slice"
-});
-const makeSlice = (from, until) => {
-  const o = Object.create(SliceProto);
-  o.from = from;
-  o.until = until;
-  return o;
-};
-const UpdateProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
-  _tag: "Update"
-});
-const makeUpdate = (index, patch) => {
-  const o = Object.create(UpdateProto);
-  o.index = index;
-  o.patch = patch;
-  return o;
-};
-/** @internal */
-const diff$4 = options => {
-  let i = 0;
-  let patch = empty$a();
-  while (i < options.oldValue.length && i < options.newValue.length) {
-    const oldElement = options.oldValue[i];
-    const newElement = options.newValue[i];
-    const valuePatch = options.differ.diff(oldElement, newElement);
-    if (!equals$1(valuePatch, options.differ.empty)) {
-      patch = combine$2(patch, makeUpdate(i, valuePatch));
-    }
-    i = i + 1;
-  }
-  if (i < options.oldValue.length) {
-    patch = combine$2(patch, makeSlice(0, i));
-  }
-  if (i < options.newValue.length) {
-    patch = combine$2(patch, makeAppend(drop(i)(options.newValue)));
-  }
-  return patch;
-};
-/** @internal */
-const combine$2 = /*#__PURE__*/dual(2, (self, that) => makeAndThen(self, that));
-/** @internal */
-const patch$5 = /*#__PURE__*/dual(3, (self, oldValue, differ) => {
-  if (self._tag === "Empty") {
-    return oldValue;
-  }
-  let readonlyArray = oldValue.slice();
-  let patches = of$3(self);
-  while (isNonEmptyArray(patches)) {
-    const head = headNonEmpty$1(patches);
-    const tail = tailNonEmpty$1(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          tail.unshift(head.first, head.second);
-          patches = tail;
-          break;
-        }
-      case "Append":
-        {
-          for (const value of head.values) {
-            readonlyArray.push(value);
-          }
-          patches = tail;
-          break;
-        }
-      case "Slice":
-        {
-          readonlyArray = readonlyArray.slice(head.from, head.until);
-          patches = tail;
-          break;
-        }
-      case "Update":
-        {
-          readonlyArray[head.index] = differ.patch(head.patch, readonlyArray[head.index]);
-          patches = tail;
-          break;
-        }
-    }
-  }
-  return readonlyArray;
-});
-
-/** @internal */
-const DifferTypeId = /*#__PURE__*/Symbol.for("effect/Differ");
-/** @internal */
-const DifferProto = {
-  [DifferTypeId]: {
-    _P: identity,
-    _V: identity
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const make$n = params => {
-  const differ = Object.create(DifferProto);
-  differ.empty = params.empty;
-  differ.diff = params.diff;
-  differ.combine = params.combine;
-  differ.patch = params.patch;
-  return differ;
-};
-/** @internal */
-const environment = () => make$n({
-  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$n({
-  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$n({
-  empty: empty$a(),
-  combine: (first, second) => combine$2(first, second),
-  diff: (oldValue, newValue) => diff$4({
-    oldValue,
-    newValue,
-    differ
-  }),
-  patch: (patch, oldValue) => patch$5(patch, oldValue, differ)
-});
-/** @internal */
-const update$3 = () => updateWith((_, a) => a);
-/** @internal */
-const updateWith = f => make$n({
-  empty: identity,
-  combine: (first, second) => {
-    if (first === identity) {
-      return second;
-    }
-    if (second === identity) {
-      return first;
-    }
-    return a => second(first(a));
-  },
-  diff: (oldValue, newValue) => {
-    if (equals$1(oldValue, newValue)) {
-      return identity;
-    }
-    return constant(newValue);
-  },
-  patch: (patch, oldValue) => f(oldValue, patch(oldValue))
-});
-
-/** @internal */
-const BIT_MASK = 0xff;
-/** @internal */
-const BIT_SHIFT = 0x08;
-/** @internal */
-const active = patch => patch & BIT_MASK;
-/** @internal */
-const enabled = patch => patch >> BIT_SHIFT & BIT_MASK;
-/** @internal */
-const make$m = (active, enabled) => (active & BIT_MASK) + ((enabled & active & BIT_MASK) << BIT_SHIFT);
-/** @internal */
-const empty$9 = /*#__PURE__*/make$m(0, 0);
-/** @internal */
-const enable$2 = flag => make$m(flag, flag);
-/** @internal */
-const disable$1 = flag => make$m(flag, 0);
-/** @internal */
-const exclude$1 = /*#__PURE__*/dual(2, (self, flag) => make$m(active(self) & ~flag, enabled(self)));
-/** @internal */
-const andThen = /*#__PURE__*/dual(2, (self, that) => self | that);
-/** @internal */
-const invert = n => ~n >>> 0 & BIT_MASK;
-
-/** @internal */
-const None$1 = 0;
-/** @internal */
-const Interruption = 1 << 0;
-/** @internal */
-const OpSupervision = 1 << 1;
-/** @internal */
-const RuntimeMetrics = 1 << 2;
-/** @internal */
-const WindDown = 1 << 4;
-/** @internal */
-const CooperativeYielding = 1 << 5;
-/** @internal */
-const cooperativeYielding = self => isEnabled(self, CooperativeYielding);
-/** @internal */
-const enable$1 = /*#__PURE__*/dual(2, (self, flag) => self | flag);
-/** @internal */
-const interruptible$2 = self => interruption(self) && !windDown(self);
-/** @internal */
-const interruption = self => isEnabled(self, Interruption);
-/** @internal */
-const isEnabled = /*#__PURE__*/dual(2, (self, flag) => (self & flag) !== 0);
-/** @internal */
-const make$l = (...flags) => flags.reduce((a, b) => a | b, 0);
-/** @internal */
-const none$1 = /*#__PURE__*/make$l(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$m(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$n({
-  empty: empty$9,
-  diff: (oldValue, newValue) => diff$3(oldValue, newValue),
-  combine: (first, second) => andThen(second)(first),
-  patch: (_patch, oldValue) => patch$4(oldValue, _patch)
-});
-
-/**
- * @since 2.0.0
- */
-/**
- * Creates a `RuntimeFlagsPatch` describing enabling the provided `RuntimeFlag`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const enable = enable$2;
-/**
- * Creates a `RuntimeFlagsPatch` describing disabling the provided `RuntimeFlag`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const disable = disable$1;
-/**
- * Creates a `RuntimeFlagsPatch` which describes exclusion of the specified
- * `RuntimeFlag` from the set of `RuntimeFlags`.
- *
- * @category utils
- * @since 2.0.0
- */
-const exclude = exclude$1;
-
-/**
- * Combines this collection of blocked requests with the specified collection
- * of blocked requests, in parallel.
- *
- * @internal
- */
-const par = (self, that) => ({
-  _tag: "Par",
-  left: self,
-  right: that
-});
-/**
- * Combines this collection of blocked requests with the specified collection
- * of blocked requests, in sequence.
- *
- * @internal
- */
-const seq = (self, that) => ({
-  _tag: "Seq",
-  left: self,
-  right: that
-});
-/**
- * Flattens a collection of blocked requests into a collection of pipelined
- * and batched requests that can be submitted for execution.
- *
- * @internal
- */
-const flatten$4 = self => {
-  let current = of$1(self);
-  let updated = empty$d();
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    const [parallel, sequential] = reduce(current, [parallelCollectionEmpty(), empty$d()], ([parallel, sequential], blockedRequest) => {
-      const [par, seq] = step$1(blockedRequest);
-      return [parallelCollectionCombine(parallel, par), appendAll(sequential, seq)];
-    });
-    updated = merge(updated, parallel);
-    if (isNil(sequential)) {
-      return reverse(updated);
-    }
-    current = sequential;
-  }
-  throw new Error("BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/effect/issues");
-};
-/**
- * Takes one step in evaluating a collection of blocked requests, returning a
- * collection of blocked requests that can be performed in parallel and a list
- * of blocked requests that must be performed sequentially after those
- * requests.
- */
-const step$1 = requests => {
-  let current = requests;
-  let parallel = parallelCollectionEmpty();
-  let stack = empty$d();
-  let sequential = empty$d();
-  // eslint-disable-next-line no-constant-condition
-  while (1) {
-    switch (current._tag) {
-      case "Empty":
-        {
-          if (isNil(stack)) {
-            return [parallel, sequential];
-          }
-          current = stack.head;
-          stack = stack.tail;
-          break;
-        }
-      case "Par":
-        {
-          stack = cons(current.right, stack);
-          current = current.left;
-          break;
-        }
-      case "Seq":
-        {
-          const left = current.left;
-          const right = current.right;
-          switch (left._tag) {
-            case "Empty":
-              {
-                current = right;
-                break;
-              }
-            case "Par":
-              {
-                const l = left.left;
-                const r = left.right;
-                current = par(seq(l, right), seq(r, right));
-                break;
-              }
-            case "Seq":
-              {
-                const l = left.left;
-                const r = left.right;
-                current = seq(l, seq(r, right));
-                break;
-              }
-            case "Single":
-              {
-                current = left;
-                sequential = cons(right, sequential);
-                break;
-              }
-          }
-          break;
-        }
-      case "Single":
-        {
-          parallel = parallelCollectionAdd(parallel, current);
-          if (isNil(stack)) {
-            return [parallel, sequential];
-          }
-          current = stack.head;
-          stack = stack.tail;
-          break;
-        }
-    }
-  }
-  throw new Error("BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/effect/issues");
-};
-/**
- * Merges a collection of requests that must be executed sequentially with a
- * collection of requests that can be executed in parallel. If the collections
- * are both from the same single data source then the requests can be
- * pipelined while preserving ordering guarantees.
- */
-const merge = (sequential, parallel) => {
-  if (isNil(sequential)) {
-    return of$1(parallelCollectionToSequentialCollection(parallel));
-  }
-  if (parallelCollectionIsEmpty(parallel)) {
-    return sequential;
-  }
-  const seqHeadKeys = sequentialCollectionKeys(sequential.head);
-  const parKeys = parallelCollectionKeys(parallel);
-  if (seqHeadKeys.length === 1 && parKeys.length === 1 && equals$1(seqHeadKeys[0], parKeys[0])) {
-    return cons(sequentialCollectionCombine(sequential.head, parallelCollectionToSequentialCollection(parallel)), sequential.tail);
-  }
-  return cons(parallelCollectionToSequentialCollection(parallel), sequential);
-};
-/** @internal */
-const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
-const parallelVariance = {
-  /* c8 ignore next */
-  _R: _ => _
-};
-class ParallelImpl {
-  map;
-  [RequestBlockParallelTypeId] = parallelVariance;
-  constructor(map) {
-    this.map = map;
-  }
-}
-/** @internal */
-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$2(blockedRequest.blockedRequest))));
-/** @internal */
-const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$1(self.map, that.map, (map, value, key) => set$2(map, key, match$6(get$4(map, key), {
-  onNone: () => value,
-  onSome: other => appendAll$1(value, other)
-}))));
-/** @internal */
-const parallelCollectionIsEmpty = self => isEmpty$4(self.map);
-/** @internal */
-const parallelCollectionKeys = self => Array.from(keys(self.map));
-/** @internal */
-const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map$7(self.map, x => of$2(x)));
-// TODO
-// /** @internal */
-// export const parallelCollectionToChunk = <R>(
-//   self: ParallelCollection<R>
-// ): Array<[RequestResolver.RequestResolver<unknown, R>, Array<Request.Entry<unknown>>]> => Array.from(self.map) as any
-/** @internal */
-const SequentialCollectionTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential");
-const sequentialVariance = {
-  /* c8 ignore next */
-  _R: _ => _
-};
-class SequentialImpl {
-  map;
-  [SequentialCollectionTypeId] = sequentialVariance;
-  constructor(map) {
-    this.map = map;
-  }
-}
-/** @internal */
-const sequentialCollectionMake = map => new SequentialImpl(map);
-/** @internal */
-const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$1(that.map, self.map, (map, value, key) => set$2(map, key, match$6(get$4(map, key), {
-  onNone: () => empty$g(),
-  onSome: a => appendAll$1(a, value)
-}))));
-/** @internal */
-const sequentialCollectionKeys = self => Array.from(keys(self.map));
-/** @internal */
-const sequentialCollectionToChunk = self => Array.from(self.map);
-
-/** @internal */
-const OP_STATE_PENDING = "Pending";
-/** @internal */
-const OP_STATE_DONE$1 = "Done";
-
-/** @internal */
-const DeferredSymbolKey = "effect/Deferred";
-/** @internal */
-const DeferredTypeId = /*#__PURE__*/Symbol.for(DeferredSymbolKey);
-/** @internal */
-const deferredVariance = {
-  /* c8 ignore next */
-  _E: _ => _,
-  /* c8 ignore next */
-  _A: _ => _
-};
-/** @internal */
-const pending = joiners => {
-  return {
-    _tag: OP_STATE_PENDING,
-    joiners
-  };
-};
-/** @internal */
-const done$4 = effect => {
-  return {
-    _tag: OP_STATE_DONE$1,
-    effect
-  };
-};
-
-/** @internal */
-class SingleShotGen {
-  self;
-  called = false;
-  constructor(self) {
-    this.self = self;
-  }
-  next(a) {
-    return this.called ? {
-      value: a,
-      done: true
-    } : (this.called = true, {
-      value: this.self,
-      done: false
-    });
-  }
-  return(a) {
-    return {
-      value: a,
-      done: true
-    };
-  }
-  throw(e) {
-    throw e;
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(this.self);
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Effect
-// -----------------------------------------------------------------------------
-/**
- * @internal
- */
-const blocked = (blockedRequests, _continue) => {
-  const effect = new EffectPrimitive("Blocked");
-  effect.effect_instruction_i0 = blockedRequests;
-  effect.effect_instruction_i1 = _continue;
-  return effect;
-};
-/**
- * @internal
- */
-const runRequestBlock = blockedRequests => {
-  const effect = new EffectPrimitive("RunBlocked");
-  effect.effect_instruction_i0 = blockedRequests;
-  return effect;
-};
-/** @internal */
-const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
-/** @internal */
-class RevertFlags {
-  patch;
-  op;
-  _op = OP_REVERT_FLAGS;
-  constructor(patch, op) {
-    this.patch = patch;
-    this.op = op;
-  }
-}
-class EffectPrimitive {
-  _op;
-  effect_instruction_i0 = undefined;
-  effect_instruction_i1 = undefined;
-  effect_instruction_i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = effectVariance;
-  constructor(_op) {
-    this._op = _op;
-  }
-  [symbol](that) {
-    return this === that;
-  }
-  [symbol$1]() {
-    return cached(this, random(this));
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Effect",
-      _op: this._op,
-      effect_instruction_i0: toJSON(this.effect_instruction_i0),
-      effect_instruction_i1: toJSON(this.effect_instruction_i1),
-      effect_instruction_i2: toJSON(this.effect_instruction_i2)
-    };
-  }
-  toString() {
-    return format$1(this.toJSON());
-  }
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-}
-/** @internal */
-class EffectPrimitiveFailure {
-  _op;
-  effect_instruction_i0 = undefined;
-  effect_instruction_i1 = undefined;
-  effect_instruction_i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = effectVariance;
-  constructor(_op) {
-    this._op = _op;
-    // @ts-expect-error
-    this._tag = _op;
-  }
-  [symbol](that) {
-    return exitIsExit(that) && that._op === "Failure" &&
-    // @ts-expect-error
-    equals$1(this.effect_instruction_i0, that.effect_instruction_i0);
-  }
-  [symbol$1]() {
-    return pipe(
-    // @ts-expect-error
-    string(this._tag),
-    // @ts-expect-error
-    combine$7(hash(this.effect_instruction_i0)), cached(this));
-  }
-  get cause() {
-    return this.effect_instruction_i0;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Exit",
-      _tag: this._op,
-      cause: this.cause.toJSON()
-    };
-  }
-  toString() {
-    return format$1(this.toJSON());
-  }
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-}
-/** @internal */
-class EffectPrimitiveSuccess {
-  _op;
-  effect_instruction_i0 = undefined;
-  effect_instruction_i1 = undefined;
-  effect_instruction_i2 = undefined;
-  trace = undefined;
-  [EffectTypeId] = effectVariance;
-  constructor(_op) {
-    this._op = _op;
-    // @ts-expect-error
-    this._tag = _op;
-  }
-  [symbol](that) {
-    return exitIsExit(that) && that._op === "Success" &&
-    // @ts-expect-error
-    equals$1(this.effect_instruction_i0, that.effect_instruction_i0);
-  }
-  [symbol$1]() {
-    return pipe(
-    // @ts-expect-error
-    string(this._tag),
-    // @ts-expect-error
-    combine$7(hash(this.effect_instruction_i0)), cached(this));
-  }
-  get value() {
-    return this.effect_instruction_i0;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  toJSON() {
-    return {
-      _id: "Exit",
-      _tag: this._op,
-      value: toJSON(this.value)
-    };
-  }
-  toString() {
-    return format$1(this.toJSON());
-  }
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  }
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-}
-/** @internal */
-const isEffect$1 = u => hasProperty(u, EffectTypeId);
-/* @internal */
-const withFiberRuntime$1 = withRuntime => {
-  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
-  effect.effect_instruction_i0 = withRuntime;
-  return effect;
-};
-/* @internal */
-const acquireUseRelease$1 = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask$1(restore => flatMap$3(acquire, a => flatMap$3(exit$1(suspend$3(() => restore(use(a)))), exit => {
-  return suspend$3(() => release(a, exit)).pipe(matchCauseEffect$1({
-    onFailure: cause => {
-      switch (exit._tag) {
-        case OP_FAILURE:
-          return failCause$6(sequential$2(exit.effect_instruction_i0, cause));
-        case OP_SUCCESS:
-          return failCause$6(cause);
-      }
-    },
-    onSuccess: () => exit
-  }));
-}))));
-/* @internal */
-const as$1 = /*#__PURE__*/dual(2, (self, value) => flatMap$3(self, () => succeed$4(value)));
-/* @internal */
-const asVoid$1 = self => as$1(self, void 0);
-/* @internal */
-const custom = function () {
-  const wrapper = new EffectPrimitive(OP_COMMIT);
-  switch (arguments.length) {
-    case 2:
-      {
-        wrapper.effect_instruction_i0 = arguments[0];
-        wrapper.commit = arguments[1];
-        break;
-      }
-    case 3:
-      {
-        wrapper.effect_instruction_i0 = arguments[0];
-        wrapper.effect_instruction_i1 = arguments[1];
-        wrapper.commit = arguments[2];
-        break;
-      }
-    case 4:
-      {
-        wrapper.effect_instruction_i0 = arguments[0];
-        wrapper.effect_instruction_i1 = arguments[1];
-        wrapper.effect_instruction_i2 = arguments[2];
-        wrapper.commit = arguments[3];
-        break;
-      }
-    default:
-      {
-        throw new Error(getBugErrorMessage("you're not supposed to end up here"));
-      }
-  }
-  return wrapper;
-};
-/* @internal */
-const unsafeAsync = (register, blockingOn = none$2) => {
-  const effect = new EffectPrimitive(OP_ASYNC);
-  let cancelerRef = undefined;
-  effect.effect_instruction_i0 = resume => {
-    cancelerRef = register(resume);
-  };
-  effect.effect_instruction_i1 = blockingOn;
-  return onInterrupt(effect, _ => isEffect$1(cancelerRef) ? cancelerRef : void_$2);
-};
-/* @internal */
-const asyncInterrupt = (register, blockingOn = none$2) => suspend$3(() => unsafeAsync(register, blockingOn));
-const async_ = (resume, blockingOn = none$2) => {
-  return custom(resume, function () {
-    let backingResume = undefined;
-    let pendingEffect = undefined;
-    function proxyResume(effect) {
-      if (backingResume) {
-        backingResume(effect);
-      } else if (pendingEffect === undefined) {
-        pendingEffect = effect;
-      }
-    }
-    const effect = new EffectPrimitive(OP_ASYNC);
-    effect.effect_instruction_i0 = resume => {
-      backingResume = resume;
-      if (pendingEffect) {
-        resume(pendingEffect);
-      }
-    };
-    effect.effect_instruction_i1 = blockingOn;
-    let cancelerRef = undefined;
-    let controllerRef = undefined;
-    if (this.effect_instruction_i0.length !== 1) {
-      controllerRef = new AbortController();
-      cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume, controllerRef.signal));
-    } else {
-      cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume));
-    }
-    return cancelerRef || controllerRef ? onInterrupt(effect, _ => {
-      if (controllerRef) {
-        controllerRef.abort();
-      }
-      return cancelerRef ?? void_$2;
-    }) : effect;
-  });
-};
-/* @internal */
-const catchAllCause$1 = /*#__PURE__*/dual(2, (self, f) => {
-  const effect = new EffectPrimitive(OP_ON_FAILURE);
-  effect.effect_instruction_i0 = self;
-  effect.effect_instruction_i1 = f;
-  return effect;
-});
-/* @internal */
-const catchAll$1 = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
-  onFailure: f,
-  onSuccess: succeed$4
-}));
-const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
-/* @internal */
-const capture = (obj, span) => {
-  if (isSome(span)) {
-    return new Proxy(obj, {
-      has(target, p) {
-        return p === spanSymbol || p === originalSymbol || p in target;
-      },
-      get(target, p) {
-        if (p === spanSymbol) {
-          return span.value;
-        }
-        if (p === originalSymbol) {
-          return obj;
-        }
-        // @ts-expect-error
-        return target[p];
-      }
-    });
-  }
-  return obj;
-};
-/* @internal */
-const die$2 = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime$1(fiber => failCause$6(die$3(capture(defect, currentSpanFromFiber(fiber))))) : failCause$6(die$3(defect));
-/* @internal */
-const dieMessage$1 = message => failCauseSync$1(() => die$3(new RuntimeException(message)));
-/* @internal */
-const either = self => matchEffect(self, {
-  onFailure: e => succeed$4(left(e)),
-  onSuccess: a => succeed$4(right(a))
-});
-/* @internal */
-const exit$1 = self => matchCause$1(self, {
-  onFailure: exitFailCause,
-  onSuccess: exitSucceed
-});
-/* @internal */
-const fail$4 = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime$1(fiber => failCause$6(fail$5(capture(error, currentSpanFromFiber(fiber))))) : failCause$6(fail$5(error));
-/* @internal */
-const failSync = evaluate => flatMap$3(sync$2(evaluate), fail$4);
-/* @internal */
-const failCause$6 = cause => {
-  const effect = new EffectPrimitiveFailure(OP_FAILURE);
-  effect.effect_instruction_i0 = cause;
-  return effect;
-};
-/* @internal */
-const failCauseSync$1 = evaluate => flatMap$3(sync$2(evaluate), failCause$6);
-/* @internal */
-const fiberId = /*#__PURE__*/withFiberRuntime$1(state => succeed$4(state.id()));
-/* @internal */
-const fiberIdWith$1 = f => withFiberRuntime$1(state => f(state.id()));
-/* @internal */
-const flatMap$3 = /*#__PURE__*/dual(2, (self, f) => {
-  const effect = new EffectPrimitive(OP_ON_SUCCESS);
-  effect.effect_instruction_i0 = self;
-  effect.effect_instruction_i1 = f;
-  return effect;
-});
-/* @internal */
-const step = self => {
-  const effect = new EffectPrimitive("OnStep");
-  effect.effect_instruction_i0 = self;
-  return effect;
-};
-/* @internal */
-const flatten$3 = self => flatMap$3(self, identity);
-/* @internal */
-const matchCause$1 = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$1(self, {
-  onFailure: cause => succeed$4(options.onFailure(cause)),
-  onSuccess: a => succeed$4(options.onSuccess(a))
-}));
-/* @internal */
-const matchCauseEffect$1 = /*#__PURE__*/dual(2, (self, options) => {
-  const effect = new EffectPrimitive(OP_ON_SUCCESS_AND_FAILURE);
-  effect.effect_instruction_i0 = self;
-  effect.effect_instruction_i1 = options.onFailure;
-  effect.effect_instruction_i2 = options.onSuccess;
-  return effect;
-});
-/* @internal */
-const matchEffect = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect$1(self, {
-  onFailure: cause => {
-    const defects$1 = defects(cause);
-    if (defects$1.length > 0) {
-      return failCause$6(electFailures(cause));
-    }
-    const failures$1 = failures(cause);
-    if (failures$1.length > 0) {
-      return options.onFailure(unsafeHead(failures$1));
-    }
-    return failCause$6(cause);
-  },
-  onSuccess: options.onSuccess
-}));
-/* @internal */
-const forEachSequential = /*#__PURE__*/dual(2, (self, f) => suspend$3(() => {
-  const arr = fromIterable$3(self);
-  const ret = allocate(arr.length);
-  let i = 0;
-  return as$1(whileLoop({
-    while: () => i < arr.length,
-    body: () => f(arr[i], i),
-    step: b => {
-      ret[i++] = b;
-    }
-  }), ret);
-}));
-/* @internal */
-const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspend$3(() => {
-  const arr = fromIterable$3(self);
-  let i = 0;
-  return whileLoop({
-    while: () => i < arr.length,
-    body: () => f(arr[i], i),
-    step: () => {
-      i++;
-    }
-  });
-}));
-/* @internal */
-const interrupt$3 = /*#__PURE__*/flatMap$3(fiberId, fiberId => interruptWith(fiberId));
-/* @internal */
-const interruptWith = fiberId => failCause$6(interrupt$4(fiberId));
-/* @internal */
-const interruptible$1 = self => {
-  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
-  effect.effect_instruction_i0 = enable(Interruption);
-  effect.effect_instruction_i1 = () => self;
-  return effect;
-};
-/* @internal */
-const intoDeferred$1 = /*#__PURE__*/dual(2, (self, deferred) => uninterruptibleMask$1(restore => flatMap$3(exit$1(restore(self)), exit => deferredDone(deferred, exit))));
-/* @internal */
-const map$6 = /*#__PURE__*/dual(2, (self, f) => flatMap$3(self, a => sync$2(() => f(a))));
-/* @internal */
-const mapBoth = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
-  onFailure: e => failSync(() => options.onFailure(e)),
-  onSuccess: a => sync$2(() => options.onSuccess(a))
-}));
-/* @internal */
-const mapError$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$1(self, {
-  onFailure: cause => {
-    const either = failureOrCause$1(cause);
-    switch (either._tag) {
-      case "Left":
-        {
-          return failSync(() => f(either.left));
-        }
-      case "Right":
+      case "Single":
         {
-          return failCause$6(either.right);
-        }
-    }
-  },
-  onSuccess: succeed$4
-}));
-/* @internal */
-const onExit = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask$1(restore => matchCauseEffect$1(restore(self), {
-  onFailure: cause1 => {
-    const result = exitFailCause(cause1);
-    return matchCauseEffect$1(cleanup(result), {
-      onFailure: cause2 => exitFailCause(sequential$2(cause1, cause2)),
-      onSuccess: () => result
-    });
-  },
-  onSuccess: success => {
-    const result = exitSucceed(success);
-    return zipRight$3(cleanup(result), result);
-  }
-})));
-/* @internal */
-const onInterrupt = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, exitMatch({
-  onFailure: cause => isInterruptedOnly$1(cause) ? asVoid$1(cleanup(interruptors$1(cause))) : void_$2,
-  onSuccess: () => void_$2
-})));
-/* @internal */
-const orDie = self => orDieWith(self, identity);
-/* @internal */
-const orDieWith = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
-  onFailure: e => die$2(f(e)),
-  onSuccess: succeed$4
-}));
-/* @internal */
-const succeed$4 = value => {
-  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
-  effect.effect_instruction_i0 = value;
-  return effect;
-};
-/* @internal */
-const suspend$3 = evaluate => {
-  const effect = new EffectPrimitive(OP_COMMIT);
-  effect.commit = evaluate;
-  return effect;
-};
-/* @internal */
-const sync$2 = thunk => {
-  const effect = new EffectPrimitive(OP_SYNC);
-  effect.effect_instruction_i0 = thunk;
-  return effect;
-};
-/* @internal */
-const tap$1 = /*#__PURE__*/dual(args => args.length === 3 || args.length === 2 && !(isObject(args[1]) && "onlyEffect" in args[1]), (self, f) => flatMap$3(self, a => {
-  const b = typeof f === "function" ? f(a) : f;
-  if (isEffect$1(b)) {
-    return as$1(b, a);
-  } else if (isPromiseLike(b)) {
-    return unsafeAsync(resume => {
-      b.then(_ => resume(succeed$4(a)), e => resume(fail$4(new UnknownException(e, "An unknown error occurred in Effect.tap"))));
-    });
-  }
-  return succeed$4(a);
-}));
-/* @internal */
-const transplant = f => withFiberRuntime$1(state => {
-  const scopeOverride = state.getFiberRef(currentForkScopeOverride);
-  const scope = pipe(scopeOverride, getOrElse(() => state.scope()));
-  return f(fiberRefLocally(currentForkScopeOverride, some(scope)));
-});
-/* @internal */
-const uninterruptible$1 = self => {
-  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
-  effect.effect_instruction_i0 = disable(Interruption);
-  effect.effect_instruction_i1 = () => self;
-  return effect;
-};
-/* @internal */
-const uninterruptibleMask$1 = f => custom(f, function () {
-  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
-  effect.effect_instruction_i0 = disable(Interruption);
-  effect.effect_instruction_i1 = oldFlags => interruption(oldFlags) ? internalCall(() => this.effect_instruction_i0(interruptible$1)) : internalCall(() => this.effect_instruction_i0(uninterruptible$1));
-  return effect;
-});
-const void_$2 = /*#__PURE__*/succeed$4(void 0);
-/* @internal */
-const updateRuntimeFlags = patch => {
-  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
-  effect.effect_instruction_i0 = patch;
-  effect.effect_instruction_i1 = void 0;
-  return effect;
-};
-/* @internal */
-const whenEffect = /*#__PURE__*/dual(2, (self, condition) => flatMap$3(condition, b => {
-  if (b) {
-    return pipe(self, map$6(some));
-  }
-  return succeed$4(none$4());
-}));
-/* @internal */
-const whileLoop = options => {
-  const effect = new EffectPrimitive(OP_WHILE);
-  effect.effect_instruction_i0 = options.while;
-  effect.effect_instruction_i1 = options.body;
-  effect.effect_instruction_i2 = options.step;
-  return effect;
-};
-/* @internal */
-const fromIterator = iterator => suspend$3(() => {
-  const effect = new EffectPrimitive(OP_ITERATOR);
-  effect.effect_instruction_i0 = iterator();
-  return effect;
-});
-/* @internal */
-const gen$1 = function () {
-  const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0]);
-  return fromIterator(() => f(pipe));
-};
-/** @internal */
-const fnUntraced = (body, ...pipeables) => Object.defineProperty(pipeables.length === 0 ? function (...args) {
-  return fromIterator(() => body.apply(this, args));
-} : function (...args) {
-  let effect = fromIterator(() => body.apply(this, args));
-  for (const x of pipeables) {
-    effect = x(effect, ...args);
-  }
-  return effect;
-}, "length", {
-  value: body.length,
-  configurable: true
-});
-/* @internal */
-const yieldNow$1 = options => {
-  const effect = new EffectPrimitive(OP_YIELD$1);
-  return typeof options?.priority !== "undefined" ? withSchedulingPriority(effect, options.priority) : effect;
-};
-/* @internal */
-const zip$3 = /*#__PURE__*/dual(2, (self, that) => flatMap$3(self, a => map$6(that, b => [a, b])));
-/* @internal */
-const zipLeft$1 = /*#__PURE__*/dual(2, (self, that) => flatMap$3(self, a => as$1(that, a)));
-/* @internal */
-const zipRight$3 = /*#__PURE__*/dual(2, (self, that) => flatMap$3(self, () => that));
-/* @internal */
-const zipWith$1 = /*#__PURE__*/dual(3, (self, that, f) => flatMap$3(self, a => map$6(that, b => f(a, b))));
-// -----------------------------------------------------------------------------
-// Fiber
-// -----------------------------------------------------------------------------
-/* @internal */
-const interruptFiber = self => flatMap$3(fiberId, fiberId => pipe(self, interruptAsFiber(fiberId)));
-/* @internal */
-const interruptAsFiber = /*#__PURE__*/dual(2, (self, fiberId) => flatMap$3(self.interruptAsFork(fiberId), () => self.await));
-// -----------------------------------------------------------------------------
-// LogLevel
-// -----------------------------------------------------------------------------
-/** @internal */
-const logLevelAll = {
-  _tag: "All",
-  syslog: 0,
-  label: "ALL",
-  ordinal: Number.MIN_SAFE_INTEGER,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const logLevelFatal = {
-  _tag: "Fatal",
-  syslog: 2,
-  label: "FATAL",
-  ordinal: 50000,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const logLevelError = {
-  _tag: "Error",
-  syslog: 3,
-  label: "ERROR",
-  ordinal: 40000,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const logLevelWarning = {
-  _tag: "Warning",
-  syslog: 4,
-  label: "WARN",
-  ordinal: 30000,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-/** @internal */
-const logLevelInfo = {
-  _tag: "Info",
-  syslog: 6,
-  label: "INFO",
-  ordinal: 20000,
-  pipe() {
-    return pipeArguments(this, arguments);
+          parallel = parallelCollectionAdd(parallel, current);
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
+        }
+    }
   }
+  throw new Error("BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/effect/issues");
 };
-/** @internal */
-const logLevelDebug = {
-  _tag: "Debug",
-  syslog: 7,
-  label: "DEBUG",
-  ordinal: 10000,
-  pipe() {
-    return pipeArguments(this, arguments);
+/**
+ * Merges a collection of requests that must be executed sequentially with a
+ * collection of requests that can be executed in parallel. If the collections
+ * are both from the same single data source then the requests can be
+ * pipelined while preserving ordering guarantees.
+ */
+const merge = (sequential, parallel) => {
+  if (isNil(sequential)) {
+    return of$1(parallelCollectionToSequentialCollection(parallel));
   }
-};
-/** @internal */
-const logLevelTrace = {
-  _tag: "Trace",
-  syslog: 7,
-  label: "TRACE",
-  ordinal: 0,
-  pipe() {
-    return pipeArguments(this, arguments);
+  if (parallelCollectionIsEmpty(parallel)) {
+    return sequential;
   }
-};
-/** @internal */
-const logLevelNone = {
-  _tag: "None",
-  syslog: 7,
-  label: "OFF",
-  ordinal: Number.MAX_SAFE_INTEGER,
-  pipe() {
-    return pipeArguments(this, arguments);
+  const seqHeadKeys = sequentialCollectionKeys(sequential.head);
+  const parKeys = parallelCollectionKeys(parallel);
+  if (seqHeadKeys.length === 1 && parKeys.length === 1 && equals$1(seqHeadKeys[0], parKeys[0])) {
+    return cons(sequentialCollectionCombine(sequential.head, parallelCollectionToSequentialCollection(parallel)), sequential.tail);
   }
+  return cons(parallelCollectionToSequentialCollection(parallel), sequential);
 };
-// -----------------------------------------------------------------------------
-// FiberRef
-// -----------------------------------------------------------------------------
 /** @internal */
-const FiberRefSymbolKey = "effect/FiberRef";
-/** @internal */
-const FiberRefTypeId = /*#__PURE__*/Symbol.for(FiberRefSymbolKey);
-const fiberRefVariance = {
+const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
+const parallelVariance = {
   /* c8 ignore next */
-  _A: _ => _
-};
-/* @internal */
-const fiberRefGet = self => withFiberRuntime$1(fiber => exitSucceed(fiber.getFiberRef(self)));
-/* @internal */
-const fiberRefGetWith = /*#__PURE__*/dual(2, (self, f) => flatMap$3(fiberRefGet(self), f));
-/* @internal */
-const fiberRefSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(self, () => [void 0, value]));
-/* @internal */
-const fiberRefModify = /*#__PURE__*/dual(2, (self, f) => withFiberRuntime$1(state => {
-  const [b, a] = f(state.getFiberRef(self));
-  state.setFiberRef(self, a);
-  return succeed$4(b);
-}));
-/* @internal */
-const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => acquireUseRelease$1(zipLeft$1(fiberRefGet(self), fiberRefSet(self, value)), () => use, oldValue => fiberRefSet(self, oldValue)));
-/* @internal */
-const fiberRefLocallyWith = /*#__PURE__*/dual(3, (use, self, f) => fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))));
-/** @internal */
-const fiberRefUnsafeMake = (initial, options) => fiberRefUnsafeMakePatch(initial, {
-  differ: update$3(),
-  fork: options?.fork ?? identity,
-  join: options?.join
-});
-/** @internal */
-const fiberRefUnsafeMakeHashSet = initial => {
-  const differ = hashSet();
-  return fiberRefUnsafeMakePatch(initial, {
-    differ,
-    fork: differ.empty
-  });
-};
-/** @internal */
-const fiberRefUnsafeMakeReadonlyArray = initial => {
-  const differ = readonlyArray(update$3());
-  return fiberRefUnsafeMakePatch(initial, {
-    differ,
-    fork: differ.empty
-  });
-};
-/** @internal */
-const fiberRefUnsafeMakeContext = initial => {
-  const differ = environment();
-  return fiberRefUnsafeMakePatch(initial, {
-    differ,
-    fork: differ.empty
-  });
-};
-/** @internal */
-const fiberRefUnsafeMakePatch = (initial, options) => {
-  const _fiberRef = {
-    ...CommitPrototype,
-    [FiberRefTypeId]: fiberRefVariance,
-    initial,
-    commit() {
-      return fiberRefGet(this);
-    },
-    diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
-    combine: (first, second) => options.differ.combine(first, second),
-    patch: patch => oldValue => options.differ.patch(patch, oldValue),
-    fork: options.fork,
-    join: options.join ?? ((_, n) => n)
-  };
-  return _fiberRef;
-};
-/** @internal */
-const fiberRefUnsafeMakeRuntimeFlags = initial => fiberRefUnsafeMakePatch(initial, {
-  differ: differ$1,
-  fork: differ$1.empty
-});
-/** @internal */
-const currentContext = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(empty$i()));
-/** @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$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$d()));
-/** @internal */
-const withSchedulingPriority = /*#__PURE__*/dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
-/** @internal */
-const currentConcurrency = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentConcurrency"), () => fiberRefUnsafeMake("unbounded"));
-/**
- * @internal
- */
-const currentRequestBatching = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestBatching"), () => fiberRefUnsafeMake(true));
-/** @internal */
-const currentUnhandledErrorLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"), () => fiberRefUnsafeMake(some(logLevelDebug)));
-/** @internal */
-const currentVersionMismatchErrorLogLevel = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/versionMismatchErrorLogLevel"), () => fiberRefUnsafeMake(some(logLevelWarning)));
-/** @internal */
-const currentMetricLabels = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(empty$j()));
-/** @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$h, {
-  fork: () => empty$h,
-  join: (parent, _) => parent
-}));
-// -----------------------------------------------------------------------------
-// Scope
-// -----------------------------------------------------------------------------
-/** @internal */
-const ScopeTypeId = /*#__PURE__*/Symbol.for("effect/Scope");
-/** @internal */
-const CloseableScopeTypeId = /*#__PURE__*/Symbol.for("effect/CloseableScope");
-/* @internal */
-const scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asVoid$1(finalizer));
-/* @internal */
-const scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer);
-/* @internal */
-const scopeClose = (self, exit) => self.close(exit);
-/* @internal */
-const scopeFork = (self, strategy) => self.fork(strategy);
-// -----------------------------------------------------------------------------
-// Errors
-// -----------------------------------------------------------------------------
-/** @internal */
-const YieldableError = /*#__PURE__*/function () {
-  class YieldableError extends globalThis.Error {
-    commit() {
-      return fail$4(this);
-    }
-    toJSON() {
-      const obj = {
-        ...this
-      };
-      if (this.message) obj.message = this.message;
-      if (this.cause) obj.cause = this.cause;
-      return obj;
-    }
-    [NodeInspectSymbol]() {
-      if (this.toString !== globalThis.Error.prototype.toString) {
-        return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
-      } else if ("Bun" in globalThis) {
-        return pretty(fail$5(this), {
-          renderErrorCause: true
-        });
-      }
-      return this;
-    }
-  }
-  // @effect-diagnostics-next-line floatingEffect:off
-  Object.assign(YieldableError.prototype, StructuralCommitPrototype);
-  return YieldableError;
-}();
-const makeException = (proto, tag) => {
-  class Base extends YieldableError {
-    _tag = tag;
-  }
-  Object.assign(Base.prototype, proto);
-  Base.prototype.name = tag;
-  return Base;
+  _R: _ => _
 };
-/** @internal */
-const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
-/** @internal */
-const RuntimeException = /*#__PURE__*/makeException({
-  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
-}, "RuntimeException");
-/** @internal */
-const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
-/** @internal */
-const isInterruptedException = u => hasProperty(u, InterruptedExceptionTypeId);
-/** @internal */
-const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
-/** @internal */
-const NoSuchElementException = /*#__PURE__*/makeException({
-  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
-}, "NoSuchElementException");
-/** @internal */
-const UnknownExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/UnknownException");
-/** @internal */
-const UnknownException = /*#__PURE__*/function () {
-  class UnknownException extends YieldableError {
-    _tag = "UnknownException";
-    error;
-    constructor(cause, message) {
-      super(message ?? "An unknown error occurred", {
-        cause
-      });
-      this.error = cause;
-    }
+class ParallelImpl {
+  map;
+  [RequestBlockParallelTypeId] = parallelVariance;
+  constructor(map) {
+    this.map = map;
   }
-  Object.assign(UnknownException.prototype, {
-    [UnknownExceptionTypeId]: UnknownExceptionTypeId,
-    name: "UnknownException"
-  });
-  return UnknownException;
-}();
-// -----------------------------------------------------------------------------
-// Exit
-// -----------------------------------------------------------------------------
-/** @internal */
-const exitIsExit = u => isEffect$1(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
-/** @internal */
-const exitIsFailure = self => self._tag === "Failure";
+}
 /** @internal */
-const exitIsSuccess = self => self._tag === "Success";
+const parallelCollectionEmpty = () => new ParallelImpl(empty$a());
 /** @internal */
-const exitAs = /*#__PURE__*/dual(2, (self, value) => {
-  switch (self._tag) {
-    case OP_FAILURE:
-      {
-        return exitFailCause(self.effect_instruction_i0);
-      }
-    case OP_SUCCESS:
-      {
-        return exitSucceed(value);
-      }
-  }
-});
+const parallelCollectionAdd = (self, blockedRequest) => new ParallelImpl(modifyAt(self.map, blockedRequest.dataSource, _ => orElseSome(map$6(_, append$1(blockedRequest.blockedRequest)), () => of$2(blockedRequest.blockedRequest))));
 /** @internal */
-const exitAsVoid = self => exitAs(self, void 0);
+const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$1(self.map, that.map, (map, value, key) => set$2(map, key, match$6(get$4(map, key), {
+  onNone: () => value,
+  onSome: other => appendAll$1(value, other)
+}))));
 /** @internal */
-const exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel$2 : sequential$2);
+const parallelCollectionIsEmpty = self => isEmpty$4(self.map);
 /** @internal */
-const exitDie = defect => exitFailCause(die$3(defect));
+const parallelCollectionKeys = self => Array.from(keys(self.map));
 /** @internal */
-const exitFail = error => exitFailCause(fail$5(error));
+const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map$7(self.map, x => of$2(x)));
+// TODO
+// /** @internal */
+// export const parallelCollectionToChunk = <R>(
+//   self: ParallelCollection<R>
+// ): Array<[RequestResolver.RequestResolver<unknown, R>, Array<Request.Entry<unknown>>]> => Array.from(self.map) as any
 /** @internal */
-const exitFailCause = cause => {
-  const effect = new EffectPrimitiveFailure(OP_FAILURE);
-  effect.effect_instruction_i0 = cause;
-  return effect;
+const SequentialCollectionTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential");
+const sequentialVariance = {
+  /* c8 ignore next */
+  _R: _ => _
 };
-/** @internal */
-const exitInterrupt = fiberId => exitFailCause(interrupt$4(fiberId));
-/** @internal */
-const exitMap = /*#__PURE__*/dual(2, (self, f) => {
-  switch (self._tag) {
-    case OP_FAILURE:
-      return exitFailCause(self.effect_instruction_i0);
-    case OP_SUCCESS:
-      return exitSucceed(f(self.effect_instruction_i0));
-  }
-});
-/** @internal */
-const exitMatch = /*#__PURE__*/dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case OP_FAILURE:
-      return onFailure(self.effect_instruction_i0);
-    case OP_SUCCESS:
-      return onSuccess(self.effect_instruction_i0);
-  }
-});
-/** @internal */
-const exitMatchEffect = /*#__PURE__*/dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case OP_FAILURE:
-      return onFailure(self.effect_instruction_i0);
-    case OP_SUCCESS:
-      return onSuccess(self.effect_instruction_i0);
+class SequentialImpl {
+  map;
+  [SequentialCollectionTypeId] = sequentialVariance;
+  constructor(map) {
+    this.map = map;
   }
-});
-/** @internal */
-const exitSucceed = value => {
-  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
-  effect.effect_instruction_i0 = value;
-  return effect;
-};
-/** @internal */
-const exitVoid = /*#__PURE__*/exitSucceed(void 0);
-/** @internal */
-const exitZip = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (a, a2) => [a, a2],
-  onFailure: sequential$2
-}));
+}
 /** @internal */
-const exitZipRight = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
-  onSuccess: (_, a2) => a2,
-  onFailure: sequential$2
-}));
+const sequentialCollectionMake = map => new SequentialImpl(map);
 /** @internal */
-const exitZipWith = /*#__PURE__*/dual(3, (self, that, {
-  onFailure,
-  onSuccess
-}) => {
-  switch (self._tag) {
-    case OP_FAILURE:
-      {
-        switch (that._tag) {
-          case OP_SUCCESS:
-            return exitFailCause(self.effect_instruction_i0);
-          case OP_FAILURE:
-            {
-              return exitFailCause(onFailure(self.effect_instruction_i0, that.effect_instruction_i0));
-            }
-        }
-      }
-    case OP_SUCCESS:
-      {
-        switch (that._tag) {
-          case OP_SUCCESS:
-            return exitSucceed(onSuccess(self.effect_instruction_i0, that.effect_instruction_i0));
-          case OP_FAILURE:
-            return exitFailCause(that.effect_instruction_i0);
-        }
-      }
-  }
-});
-const exitCollectAllInternal = (exits, combineCauses) => {
-  const list = fromIterable$4(exits);
-  if (!isNonEmpty$2(list)) {
-    return none$4();
-  }
-  return pipe(tailNonEmpty(list), reduce$4(pipe(headNonEmpty(list), exitMap(of$2)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
-    onSuccess: (list, value) => pipe(list, prepend$1(value)),
-    onFailure: combineCauses
-  }))), exitMap(reverse$1), exitMap(chunk => toReadonlyArray(chunk)), some);
-};
-// -----------------------------------------------------------------------------
-// Deferred
-// -----------------------------------------------------------------------------
+const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$1(that.map, self.map, (map, value, key) => set$2(map, key, match$6(get$4(map, key), {
+  onNone: () => empty$b(),
+  onSome: a => appendAll$1(a, value)
+}))));
 /** @internal */
-const deferredUnsafeMake = fiberId => {
-  const _deferred = {
-    ...CommitPrototype,
-    [DeferredTypeId]: deferredVariance,
-    state: make$q(pending([])),
-    commit() {
-      return deferredAwait(this);
-    },
-    blockingOn: fiberId
-  };
-  return _deferred;
-};
-/* @internal */
-const deferredMake = () => flatMap$3(fiberId, id => deferredMakeAs(id));
-/* @internal */
-const deferredMakeAs = fiberId => sync$2(() => deferredUnsafeMake(fiberId));
-/* @internal */
-const deferredAwait = self => asyncInterrupt(resume => {
-  const state = get$6(self.state);
-  switch (state._tag) {
-    case OP_STATE_DONE$1:
-      {
-        return resume(state.effect);
-      }
-    case OP_STATE_PENDING:
-      {
-        // we can push here as the internal state is mutable
-        state.joiners.push(resume);
-        return deferredInterruptJoiner(self, resume);
-      }
-  }
-}, self.blockingOn);
-/* @internal */
-const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync$2(() => {
-  const state = get$6(self.state);
-  switch (state._tag) {
-    case OP_STATE_DONE$1:
-      {
-        return false;
-      }
-    case OP_STATE_PENDING:
-      {
-        set$4(self.state, done$4(effect));
-        for (let i = 0, len = state.joiners.length; i < len; i++) {
-          state.joiners[i](effect);
-        }
-        return true;
-      }
-  }
-}));
-/* @internal */
-const deferredDone = /*#__PURE__*/dual(2, (self, exit) => deferredCompleteWith(self, exit));
-/* @internal */
-const deferredFailCause = /*#__PURE__*/dual(2, (self, cause) => deferredCompleteWith(self, failCause$6(cause)));
-/* @internal */
-const deferredInterruptWith = /*#__PURE__*/dual(2, (self, fiberId) => deferredCompleteWith(self, interruptWith(fiberId)));
-/* @internal */
-const deferredIsDone = self => sync$2(() => get$6(self.state)._tag === OP_STATE_DONE$1);
-/* @internal */
-const deferredSucceed = /*#__PURE__*/dual(2, (self, value) => deferredCompleteWith(self, succeed$4(value)));
-/** @internal */
-const deferredUnsafeDone = (self, effect) => {
-  const state = get$6(self.state);
-  if (state._tag === OP_STATE_PENDING) {
-    set$4(self.state, done$4(effect));
-    for (let i = 0, len = state.joiners.length; i < len; i++) {
-      state.joiners[i](effect);
-    }
-  }
-};
-const deferredInterruptJoiner = (self, joiner) => sync$2(() => {
-  const state = get$6(self.state);
-  if (state._tag === OP_STATE_PENDING) {
-    const index = state.joiners.indexOf(joiner);
-    if (index >= 0) {
-      // we can splice here as the internal state is mutable
-      state.joiners.splice(index, 1);
-    }
-  }
-});
-// -----------------------------------------------------------------------------
-// Context
-// -----------------------------------------------------------------------------
-const constContext = /*#__PURE__*/withFiberRuntime$1(fiber => exitSucceed(fiber.currentContext));
-/* @internal */
-const context = () => constContext;
-/* @internal */
-const contextWithEffect = f => flatMap$3(context(), f);
-/* @internal */
-const provideContext = /*#__PURE__*/dual(2, (self, context) => fiberRefLocally(currentContext, context)(self));
-/* @internal */
-const provideSomeContext = /*#__PURE__*/dual(2, (self, context) => fiberRefLocallyWith(currentContext, parent => merge$1(parent, context))(self));
-/* @internal */
-const mapInputContext = /*#__PURE__*/dual(2, (self, f) => contextWithEffect(context => provideContext(self, f(context))));
-// -----------------------------------------------------------------------------
-// Tracing
-// -----------------------------------------------------------------------------
+const sequentialCollectionKeys = self => Array.from(keys(self.map));
 /** @internal */
-const currentSpanFromFiber = fiber => {
-  const span = fiber.currentSpan;
-  return span !== undefined && span._tag === "Span" ? some(span) : none$4();
-};
+const sequentialCollectionToChunk = self => Array.from(self.map);
 
 /**
  * Creates a new `Deferred`.
@@ -3041,12 +952,12 @@ const empty$8 = () => {
  */
 const get$3 = /*#__PURE__*/dual(2, (self, key) => {
   if (isEqual(key) === false) {
-    return self.referential.has(key) ? some(self.referential.get(key)) : none$4();
+    return self.referential.has(key) ? some(self.referential.get(key)) : none$1();
   }
   const hash = key[symbol$1]();
   const bucket = self.buckets.get(hash);
   if (bucket === undefined) {
-    return none$4();
+    return none$1();
   }
   return getFromBucket(self, bucket, key);
 });
@@ -3061,7 +972,7 @@ const getFromBucket = (self, bucket, key, remove = false) => {
       return some(value);
     }
   }
-  return none$4();
+  return none$1();
 };
 /**
  * @since 2.0.0
@@ -3340,13 +1251,13 @@ const offer$2 = /*#__PURE__*/dual(2, (self, value) => {
 const offerAll = /*#__PURE__*/dual(2, (self, values) => {
   const iterator = values[Symbol.iterator]();
   let next;
-  let remainder = empty$g();
+  let remainder = empty$b();
   let offering = true;
   while (offering && (next = iterator.next()) && !next.done) {
     offering = offer$2(next.value)(self);
   }
   while (next != null && !next.done) {
-    remainder = prepend$1(next.value)(remainder);
+    remainder = prepend(next.value)(remainder);
     next = iterator.next();
   }
   return reverse$1(remainder);
@@ -3375,14 +1286,14 @@ const poll = /*#__PURE__*/dual(2, (self, def) => {
  * @since 2.0.0
  */
 const pollUpTo = /*#__PURE__*/dual(2, (self, n) => {
-  let result = empty$g();
+  let result = empty$b();
   let count = 0;
   while (count < n) {
     const element = poll(EmptyMutableQueue)(self);
     if (element === EmptyMutableQueue) {
       break;
     }
-    result = prepend$1(element)(result);
+    result = prepend(element)(result);
     count += 1;
   }
   return reverse$1(result);
@@ -3645,13 +1556,13 @@ const patch$3 = /*#__PURE__*/dual(2, (path, patch) => {
         }
       case "MapName":
         {
-          output = map$a(output, patch.f);
+          output = map$8(output, patch.f);
           input = input.tail;
           break;
         }
       case "Nested":
         {
-          output = prepend$2(output, patch.name);
+          output = prepend$1(output, patch.name);
           input = input.tail;
           break;
         }
@@ -3659,7 +1570,7 @@ const patch$3 = /*#__PURE__*/dual(2, (path, patch) => {
         {
           const containsName = pipe(head(output), contains(patch.name));
           if (containsName) {
-            output = tailNonEmpty$1(output);
+            output = tailNonEmpty(output);
             input = input.tail;
           } else {
             return left(MissingData(output, `Expected ${patch.name} to be in path in ConfigProvider#unnested`));
@@ -3722,8 +1633,8 @@ const makeFlat = options => ({
 });
 /** @internal */
 const fromFlat = flat => make$h({
-  load: config => flatMap$3(fromFlatLoop(flat, empty$j(), config, false), chunk => match$6(head(chunk), {
-    onNone: () => fail$4(MissingData(empty$j(), `Expected a single value having structure: ${config}`)),
+  load: config => flatMap$3(fromFlatLoop(flat, empty$c(), config, false), chunk => match$6(head(chunk), {
+    onNone: () => fail$4(MissingData(empty$c(), `Expected a single value having structure: ${config}`)),
     onSome: succeed$4
   })),
   flattened: flat
@@ -3743,7 +1654,7 @@ const fromEnv = options => {
   const load = (path, primitive, split = true) => {
     const pathString = makePathString(path);
     const current = getEnv();
-    const valueOpt = pathString in current ? some(current[pathString]) : none$4();
+    const valueOpt = pathString in current ? some(current[pathString]) : none$1();
     return pipe(valueOpt, mapError$1(() => MissingData(path, `Expected ${pathString} to exist in the process context`)), flatMap$3(value => parsePrimitive(value, path, primitive, seqDelim, split)));
   };
   const enumerateChildren = path => sync$2(() => {
@@ -3760,7 +1671,7 @@ const fromEnv = options => {
       }
       return true;
     }).flatMap(keyPath => keyPath.slice(path.length, path.length + 1));
-    return fromIterable$5(filteredKeyPaths);
+    return fromIterable$3(filteredKeyPaths);
   });
   return fromFlat(makeFlat({
     load,
@@ -3769,8 +1680,8 @@ const fromEnv = options => {
   }));
 };
 const extend$1 = (leftDef, rightDef, left, right) => {
-  const leftPad = unfold$1(left.length, index => index >= right.length ? none$4() : some([leftDef(index), index + 1]));
-  const rightPad = unfold$1(right.length, index => index >= left.length ? none$4() : some([rightDef(index), index + 1]));
+  const leftPad = unfold$1(left.length, index => index >= right.length ? none$1() : some([leftDef(index), index + 1]));
+  const rightPad = unfold$1(right.length, index => index >= left.length ? none$1() : some([rightDef(index), index + 1]));
   const leftExtension = concat(left, leftPad);
   const rightExtension = concat(right, rightPad);
   return [leftExtension, rightExtension];
@@ -3837,12 +1748,12 @@ const fromFlatLoop = (flat, prefix, config, split) => {
       {
         return pipe(patch$3(prefix, flat.patch), flatMap$3(patchedPrefix => pipe(flat.enumerateChildren(patchedPrefix), flatMap$3(indicesFrom), flatMap$3(indices => {
           if (indices.length === 0) {
-            return suspend$3(() => map$6(fromFlatLoop(flat, prefix, op.config, true), of$3));
+            return suspend$3(() => map$9(fromFlatLoop(flat, prefix, op.config, true), of$3));
           }
-          return pipe(forEachSequential(indices, index => fromFlatLoop(flat, append$2(prefix, `[${index}]`), op.config, true)), map$6(chunkChunk => {
-            const flattened = flatten$5(chunkChunk);
+          return pipe(forEachSequential(indices, index => fromFlatLoop(flat, append$2(prefix, `[${index}]`), op.config, true)), map$9(chunkChunk => {
+            const flattened = flatten$4(chunkChunk);
             if (flattened.length === 0) {
-              return of$3(empty$j());
+              return of$3(empty$c());
             }
             return of$3(flattened);
           }));
@@ -3851,11 +1762,11 @@ const fromFlatLoop = (flat, prefix, config, split) => {
     case OP_HASHMAP:
       {
         return suspend$3(() => pipe(patch$3(prefix, flat.patch), flatMap$3(prefix => pipe(flat.enumerateChildren(prefix), flatMap$3(keys => {
-          return pipe(keys, forEachSequential(key => fromFlatLoop(flat, concat(prefix, of$3(key)), op.valueConfig, split)), map$6(matrix => {
+          return pipe(keys, forEachSequential(key => fromFlatLoop(flat, concat(prefix, of$3(key)), op.valueConfig, split)), map$9(matrix => {
             if (matrix.length === 0) {
-              return of$3(empty$e());
+              return of$3(empty$a());
             }
-            return pipe(transpose(matrix), map$a(values => fromIterable$1(zip$4(fromIterable$3(keys), values))));
+            return pipe(transpose(matrix), map$8(values => fromIterable$1(zip$3(fromIterable$2(keys), values))));
           }));
         })))));
       }
@@ -3874,8 +1785,8 @@ const fromFlatLoop = (flat, prefix, config, split) => {
           if (isRight(left) && isRight(right$1)) {
             const path = pipe(prefix, join$2("."));
             const fail = fromFlatLoopFail(prefix, path);
-            const [lefts, rights] = extend$1(fail, fail, pipe(left.right, map$a(right)), pipe(right$1.right, map$a(right)));
-            return pipe(lefts, zip$4(rights), forEachSequential(([left, right]) => pipe(zip$3(left, right), map$6(([left, right]) => op.zip(left, right)))));
+            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$4(left, right), map$9(([left, right]) => op.zip(left, right)))));
           }
           throw new Error("BUG: ConfigProvider.fromFlatLoop - please report an issue at https://github.com/Effect-TS/effect/issues");
         })))));
@@ -3900,21 +1811,21 @@ 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$j(),
+  onFailure: () => empty$c(),
   onSuccess: sort(Order$1)
-}), either, map$6(merge$2));
+}), either, map$9(merge$1));
 const QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/;
 const parseQuotedIndex = str => {
   const match = str.match(QUOTED_INDEX_REGEX);
   if (match !== null) {
     const matchedIndex = match[2];
-    return pipe(matchedIndex !== undefined && matchedIndex.length > 0 ? some(matchedIndex) : none$4(), flatMap$4(parseInteger));
+    return pipe(matchedIndex !== undefined && matchedIndex.length > 0 ? some(matchedIndex) : none$1(), flatMap$4(parseInteger));
   }
-  return none$4();
+  return none$1();
 };
 const parseInteger = str => {
   const parsedIndex = Number.parseInt(str);
-  return Number.isNaN(parsedIndex) ? none$4() : some(parsedIndex);
+  return Number.isNaN(parsedIndex) ? none$1() : some(parsedIndex);
 };
 
 /** @internal */
@@ -4026,13 +1937,13 @@ class RandomImpl {
     return sync$2(() => this.PRNG.number());
   }
   get nextBoolean() {
-    return map$6(this.next, n => n > 0.5);
+    return map$9(this.next, n => n > 0.5);
   }
   get nextInt() {
     return sync$2(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER));
   }
   nextRange(min, max) {
-    return map$6(this.next, n => (max - min) * n + min);
+    return map$9(this.next, n => (max - min) * n + min);
   }
   nextIntBetween(min, max) {
     return sync$2(() => this.PRNG.integer(max - min) + min);
@@ -4047,7 +1958,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$6(k => swap(buffer, n - 1, k)))), as$1(fromIterable$4(buffer)));
+    return pipe(numbers, forEachSequentialDiscard(n => pipe(nextIntBounded(n), map$9(k => swap(buffer, n - 1, k)))), as$1(fromIterable$4(buffer)));
   })));
 };
 const swap = (buffer, index1, index2) => {
@@ -4143,7 +2054,7 @@ const DisablePropagation = /*#__PURE__*/Reference()("effect/Tracer/DisablePropag
 });
 
 /** @internal */
-const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$i(), /*#__PURE__*/add$1(clockTag, /*#__PURE__*/make$i()), /*#__PURE__*/add$1(consoleTag, defaultConsole), /*#__PURE__*/add$1(randomTag, /*#__PURE__*/make$g(/*#__PURE__*/Math.random())), /*#__PURE__*/add$1(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add$1(tracerTag, nativeTracer));
+const liveServices = /*#__PURE__*/pipe(/*#__PURE__*/empty$d(), /*#__PURE__*/add(clockTag, /*#__PURE__*/make$i()), /*#__PURE__*/add(consoleTag, defaultConsole), /*#__PURE__*/add(randomTag, /*#__PURE__*/make$g(/*#__PURE__*/Math.random())), /*#__PURE__*/add(configProviderTag, /*#__PURE__*/fromEnv()), /*#__PURE__*/add(tracerTag, nativeTracer));
 /**
  * The `FiberRef` holding the default `Effect` services.
  *
@@ -4205,11 +2116,11 @@ const findAncestor = (_ref, _parentStack, _childStack, _childModified = false) =
   let ret = undefined;
   while (ret === undefined) {
     if (isNonEmptyReadonlyArray(parentStack) && isNonEmptyReadonlyArray(childStack)) {
-      const parentFiberId = headNonEmpty$1(parentStack)[0];
-      const parentAncestors = tailNonEmpty$1(parentStack);
-      const childFiberId = headNonEmpty$1(childStack)[0];
-      const childRefValue = headNonEmpty$1(childStack)[1];
-      const childAncestors = tailNonEmpty$1(childStack);
+      const parentFiberId = headNonEmpty(parentStack)[0];
+      const parentAncestors = tailNonEmpty(parentStack);
+      const childFiberId = headNonEmpty(childStack)[0];
+      const childRefValue = headNonEmpty(childStack)[1];
+      const childAncestors = tailNonEmpty(childStack);
       if (parentFiberId.startTimeMillis < childFiberId.startTimeMillis) {
         childStack = childAncestors;
         childModified = true;
@@ -4291,9 +2202,9 @@ const delete_ = /*#__PURE__*/dual(2, (self, fiberRef) => {
 /** @internal */
 const get$2 = /*#__PURE__*/dual(2, (self, fiberRef) => {
   if (!self.locals.has(fiberRef)) {
-    return none$4();
+    return none$1();
   }
-  return some(headNonEmpty$1(self.locals.get(fiberRef))[1]);
+  return some(headNonEmpty(self.locals.get(fiberRef))[1]);
 });
 /** @internal */
 const getOrDefault$1 = /*#__PURE__*/dual(2, (self, fiberRef) => pipe(get$2(self, fiberRef), getOrElse(() => fiberRef.initial)));
@@ -4314,7 +2225,7 @@ const unsafeUpdateAs = (locals, fiberId, fiberRef, value) => {
   const oldStack = locals.get(fiberRef) ?? [];
   let newStack;
   if (isNonEmptyReadonlyArray(oldStack)) {
-    const [currentId, currentValue] = headNonEmpty$1(oldStack);
+    const [currentId, currentValue] = headNonEmpty(oldStack);
     if (currentId[symbol](fiberId)) {
       if (equals$1(currentValue, value)) {
         return;
@@ -4474,22 +2385,22 @@ class RefImpl extends Class {
   constructor(ref) {
     super();
     this.ref = ref;
-    this.get = sync$2(() => get$6(this.ref));
+    this.get = sync$2(() => get$5(this.ref));
   }
   get;
   modify(f) {
     return sync$2(() => {
-      const current = get$6(this.ref);
+      const current = get$5(this.ref);
       const [b, a] = f(current);
       if (current !== a) {
-        set$4(a)(this.ref);
+        set$3(a)(this.ref);
       }
       return b;
     });
   }
 }
 /** @internal */
-const unsafeMake$3 = value => new RefImpl(make$q(value));
+const unsafeMake$3 = value => new RefImpl(make$n(value));
 /** @internal */
 const make$e = value => sync$2(() => unsafeMake$3(value));
 /** @internal */
@@ -4541,10 +2452,10 @@ const diff$2 = (oldValue, newValue) => {
   const missingLocals = new Map(oldValue.locals);
   let patch = empty$3;
   for (const [fiberRef, pairs] of newValue.locals.entries()) {
-    const newValue = headNonEmpty$1(pairs)[1];
+    const newValue = headNonEmpty(pairs)[1];
     const old = missingLocals.get(fiberRef);
     if (old !== undefined) {
-      const oldValue = headNonEmpty$1(old)[1];
+      const oldValue = headNonEmpty(old)[1];
       if (!equals$1(oldValue, newValue)) {
         patch = combine$1({
           _tag: OP_UPDATE,
@@ -4580,8 +2491,8 @@ const patch$2 = /*#__PURE__*/dual(3, (self, fiberId, oldValue) => {
   let fiberRefs = oldValue;
   let patches = of$3(self);
   while (isNonEmptyReadonlyArray(patches)) {
-    const head = headNonEmpty$1(patches);
-    const tail = tailNonEmpty$1(patches);
+    const head = headNonEmpty(patches);
+    const tail = tailNonEmpty(patches);
     switch (head._tag) {
       case OP_EMPTY$1:
         {
@@ -4617,7 +2528,7 @@ const patch$2 = /*#__PURE__*/dual(3, (self, fiberId, oldValue) => {
         }
       case OP_AND_THEN$1:
         {
-          patches = prepend$2(head.first)(prepend$2(head.second)(tail));
+          patches = prepend$1(head.first)(prepend$1(head.second)(tail));
           break;
         }
     }
@@ -4658,7 +2569,7 @@ const make$c = (key, value) => {
 const isMetricLabel = u => hasProperty(u, MetricLabelTypeId);
 
 /* @internal */
-const asSome = self => map$6(self, some);
+const asSome = self => map$9(self, some);
 /* @internal */
 const catchSomeCause$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$1(self, {
   onFailure: cause => {
@@ -4701,19 +2612,19 @@ const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$1(self,
   onSuccess: succeed$4
 }));
 /* @internal */
-const negate = self => map$6(self, b => !b);
+const negate = self => map$9(self, b => !b);
 /* @internal */
 const patchFiberRefs = patch => updateFiberRefs((fiberId, fiberRefs) => pipe(patch, patch$2(fiberId, fiberRefs)));
 /* @internal */
-const provideService = /*#__PURE__*/dual(3, (self, tag, service) => contextWithEffect(env => provideContext(self, add$1(env, tag, service))));
+const provideService = /*#__PURE__*/dual(3, (self, tag, service) => contextWithEffect(env => provideContext(self, add(env, tag, service))));
 /* @internal */
-const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => contextWithEffect(env => flatMap$3(effect, service => provideContext(self, pipe(env, add$1(tag, service))))));
+const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => contextWithEffect(env => flatMap$3(effect, service => provideContext(self, pipe(env, add(tag, service))))));
 /* @internal */
 const sleep = sleep$1;
 /* @internal */
-const succeedNone = /*#__PURE__*/succeed$4(/*#__PURE__*/none$4());
+const succeedNone = /*#__PURE__*/succeed$4(/*#__PURE__*/none$1());
 /* @internal */
-const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap$3(summary, start => flatMap$3(self, value => map$6(summary, end => [f(start, end), value]))));
+const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap$3(summary, start => flatMap$3(self, value => map$9(summary, end => [f(start, end), value]))));
 /* @internal */
 const tapErrorCause$1 = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect$1(self, {
   onFailure: cause => zipRight$3(f(cause), failCause$6(cause)),
@@ -4725,8 +2636,8 @@ const updateFiberRefs = f => withFiberRuntime$1(state => {
   return void_$2;
 });
 /* @internal */
-const when$1 = /*#__PURE__*/dual(2, (self, condition) => suspend$3(() => condition() ? map$6(self, some) : succeed$4(none$4())));
-const filterDisablePropagation = /*#__PURE__*/flatMap$4(span => get$7(span.context, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(span.parent) : none$4() : some(span));
+const when$1 = /*#__PURE__*/dual(2, (self, condition) => suspend$3(() => condition() ? map$9(self, some) : succeed$4(none$1())));
+const filterDisablePropagation = /*#__PURE__*/flatMap$4(span => get$6(span.context, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(span.parent) : none$1() : some(span));
 
 /** @internal */
 const OP_SEQUENTIAL = "Sequential";
@@ -4821,7 +2732,7 @@ class Running {
     this.runtimeFlags = runtimeFlags;
   }
   [symbol$1]() {
-    return pipe(hash(FiberStatusSymbolKey), combine$7(hash(this._tag)), combine$7(hash(this.runtimeFlags)), cached(this));
+    return pipe(hash(FiberStatusSymbolKey), combine$2(hash(this._tag)), combine$2(hash(this.runtimeFlags)), cached(this));
   }
   [symbol](that) {
     return isFiberStatus(that) && that._tag === OP_RUNNING && this.runtimeFlags === that.runtimeFlags;
@@ -4838,7 +2749,7 @@ class Suspended {
     this.blockingOn = blockingOn;
   }
   [symbol$1]() {
-    return pipe(hash(FiberStatusSymbolKey), combine$7(hash(this._tag)), combine$7(hash(this.runtimeFlags)), combine$7(hash(this.blockingOn)), cached(this));
+    return pipe(hash(FiberStatusSymbolKey), combine$2(hash(this._tag)), combine$2(hash(this.runtimeFlags)), combine$2(hash(this.blockingOn)), cached(this));
   }
   [symbol](that) {
     return isFiberStatus(that) && that._tag === OP_SUSPENDED && this.runtimeFlags === that.runtimeFlags && equals$1(this.blockingOn, that.blockingOn);
@@ -5115,7 +3026,7 @@ const _await$1 = self => self.await;
 /** @internal */
 const inheritAll$1 = self => self.inheritAll;
 /** @internal */
-const join$1 = self => zipLeft$1(flatten$3(self.await), self.inheritAll);
+const join$1 = self => zipLeft$1(flatten$5(self.await), self.inheritAll);
 /** @internal */
 const currentFiberURI = "effect/FiberCurrent";
 
@@ -5129,7 +3040,7 @@ class MetricBoundariesImpl {
   [MetricBoundariesTypeId] = MetricBoundariesTypeId;
   constructor(values) {
     this.values = values;
-    this._hash = pipe(string(MetricBoundariesSymbolKey), combine$7(array(this.values)));
+    this._hash = pipe(string(MetricBoundariesSymbolKey), combine$2(array(this.values)));
   }
   _hash;
   [symbol$1]() {
@@ -5211,7 +3122,7 @@ class HistogramKeyType {
   [HistogramKeyTypeTypeId] = HistogramKeyTypeTypeId;
   constructor(boundaries) {
     this.boundaries = boundaries;
-    this._hash = pipe(string(HistogramKeyTypeSymbolKey), combine$7(hash(this.boundaries)));
+    this._hash = pipe(string(HistogramKeyTypeSymbolKey), combine$2(hash(this.boundaries)));
   }
   _hash;
   [symbol$1]() {
@@ -5249,7 +3160,7 @@ const metricKeyVariance = {
   /* c8 ignore next */
   _Type: _ => _
 };
-const arrayEquivilence = /*#__PURE__*/getEquivalence$1(equals$1);
+const arrayEquivilence = /*#__PURE__*/getEquivalence(equals$1);
 /** @internal */
 class MetricKeyImpl {
   name;
@@ -5262,7 +3173,7 @@ class MetricKeyImpl {
     this.keyType = keyType;
     this.description = description;
     this.tags = tags;
-    this._hash = pipe(string(this.name + this.description), combine$7(hash(this.keyType)), combine$7(array(this.tags)));
+    this._hash = pipe(string(this.name + this.description), combine$2(hash(this.keyType)), combine$2(array(this.tags)));
   }
   _hash;
   [symbol$1]() {
@@ -5321,7 +3232,7 @@ class CounterState {
     this.count = count;
   }
   [symbol$1]() {
-    return pipe(hash(CounterStateSymbolKey), combine$7(hash(this.count)), cached(this));
+    return pipe(hash(CounterStateSymbolKey), combine$2(hash(this.count)), cached(this));
   }
   [symbol](that) {
     return isCounterState(that) && this.count === that.count;
@@ -5330,7 +3241,7 @@ class CounterState {
     return pipeArguments(this, arguments);
   }
 }
-const arrayEquals = /*#__PURE__*/getEquivalence$1(equals$1);
+const arrayEquals = /*#__PURE__*/getEquivalence(equals$1);
 /** @internal */
 class FrequencyState {
   occurrences;
@@ -5341,10 +3252,10 @@ class FrequencyState {
   }
   _hash;
   [symbol$1]() {
-    return pipe(string(FrequencyStateSymbolKey), combine$7(array(fromIterable$3(this.occurrences.entries()))), cached(this));
+    return pipe(string(FrequencyStateSymbolKey), combine$2(array(fromIterable$2(this.occurrences.entries()))), cached(this));
   }
   [symbol](that) {
-    return isFrequencyState(that) && arrayEquals(fromIterable$3(this.occurrences.entries()), fromIterable$3(that.occurrences.entries()));
+    return isFrequencyState(that) && arrayEquals(fromIterable$2(this.occurrences.entries()), fromIterable$2(that.occurrences.entries()));
   }
   pipe() {
     return pipeArguments(this, arguments);
@@ -5359,7 +3270,7 @@ class GaugeState {
     this.value = value;
   }
   [symbol$1]() {
-    return pipe(hash(GaugeStateSymbolKey), combine$7(hash(this.value)), cached(this));
+    return pipe(hash(GaugeStateSymbolKey), combine$2(hash(this.value)), cached(this));
   }
   [symbol](u) {
     return isGaugeState(u) && this.value === u.value;
@@ -5385,7 +3296,7 @@ class HistogramState {
     this.sum = sum;
   }
   [symbol$1]() {
-    return pipe(hash(HistogramStateSymbolKey), combine$7(hash(this.buckets)), combine$7(hash(this.count)), combine$7(hash(this.min)), combine$7(hash(this.max)), combine$7(hash(this.sum)), cached(this));
+    return pipe(hash(HistogramStateSymbolKey), combine$2(hash(this.buckets)), combine$2(hash(this.count)), combine$2(hash(this.min)), combine$2(hash(this.max)), combine$2(hash(this.sum)), cached(this));
   }
   [symbol](that) {
     return isHistogramState(that) && equals$1(this.buckets, that.buckets) && this.count === that.count && this.min === that.min && this.max === that.max && this.sum === that.sum;
@@ -5413,7 +3324,7 @@ class SummaryState {
     this.sum = sum;
   }
   [symbol$1]() {
-    return pipe(hash(SummaryStateSymbolKey), combine$7(hash(this.error)), combine$7(hash(this.quantiles)), combine$7(hash(this.count)), combine$7(hash(this.min)), combine$7(hash(this.max)), combine$7(hash(this.sum)), cached(this));
+    return pipe(hash(SummaryStateSymbolKey), combine$2(hash(this.error)), combine$2(hash(this.quantiles)), combine$2(hash(this.count)), combine$2(hash(this.min)), combine$2(hash(this.max)), combine$2(hash(this.sum)), cached(this));
   }
   [symbol](that) {
     return isSummaryState(that) && this.error === that.error && equals$1(this.quantiles, that.quantiles) && this.count === that.count && this.min === that.min && this.max === that.max && this.sum === that.sum;
@@ -5535,7 +3446,7 @@ const histogram$1 = key => {
   let sum = 0;
   let min = Number.MAX_VALUE;
   let max = Number.MIN_VALUE;
-  pipe(bounds, sort(Order$1), map$a((n, i) => {
+  pipe(bounds, sort(Order$1), map$8((n, i) => {
     boundaries[i] = n;
   }));
   // Insert the value into the right bucket with a binary search
@@ -5665,16 +3576,16 @@ const calculateQuantiles = (error, sortedQuantiles, sortedSamples) => {
   // The number of samples examined
   const sampleCount = sortedSamples.length;
   if (!isNonEmptyReadonlyArray(sortedQuantiles)) {
-    return empty$j();
+    return empty$c();
   }
   const head = sortedQuantiles[0];
   const tail = sortedQuantiles.slice(1);
-  const resolvedHead = resolveQuantile(error, sampleCount, none$4(), 0, head, sortedSamples);
+  const resolvedHead = resolveQuantile(error, sampleCount, none$1(), 0, head, sortedSamples);
   const resolved = of$3(resolvedHead);
   tail.forEach(quantile => {
     resolved.push(resolveQuantile(error, sampleCount, resolvedHead.value, resolvedHead.consumed, quantile, resolvedHead.rest));
   });
-  return map$a(resolved, rq => [rq.quantile, rq.value]);
+  return map$8(resolved, rq => [rq.quantile, rq.value]);
 };
 /** @internal */
 const resolveQuantile = (error, sampleCount, current, consumed, quantile, rest) => {
@@ -5696,7 +3607,7 @@ const resolveQuantile = (error, sampleCount, current, consumed, quantile, rest)
     if (!isNonEmptyReadonlyArray(rest_1)) {
       return {
         quantile: quantile_1,
-        value: none$4(),
+        value: none$1(),
         consumed: consumed_1,
         rest: []
       };
@@ -5713,7 +3624,7 @@ const resolveQuantile = (error, sampleCount, current, consumed, quantile, rest)
     }
     // Split into two chunks - the first chunk contains all elements of the same
     // value as the chunk head
-    const headValue = headNonEmpty$1(rest_1); // Get head value since rest_1 is non-empty
+    const headValue = headNonEmpty(rest_1); // Get head value since rest_1 is non-empty
     const sameHead = span(rest_1, n => n === headValue);
     // How many elements do we want to accept for this quantile
     const desired = quantile_1 * sampleCount_1;
@@ -6033,7 +3944,7 @@ class ProxySupervisor {
     this.underlying.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$6(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$9(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -6050,7 +3961,7 @@ class Zip {
     this.right = right;
   }
   get value() {
-    return zip$3(this.left.value, this.right.value);
+    return zip$4(this.left.value, this.right.value);
   }
   onStart(context, effect, parent, fiber) {
     this.left.onStart(context, effect, parent, fiber);
@@ -6073,7 +3984,7 @@ class Zip {
     this.right.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$6(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$9(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -6107,7 +4018,7 @@ class Const {
     //
   }
   map(f) {
-    return new ProxySupervisor(this, pipe(this.value, map$6(f)));
+    return new ProxySupervisor(this, pipe(this.value, map$9(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -6129,7 +4040,7 @@ const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect
  * @since 2.0.0
  * @category constructors
  */
-const make$8 = make$n;
+const make$8 = make$o;
 
 /** @internal */
 const OP_EMPTY = "Empty";
@@ -6173,28 +4084,28 @@ const patchLoop = (_supervisor, _patches) => {
   let supervisor = _supervisor;
   let patches = _patches;
   while (isNonEmpty$2(patches)) {
-    const head = headNonEmpty(patches);
+    const head = headNonEmpty$1(patches);
     switch (head._tag) {
       case OP_EMPTY:
         {
-          patches = tailNonEmpty(patches);
+          patches = tailNonEmpty$1(patches);
           break;
         }
       case OP_ADD_SUPERVISOR:
         {
           supervisor = supervisor.zip(head.supervisor);
-          patches = tailNonEmpty(patches);
+          patches = tailNonEmpty$1(patches);
           break;
         }
       case OP_REMOVE_SUPERVISOR:
         {
           supervisor = removeSupervisor(supervisor, head.supervisor);
-          patches = tailNonEmpty(patches);
+          patches = tailNonEmpty$1(patches);
           break;
         }
       case OP_AND_THEN:
         {
-          patches = prepend$1(head.first)(prepend$1(head.second)(tailNonEmpty(patches)));
+          patches = prepend(head.first)(prepend(head.second)(tailNonEmpty$1(patches)));
           break;
         }
     }
@@ -6216,12 +4127,12 @@ const removeSupervisor = (self, that) => {
 /** @internal */
 const toSet = self => {
   if (equals$1(self, none)) {
-    return empty$k();
+    return empty$e();
   } else {
     if (isZip(self)) {
       return pipe(toSet(self.left), union$1(toSet(self.right)));
     } else {
-      return make$r(self);
+      return make$p(self);
     }
   }
 };
@@ -6232,11 +4143,11 @@ const diff = (oldValue, newValue) => {
   }
   const oldSupervisors = toSet(oldValue);
   const newSupervisors = toSet(newValue);
-  const added = pipe(newSupervisors, difference(oldSupervisors), reduce$3(empty$2, (patch, supervisor) => combine(patch, {
+  const added = pipe(newSupervisors, difference(oldSupervisors), reduce$2(empty$2, (patch, supervisor) => combine(patch, {
     _tag: OP_ADD_SUPERVISOR,
     supervisor
   })));
-  const removed = pipe(oldSupervisors, difference(newSupervisors), reduce$3(empty$2, (patch, supervisor) => combine(patch, {
+  const removed = pipe(oldSupervisors, difference(newSupervisors), reduce$2(empty$2, (patch, supervisor) => combine(patch, {
     _tag: OP_REMOVE_SUPERVISOR,
     supervisor
   })));
@@ -6301,7 +4212,7 @@ const contOpSuccess = {
   },
   [OP_REVERT_FLAGS]: (self, cont, value) => {
     self.patchRuntimeFlags(self.currentRuntimeFlags, cont.patch);
-    if (interruptible$2(self.currentRuntimeFlags) && self.isInterrupted()) {
+    if (interruptible$1(self.currentRuntimeFlags) && self.isInterrupted()) {
       return exitFailCause(self.getInterruptedCause());
     } else {
       return exitSucceed(value);
@@ -6336,7 +4247,7 @@ const contOpSuccess = {
 const drainQueueWhileRunningTable = {
   [OP_INTERRUPT_SIGNAL]: (self, runtimeFlags, cur, message) => {
     self.processNewInterruptSignal(message.cause);
-    return interruptible$2(runtimeFlags) ? exitFailCause(message.cause) : cur;
+    return interruptible$1(runtimeFlags) ? exitFailCause(message.cause) : cur;
   },
   [OP_RESUME]: (_self, _runtimeFlags, _cur, _message) => {
     throw new Error("It is illegal to have multiple concurrent run loops in a single fiber");
@@ -6352,7 +4263,7 @@ const drainQueueWhileRunningTable = {
 /**
  * Executes all requests, submitting requests to each data source in parallel.
  */
-const runBlockedRequests = self => forEachSequentialDiscard(flatten$4(self), requestsByRequestResolver => forEachConcurrentDiscard(sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
+const runBlockedRequests = self => forEachSequentialDiscard(flatten$3(self), requestsByRequestResolver => forEachConcurrentDiscard(sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
   const map = new Map();
   const arr = [];
   for (const block of sequential) {
@@ -6553,13 +4464,13 @@ class FiberRuntime extends Class {
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   interruptAsFork(fiberId) {
-    return sync$2(() => this.tell(interruptSignal(interrupt$4(fiberId))));
+    return sync$2(() => this.tell(interruptSignal(interrupt$3(fiberId))));
   }
   /**
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   unsafeInterruptAsFork(fiberId) {
-    this.tell(interruptSignal(interrupt$4(fiberId)));
+    this.tell(interruptSignal(interrupt$3(fiberId)));
   }
   /**
    * Adds an observer to the list of observers.
@@ -6753,7 +4664,7 @@ class FiberRuntime extends Class {
    * log annotations and log level) may not be up-to-date.
    */
   isInterrupted() {
-    return !isEmpty$6(this.getFiberRef(currentInterruptedCause));
+    return !isEmpty$5(this.getFiberRef(currentInterruptedCause));
   }
   /**
    * Adds an interruptor to the set of interruptors that are interrupting this
@@ -6787,7 +4698,7 @@ class FiberRuntime extends Class {
     }
     let told = false;
     for (const child of this._children) {
-      child.tell(interruptSignal(interrupt$4(this.id())));
+      child.tell(interruptSignal(interrupt$3(this.id())));
       told = true;
     }
     return told;
@@ -6873,7 +4784,7 @@ class FiberRuntime extends Class {
     const loggers = this.getLoggers();
     const contextMap = this.getFiberRefs();
     if (size$2(loggers) > 0) {
-      const clockService = get$7(this.getFiberRef(currentServices), clockTag);
+      const clockService = get$6(this.getFiberRef(currentServices), clockTag);
       const date = new Date(clockService.unsafeCurrentTimeMillis());
       withRedactableContext(contextMap, () => {
         for (const logger of loggers) {
@@ -6939,7 +4850,7 @@ class FiberRuntime extends Class {
   evaluateEffect(effect0) {
     this.currentSupervisor.onResume(this);
     try {
-      let effect = interruptible$2(this.currentRuntimeFlags) && this.isInterrupted() ? exitFailCause(this.getInterruptedCause()) : effect0;
+      let effect = interruptible$1(this.currentRuntimeFlags) && this.isInterrupted() ? exitFailCause(this.getInterruptedCause()) : effect0;
       while (effect !== null) {
         const eff = effect;
         const exit = this.runLoop(eff);
@@ -6959,7 +4870,7 @@ class FiberRuntime extends Class {
             effect = null;
           }
         } else {
-          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, enable$1(WindDown));
+          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, enable(WindDown));
           const interruption = this.interruptAllChildren();
           if (interruption !== null) {
             effect = flatMap$3(interruption, () => exit);
@@ -7048,13 +4959,13 @@ class FiberRuntime extends Class {
         this.tell(resume(effect));
       }
     };
-    if (interruptible$2(runtimeFlags)) {
+    if (interruptible$1(runtimeFlags)) {
       this._asyncInterruptor = callback;
     }
     try {
       asyncRegister(callback);
     } catch (e) {
-      callback(failCause$6(die$3(e)));
+      callback(failCause$6(die$2(e)));
     }
   }
   pushStack(cont) {
@@ -7120,7 +5031,7 @@ class FiberRuntime extends Class {
         switch (exit.cause._tag) {
           case "Interrupt":
             {
-              return resume(exitFailCause(interrupt$4(none$2)));
+              return resume(exitFailCause(interrupt$3(none$2)));
             }
           case "Fail":
             {
@@ -7128,7 +5039,7 @@ class FiberRuntime extends Class {
             }
           case "Die":
             {
-              return resume(die$2(exit.cause.defect));
+              return resume(die$3(exit.cause.defect));
             }
         }
       });
@@ -7178,7 +5089,7 @@ class FiberRuntime extends Class {
         case OP_ON_FAILURE:
         case OP_ON_SUCCESS_AND_FAILURE:
           {
-            if (!(interruptible$2(this.currentRuntimeFlags) && this.isInterrupted())) {
+            if (!(interruptible$1(this.currentRuntimeFlags) && this.isInterrupted())) {
               return internalCall(() => cont.effect_instruction_i1(cause));
             } else {
               return exitFailCause(stripFailures(cause));
@@ -7186,7 +5097,7 @@ class FiberRuntime extends Class {
           }
         case "OnStep":
           {
-            if (!(interruptible$2(this.currentRuntimeFlags) && this.isInterrupted())) {
+            if (!(interruptible$1(this.currentRuntimeFlags) && this.isInterrupted())) {
               return exitSucceed(exitFailCause(cause));
             } else {
               return exitFailCause(stripFailures(cause));
@@ -7195,7 +5106,7 @@ class FiberRuntime extends Class {
         case OP_REVERT_FLAGS:
           {
             this.patchRuntimeFlags(this.currentRuntimeFlags, cont.patch);
-            if (interruptible$2(this.currentRuntimeFlags) && this.isInterrupted()) {
+            if (interruptible$1(this.currentRuntimeFlags) && this.isInterrupted()) {
               return exitFailCause(sequential$2(cause, this.getInterruptedCause()));
             } else {
               return exitFailCause(cause);
@@ -7251,7 +5162,7 @@ class FiberRuntime extends Class {
     // to interrupt. Interruption will cause immediate reversion of
     // the flag, so as long as we "peek ahead", there's no need to
     // set them to begin with.
-    if (interruptible$2(newRuntimeFlags) && this.isInterrupted()) {
+    if (interruptible$1(newRuntimeFlags) && this.isInterrupted()) {
       return exitFailCause(this.getInterruptedCause());
     } else {
       // Impossible to short circuit, so record the changes
@@ -7343,7 +5254,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$h, 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$f, level);
             }
           }
           // @ts-expect-error
@@ -7355,15 +5266,15 @@ class FiberRuntime extends Class {
             return YieldedOp;
           }
           yieldedOpChannel.currentOp = null;
-          return op._op === OP_SUCCESS || op._op === OP_FAILURE ? op : exitFailCause(die$3(op));
+          return op._op === OP_SUCCESS || op._op === OP_FAILURE ? op : exitFailCause(die$2(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(sequential$2(die$3(e), interrupt$4(none$2)));
+          cur = exitFailCause(sequential$2(die$2(e), interrupt$3(none$2)));
         } else {
-          cur = die$2(e);
+          cur = die$3(e);
         }
       }
     }
@@ -7378,7 +5289,7 @@ const currentMinimumLogLevel = /*#__PURE__*/globalValue("effect/FiberRef/current
 /** @internal */
 const loggerWithConsoleLog = self => makeLogger(opts => {
   const services = getOrDefault(opts.context, currentServices);
-  get$7(services, consoleTag).unsafe.log(self.log(opts));
+  get$6(services, consoleTag).unsafe.log(self.log(opts));
 });
 /** @internal */
 const defaultLogger = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/Logger/defaultLogger"), () => loggerWithConsoleLog(stringLogger));
@@ -7410,11 +5321,11 @@ 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$r(defaultLogger, tracerLogger)));
+const currentLoggers = /*#__PURE__*/globalValue(/*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make$p(defaultLogger, tracerLogger)));
 // === all
 const allResolveInput = input => {
   if (Array.isArray(input) || isIterable(input)) {
-    return [input, none$4()];
+    return [input, none$1()];
   }
   const keys = Object.keys(input);
   const size = keys.length;
@@ -7436,7 +5347,7 @@ const allValidate = (effects, reconcile, options) => {
     batching: options?.batching,
     concurrentFinalizers: options?.concurrentFinalizers
   }), eithers => {
-    const none = none$4();
+    const none = none$1();
     const size = eithers.length;
     const errors = new Array(size);
     const successes = new Array(size);
@@ -7472,7 +5383,7 @@ const allEither = (effects, reconcile, options) => {
       concurrentFinalizers: options?.concurrentFinalizers
     });
   }
-  return map$6(forEach$1(eitherEffects, identity, {
+  return map$9(forEach$1(eitherEffects, identity, {
     concurrency: options?.concurrency,
     batching: options?.batching,
     concurrentFinalizers: options?.concurrentFinalizers
@@ -7486,7 +5397,7 @@ const all$1 = (arg, options) => {
   } else if (options?.mode === "either") {
     return allEither(effects, reconcile, options);
   }
-  return options?.discard !== true && reconcile._tag === "Some" ? map$6(forEach$1(effects, identity, options), reconcile.value) : forEach$1(effects, identity, options);
+  return options?.discard !== true && reconcile._tag === "Some" ? map$9(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 => {
@@ -7498,7 +5409,7 @@ const forEach$1 = /*#__PURE__*/dual(args => isIterable(args[0]), (self, f, optio
 }));
 /* @internal */
 const forEachParUnbounded = (self, f, batching) => suspend$3(() => {
-  const as = fromIterable$3(self);
+  const as = fromIterable$2(self);
   const array = new Array(as.length);
   const fn = (a, i) => flatMap$3(f(a, i), b => sync$2(() => array[i] = b));
   return zipRight$3(forEachConcurrentDiscard(as, fn, batching, false), succeed$4(array));
@@ -7553,7 +5464,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
     interrupted = true;
     interruptAll();
   };
-  const stepOrExit = batching ? step : exit$1;
+  const stepOrExit = batching ? step$1 : exit$1;
   const processingFiber = runFiber(async_(resume => {
     const pushResult = (res, index) => {
       if (res._op === "Blocked") {
@@ -7625,7 +5536,7 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
       next();
     }
   }));
-  return asVoid$1(onExit(flatten$3(restore(join$1(processingFiber))), exitMatch({
+  return asVoid$1(onExit(flatten$5(restore(join$1(processingFiber))), exitMatch({
     onFailure: cause => {
       onInterruptSignal();
       const target = residual.length + 1;
@@ -7659,9 +5570,9 @@ const forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterru
 })));
 /* @internal */
 const forEachParN = (self, n, f, batching) => suspend$3(() => {
-  const as = fromIterable$3(self);
+  const as = fromIterable$2(self);
   const array = new Array(as.length);
-  const fn = (a, i) => map$6(f(a, i), b => array[i] = b);
+  const fn = (a, i) => map$9(f(a, i), b => array[i] = b);
   return zipRight$3(forEachConcurrentDiscard(as, fn, batching, false, n), succeed$4(array));
 });
 /* @internal */
@@ -7769,7 +5680,7 @@ const zipRightOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, th
   return zipWithOptions(self, that, (_, b) => b, options);
 });
 /** @internal */
-const zipWithOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, that, f, options) => map$6(all$1([self, that], {
+const zipWithOptions = /*#__PURE__*/dual(args => isEffect$1(args[1]), (self, that, f, options) => map$9(all$1([self, that], {
   concurrency: options?.concurrent ? 2 : 1,
   batching: options?.batching,
   concurrentFinalizers: options?.concurrentFinalizers
@@ -7821,11 +5732,11 @@ const ScopeImplProto = {
       if (finalizers.length === 0) {
         return void_$2;
       }
-      return isSequential(this.strategy) ? pipe(forEachSequential(finalizers, fin => exit$1(fin(exit))), flatMap$3(results => pipe(exitCollectAll(results), map$9(exitAsVoid), getOrElse(() => exitVoid)))) : isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit$1(fin(exit)), false), flatMap$3(results => pipe(exitCollectAll(results, {
+      return isSequential(this.strategy) ? pipe(forEachSequential(finalizers, fin => exit$1(fin(exit))), flatMap$3(results => pipe(exitCollectAll(results), map$6(exitAsVoid), getOrElse(() => exitVoid)))) : isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit$1(fin(exit)), false), flatMap$3(results => pipe(exitCollectAll(results, {
         parallel: true
-      }), map$9(exitAsVoid), getOrElse(() => exitVoid)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => exit$1(fin(exit)), false), flatMap$3(results => pipe(exitCollectAll(results, {
+      }), map$6(exitAsVoid), getOrElse(() => exitVoid)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, fin => exit$1(fin(exit)), false), flatMap$3(results => pipe(exitCollectAll(results, {
         parallel: true
-      }), map$9(exitAsVoid), getOrElse(() => exitVoid))));
+      }), map$6(exitAsVoid), getOrElse(() => exitVoid))));
     });
   },
   addFinalizer(fin) {
@@ -7852,7 +5763,7 @@ const scopeMake = (strategy = sequential$1) => sync$2(() => scopeUnsafeMake(stra
 /* @internal */
 const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => mapInputContext(effect,
 // @ts-expect-error
-merge$1(make$s(scopeTag, scope))));
+merge$2(make$q(scopeTag, scope))));
 // circular with Supervisor
 /** @internal */
 const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial, {
@@ -7860,7 +5771,7 @@ const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial,
   fork: empty$2
 });
 /** @internal */
-const currentRuntimeFlags = /*#__PURE__*/fiberRefUnsafeMakeRuntimeFlags(none$1);
+const currentRuntimeFlags = /*#__PURE__*/fiberRefUnsafeMakeRuntimeFlags(none$3);
 /** @internal */
 const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none);
 //
@@ -7907,7 +5818,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$q(true);
+  const raceIndicator = make$n(true);
   const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
   const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
   return async_(cb => {
@@ -7915,7 +5826,7 @@ const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberR
     rightFiber.addObserver(() => completeRace(rightFiber, leftFiber, options.onOtherWin, raceIndicator, cb));
     leftFiber.startFork(self);
     rightFiber.startFork(other);
-  }, combine$5(leftFiber.id(), rightFiber.id()));
+  }, combine$3(leftFiber.id(), rightFiber.id()));
 }));
 const completeRace = (winner, loser, cont, ab, cb) => {
   if (compareAndSet(true, false)(ab)) {
@@ -7931,7 +5842,7 @@ const ensuring$3 = /*#__PURE__*/dual(2, (self, finalizer) => uninterruptibleMask
   onSuccess: a => as$1(finalizer, a)
 })));
 /** @internal */
-const invokeWithInterrupt = (self, entries, onInterrupt) => fiberIdWith$1(id => ensuring$3(flatMap$3(forkDaemon$1(interruptible$1(self)), processing => async_(cb => {
+const invokeWithInterrupt = (self, entries, onInterrupt) => fiberIdWith$1(id => ensuring$3(flatMap$3(forkDaemon$1(interruptible$2(self)), processing => async_(cb => {
   const counts = entries.map(_ => _.listeners.count);
   const checkDone = () => {
     if (counts.every(count => count === 0)) {
@@ -8005,7 +5916,7 @@ const fail$2 = fail$5;
  * @since 2.0.0
  * @category Constructors
  */
-const die = die$3;
+const die = die$2;
 /**
  * Creates an `Interrupt` cause from a `FiberId`.
  *
@@ -8020,7 +5931,7 @@ const die = die$3;
  * @since 2.0.0
  * @category Constructors
  */
-const interrupt$2 = interrupt$4;
+const interrupt$2 = interrupt$3;
 /**
  * Checks if a `Cause` is a `Die` type.
  *
@@ -8109,7 +6020,7 @@ const flipCauseOption = flipCauseOption$1;
  * @since 2.0.0
  * @category Mapping
  */
-const map$4 = map$b;
+const map$4 = map$a;
 
 /** @internal */
 const IntervalSymbolKey = "effect/ScheduleInterval";
@@ -8209,19 +6120,19 @@ const make$6 = intervals => {
   };
 };
 /** @internal */
-const intersect$2 = /*#__PURE__*/dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$g()));
+const intersect$2 = /*#__PURE__*/dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty$b()));
 /** @internal */
 const intersectLoop = (_left, _right, _acc) => {
   let left = _left;
   let right = _right;
   let acc = _acc;
   while (isNonEmpty$2(left) && isNonEmpty$2(right)) {
-    const interval = pipe(headNonEmpty(left), intersect$3(headNonEmpty(right)));
-    const intervals = isEmpty(interval) ? acc : pipe(acc, prepend$1(interval));
-    if (pipe(headNonEmpty(left), lessThan$2(headNonEmpty(right)))) {
-      left = tailNonEmpty(left);
+    const interval = pipe(headNonEmpty$1(left), intersect$3(headNonEmpty$1(right)));
+    const intervals = isEmpty(interval) ? acc : pipe(acc, prepend(interval));
+    if (pipe(headNonEmpty$1(left), lessThan$2(headNonEmpty$1(right)))) {
+      left = tailNonEmpty$1(left);
     } else {
-      right = tailNonEmpty(right);
+      right = tailNonEmpty$1(right);
     }
     acc = intervals;
   }
@@ -8493,7 +6404,7 @@ const forkIn$1 = /*#__PURE__*/dual(2, (self, scope) => withFiberRuntime$1((paren
   return succeed$4(fiber);
 }));
 /** @internal */
-const raceFirst$1 = /*#__PURE__*/dual(2, (self, that) => pipe(exit$1(self), race$1(exit$1(that)), effect => flatten$3(effect)));
+const raceFirst$1 = /*#__PURE__*/dual(2, (self, that) => pipe(exit$1(self), race$1(exit$1(that)), effect => flatten$5(effect)));
 // circular with Synchronized
 /** @internal */
 const SynchronizedSymbolKey = "effect/Ref/SynchronizedRef";
@@ -8615,7 +6526,7 @@ const unsafeFork = /*#__PURE__*/makeDual((runtime, self, options) => {
   const supervisor = fiberRuntime.currentSupervisor;
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
   if (supervisor !== none) {
-    supervisor.onStart(runtime.context, effect, none$4(), fiberRuntime);
+    supervisor.onStart(runtime.context, effect, none$1(), fiberRuntime);
     fiberRuntime.addObserver(exit => supervisor.onEnd(exit, fiberRuntime));
   }
   globalScope.add(runtime.runtimeFlags, fiberRuntime);
@@ -8749,10 +6660,10 @@ const make$3 = options => new RuntimeImpl(options.context, options.runtimeFlags,
 /** @internal */
 const runtime$1 = () => withFiberRuntime$1((state, status) => succeed$4(new RuntimeImpl(state.getFiberRef(currentContext), status.runtimeFlags, state.getFiberRefs())));
 /** @internal */
-const defaultRuntimeFlags = /*#__PURE__*/make$l(Interruption, CooperativeYielding, RuntimeMetrics);
+const defaultRuntimeFlags = /*#__PURE__*/make$r(Interruption, CooperativeYielding, RuntimeMetrics);
 /** @internal */
 const defaultRuntime = /*#__PURE__*/make$3({
-  context: /*#__PURE__*/empty$i(),
+  context: /*#__PURE__*/empty$d(),
   runtimeFlags: defaultRuntimeFlags,
   fiberRefs: /*#__PURE__*/empty$4()
 });
@@ -8824,7 +6735,7 @@ class MemoMapImpl {
         })));
         return succeed$4([cached, map]);
       }
-      return pipe(make$e(0), flatMap$3(observers => pipe(deferredMake(), flatMap$3(deferred => pipe(make$e(() => void_$2), map$6(finalizerRef => {
+      return pipe(make$e(0), flatMap$3(observers => pipe(deferredMake(), flatMap$3(deferred => pipe(make$e(() => void_$2), map$9(finalizerRef => {
         const resource = uninterruptibleMask$1(restore => pipe(scopeMake(), flatMap$3(innerScope => pipe(restore(flatMap$3(makeBuilder(layer, innerScope, true), f => diffFiberRefs(f(this)))), exit$1, flatMap$3(exit => {
           switch (exit._tag) {
             case OP_FAILURE:
@@ -8843,11 +6754,11 @@ class MemoMapImpl {
         }))), exit => pipe(get$1(finalizerRef), flatMap$3(finalizer => finalizer(exit)))];
         return [resource, isFresh(layer) ? map : map.set(layer, memoized)];
       }))))));
-    }), flatten$3);
+    }), flatten$5);
   }
 }
 /** @internal */
-const makeMemoMap = /*#__PURE__*/suspend$3(() => map$6(makeSynchronized(new Map()), ref => new MemoMapImpl(ref)));
+const makeMemoMap = /*#__PURE__*/suspend$3(() => map$9(makeSynchronized(new Map()), ref => new MemoMapImpl(ref)));
 /** @internal */
 const unsafeMakeMemoMap = () => new MemoMapImpl(unsafeMakeSynchronized(new Map()));
 /** @internal */
@@ -8910,9 +6821,9 @@ const makeBuilder = (self, scope, inMemoMap = false) => {
     case "MergeAll":
       {
         const layers = op.layers;
-        return map$6(scopeFork(scope, parallel$1), parallelScope => memoMap => {
+        return map$9(scopeFork(scope, parallel$1), parallelScope => memoMap => {
           const contexts = new Array(layers.length);
-          return map$6(forEachConcurrentDiscard(layers, fnUntraced(function* (layer, i) {
+          return map$9(forEachConcurrentDiscard(layers, fnUntraced(function* (layer, i) {
             const scope = yield* scopeFork(parallelScope, sequential$1);
             const context = yield* memoMap.getOrElseMemoize(layer, scope);
             contexts[i] = context;
@@ -8943,7 +6854,7 @@ const provideSomeRuntime = /*#__PURE__*/dual(2, (self, rt) => {
     const rollbackFlags = diff$3(newFlags, oldFlags);
     fiber.setFiberRefs(newRefs);
     fiber.currentRuntimeFlags = newFlags;
-    return ensuring$3(provideSomeContext(restore(self), merge$1(oldContext, rt.context)), withFiberRuntime$1(fiber => {
+    return ensuring$3(provideSomeContext(restore(self), merge$2(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;
@@ -9047,7 +6958,7 @@ class ScheduleDriverImpl {
     this.ref = ref;
   }
   get state() {
-    return map$6(get$1(this.ref), tuple => tuple[1]);
+    return map$9(get$1(this.ref), tuple => tuple[1]);
   }
   get last() {
     return flatMap$3(get$1(this.ref), ([element, _]) => {
@@ -9065,13 +6976,13 @@ class ScheduleDriverImpl {
   }
   iterationMeta = /*#__PURE__*/unsafeMake$3(defaultIterationMetadata);
   get reset() {
-    return set(this.ref, [none$4(), this.schedule.initial]).pipe(zipLeft$1(set(this.iterationMeta, defaultIterationMetadata)));
+    return set(this.ref, [none$1(), this.schedule.initial]).pipe(zipLeft$1(set(this.iterationMeta, defaultIterationMetadata)));
   }
   next(input) {
-    return pipe(map$6(get$1(this.ref), tuple => tuple[1]), flatMap$3(state => pipe(currentTimeMillis, flatMap$3(now => pipe(suspend$3(() => this.schedule.step(now, input, state)), flatMap$3(([state, out, decision]) => {
+    return pipe(map$9(get$1(this.ref), tuple => tuple[1]), flatMap$3(state => pipe(currentTimeMillis, flatMap$3(now => pipe(suspend$3(() => this.schedule.step(now, input, state)), flatMap$3(([state, out, decision]) => {
       const setState = set(this.ref, [some(out), state]);
       if (isDone(decision)) {
-        return setState.pipe(zipRight$3(fail$4(none$4())));
+        return setState.pipe(zipRight$3(fail$4(none$1())));
       }
       const millis$1 = start(decision.intervals) - now;
       if (millis$1 <= 0) {
@@ -9091,10 +7002,10 @@ const checkEffect = /*#__PURE__*/dual(2, (self, test) => makeWithState(self.init
   if (isDone(decision)) {
     return succeed$4([state, out, done]);
   }
-  return map$6(test(input, out), cont => cont ? [state, out, decision] : [state, out, done]);
+  return map$9(test(input, out), cont => cont ? [state, out, decision] : [state, out, done]);
 })));
 /** @internal */
-const driver = self => pipe(make$e([none$4(), self.initial]), map$6(ref => new ScheduleDriverImpl(self, ref)));
+const driver = self => pipe(make$e([none$1(), self.initial]), map$9(ref => new ScheduleDriverImpl(self, ref)));
 /** @internal */
 const intersect = /*#__PURE__*/dual(2, (self, that) => intersectWith(self, that, intersect$1));
 /** @internal */
@@ -9128,9 +7039,9 @@ const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, ou
 /** @internal */
 const map$3 = /*#__PURE__*/dual(2, (self, f) => mapEffect$1(self, out => sync$2(() => f(out))));
 /** @internal */
-const mapEffect$1 = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap$3(self.step(now, input, state), ([state, out, decision]) => map$6(f(out), out2 => [state, out2, decision]))));
+const mapEffect$1 = /*#__PURE__*/dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap$3(self.step(now, input, state), ([state, out, decision]) => map$9(f(out), out2 => [state, out2, decision]))));
 /** @internal */
-const passthrough = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), map$6(([state, _, decision]) => [state, input, decision])));
+const passthrough = self => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), map$9(([state, _, decision]) => [state, input, decision])));
 /** @internal */
 const recurs = n => whileOutput(forever$1, out => out < n);
 /** @internal */
@@ -9152,9 +7063,9 @@ class ScheduleDefect {
   }
 }
 const isScheduleDefect = u => hasProperty(u, ScheduleDefectTypeId);
-const scheduleDefectWrap = self => catchAll$1(self, e => die$2(new ScheduleDefect(e)));
+const scheduleDefectWrap = self => catchAll$1(self, e => die$3(new ScheduleDefect(e)));
 /** @internal */
-const scheduleDefectRefailCause = cause => match$6(find(cause, _ => isDieType$1(_) && isScheduleDefect(_.defect) ? some(_.defect) : none$4()), {
+const scheduleDefectRefailCause = cause => match$6(find(cause, _ => isDieType$1(_) && isScheduleDefect(_.defect) ? some(_.defect) : none$1()), {
   onNone: () => cause,
   onSome: error => fail$5(error.error)
 });
@@ -9187,7 +7098,7 @@ const repeat_combined = /*#__PURE__*/dual(2, (self, options) => {
 });
 /** @internal */
 const repeatOrElse_Effect = /*#__PURE__*/dual(3, (self, schedule, orElse) => flatMap$3(driver(schedule), driver => matchEffect(self, {
-  onFailure: error => orElse(error, none$4()),
+  onFailure: error => orElse(error, none$1()),
   onSuccess: value => repeatOrElseEffectLoop(provideServiceEffect(self, CurrentIterationMetadata, get$1(driver.iterationMeta)), driver, (error, option) => provideServiceEffect(orElse(error, option), CurrentIterationMetadata, get$1(driver.iterationMeta)), value)
 })));
 /** @internal */
@@ -10113,14 +8024,14 @@ const ignore = ignore$1;
  * @since 2.0.0
  * @category Interruption
  */
-const interrupt = interrupt$3;
+const interrupt = interrupt$4;
 /**
  * Marks an effect as interruptible.
  *
  * @since 2.0.0
  * @category Interruption
  */
-const interruptible = interruptible$1;
+const interruptible = interruptible$2;
 /**
  * Marks an effect as uninterruptible.
  *
@@ -10225,7 +8136,7 @@ const asVoid = asVoid$1;
  * @since 2.0.0
  * @category Mapping
  */
-const map$2 = map$6;
+const map$2 = map$9;
 /**
  * Transforms or modifies the error produced by an effect without affecting its
  * success value.
@@ -10820,7 +8731,7 @@ const flatMap$2 = flatMap$3;
  * @since 2.0.0
  * @category Sequencing
  */
-const flatten$2 = flatten$3;
+const flatten$2 = flatten$5;
 /**
  * Races two effects and returns the result of the first successful one.
  *
@@ -11924,37 +9835,37 @@ class QueueImpl extends Class {
     return this.queue.capacity();
   }
   get size() {
-    return suspend$3(() => catchAll$1(this.unsafeSize(), () => interrupt$3));
+    return suspend$3(() => catchAll$1(this.unsafeSize(), () => interrupt$4));
   }
   unsafeSize() {
-    if (get$6(this.shutdownFlag)) {
-      return none$4();
+    if (get$5(this.shutdownFlag)) {
+      return none$1();
     }
     return some(this.queue.length() - length(this.takers) + this.strategy.surplusSize());
   }
   get isEmpty() {
-    return map$6(this.size, size => size <= 0);
+    return map$9(this.size, size => size <= 0);
   }
   get isFull() {
-    return map$6(this.size, size => size >= this.capacity());
+    return map$9(this.size, size => size >= this.capacity());
   }
   get shutdown() {
     return uninterruptible$1(withFiberRuntime$1(state => {
-      pipe(this.shutdownFlag, set$4(true));
+      pipe(this.shutdownFlag, set$3(true));
       return pipe(forEachConcurrentDiscard(unsafePollAll(this.takers), d => deferredInterruptWith(d, state.id()), false, false), zipRight$3(this.strategy.shutdown), whenEffect(deferredSucceed(this.shutdownHook, void 0)), asVoid$1);
     }));
   }
   get isShutdown() {
-    return sync$2(() => get$6(this.shutdownFlag));
+    return sync$2(() => get$5(this.shutdownFlag));
   }
   get awaitShutdown() {
     return deferredAwait(this.shutdownHook);
   }
   isActive() {
-    return !get$6(this.shutdownFlag);
+    return !get$5(this.shutdownFlag);
   }
   unsafeOffer(value) {
-    if (get$6(this.shutdownFlag)) {
+    if (get$5(this.shutdownFlag)) {
       return false;
     }
     let noRemaining;
@@ -11979,8 +9890,8 @@ class QueueImpl extends Class {
   }
   offer(value) {
     return suspend$3(() => {
-      if (get$6(this.shutdownFlag)) {
-        return interrupt$3;
+      if (get$5(this.shutdownFlag)) {
+        return interrupt$4;
       }
       let noRemaining;
       if (this.queue.length() === 0) {
@@ -12005,11 +9916,11 @@ class QueueImpl extends Class {
   }
   offerAll(iterable) {
     return suspend$3(() => {
-      if (get$6(this.shutdownFlag)) {
-        return interrupt$3;
+      if (get$5(this.shutdownFlag)) {
+        return interrupt$4;
       }
-      const values = fromIterable$3(iterable);
-      const pTakers = this.queue.length() === 0 ? fromIterable$3(unsafePollN(this.takers, values.length)) : empty$j;
+      const values = fromIterable$2(iterable);
+      const pTakers = this.queue.length() === 0 ? fromIterable$2(unsafePollN(this.takers, values.length)) : empty$c;
       const [forTakers, remaining] = pipe(values, splitAt(pTakers.length));
       for (let i = 0; i < pTakers.length; i++) {
         const taker = pTakers[i];
@@ -12022,13 +9933,13 @@ class QueueImpl extends Class {
       // Not enough takers, offer to the queue
       const surplus = this.queue.offerAll(remaining);
       unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-      return isEmpty$7(surplus) ? succeed$4(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
+      return isEmpty$6(surplus) ? succeed$4(true) : this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
     });
   }
   get take() {
     return withFiberRuntime$1(state => {
-      if (get$6(this.shutdownFlag)) {
-        return interrupt$3;
+      if (get$5(this.shutdownFlag)) {
+        return interrupt$4;
       }
       const item = this.queue.poll(EmptyMutableQueue);
       if (item !== EmptyMutableQueue) {
@@ -12043,7 +9954,7 @@ class QueueImpl extends Class {
         return pipe(suspend$3(() => {
           pipe(this.takers, offer$2(deferred));
           unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-          return get$6(this.shutdownFlag) ? interrupt$3 : deferredAwait(deferred);
+          return get$5(this.shutdownFlag) ? interrupt$4 : deferredAwait(deferred);
         }), onInterrupt(() => {
           return sync$2(() => unsafeRemove(this.takers, deferred));
         }));
@@ -12052,7 +9963,7 @@ class QueueImpl extends Class {
   }
   get takeAll() {
     return suspend$3(() => {
-      return get$6(this.shutdownFlag) ? interrupt$3 : sync$2(() => {
+      return get$5(this.shutdownFlag) ? interrupt$4 : sync$2(() => {
         const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
         this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
         return fromIterable$4(values);
@@ -12060,14 +9971,14 @@ class QueueImpl extends Class {
     });
   }
   takeUpTo(max) {
-    return suspend$3(() => get$6(this.shutdownFlag) ? interrupt$3 : sync$2(() => {
+    return suspend$3(() => get$5(this.shutdownFlag) ? interrupt$4 : sync$2(() => {
       const values = this.queue.pollUpTo(max);
       this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
       return fromIterable$4(values);
     }));
   }
   takeBetween(min, max) {
-    return suspend$3(() => takeRemainderLoop(this, min, max, empty$g()));
+    return suspend$3(() => takeRemainderLoop(this, min, max, empty$b()));
   }
 }
 /** @internal */
@@ -12078,7 +9989,7 @@ const takeRemainderLoop = (self, min, max, acc) => {
   return pipe(takeUpTo(self, max), flatMap$3(bs => {
     const remaining = min - bs.length;
     if (remaining === 1) {
-      return pipe(take$1(self), map$6(b => pipe(acc, appendAll$1(bs), append$1(b))));
+      return pipe(take$1(self), map$9(b => pipe(acc, appendAll$1(bs), append$1(b))));
     }
     if (remaining > 1) {
       return pipe(take$1(self), flatMap$3(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, pipe(acc, appendAll$1(bs), append$1(b)))));
@@ -12095,7 +10006,7 @@ const unsafeMake = (queue, takers, shutdownHook, shutdownFlag, strategy) => {
   return new QueueImpl(queue, takers, shutdownHook, shutdownFlag, strategy);
 };
 /** @internal */
-const make$2 = (queue, strategy) => pipe(deferredMake(), map$6(deferred => unsafeMake(queue, unbounded$2(), deferred, make$q(false), strategy)));
+const make$2 = (queue, strategy) => pipe(deferredMake(), map$9(deferred => unsafeMake(queue, unbounded$2(), deferred, make$n(false), strategy)));
 /** @internal */
 class BackingQueueFromMutableQueue {
   mutable;
@@ -12172,7 +10083,7 @@ class BackPressureStrategy {
         this.unsafeOffer(iterable, deferred);
         this.unsafeOnQueueEmptySpace(queue, takers);
         unsafeCompleteTakers(this, queue, takers);
-        return get$6(isShutdown) ? interrupt$3 : deferredAwait(deferred);
+        return get$5(isShutdown) ? interrupt$4 : deferredAwait(deferred);
       }), onInterrupt(() => sync$2(() => this.unsafeRemove(deferred))));
     });
   }
@@ -12187,14 +10098,14 @@ class BackPressureStrategy {
         if (offered && putter[2]) {
           unsafeCompleteDeferred(putter[1], true);
         } else if (!offered) {
-          unsafeOfferAll(this.putters, pipe(unsafePollAll(this.putters), prepend$1(putter)));
+          unsafeOfferAll(this.putters, pipe(unsafePollAll(this.putters), prepend(putter)));
         }
         unsafeCompleteTakers(this, queue, takers);
       }
     }
   }
   unsafeOffer(iterable, deferred) {
-    const stuff = fromIterable$3(iterable);
+    const stuff = fromIterable$2(iterable);
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i];
       if (i === stuff.length - 1) {
@@ -12257,7 +10168,7 @@ const unsafeCompleteTakers = (strategy, queue, takers) => {
         unsafeCompleteDeferred(taker, element);
         strategy.unsafeOnQueueEmptySpace(queue, takers);
       } else {
-        unsafeOfferAll(takers, pipe(unsafePollAll(takers), prepend$1(taker)));
+        unsafeOfferAll(takers, pipe(unsafePollAll(takers), prepend(taker)));
       }
       keepPolling = true;
     } else {
@@ -12508,7 +10419,7 @@ const concatAllWith = (channels, f, g) => {
   op._tag = OP_CONCAT_ALL;
   op.combineInners = f;
   op.combineAll = g;
-  op.onPull = () => PullAfterNext(none$4());
+  op.onPull = () => PullAfterNext(none$1());
   op.onEmit = () => Continue;
   op.value = () => channels;
   op.k = identity;
@@ -12520,7 +10431,7 @@ const concatMapWith = /*#__PURE__*/dual(4, (self, f, g, h) => {
   op._tag = OP_CONCAT_ALL;
   op.combineInners = g;
   op.combineAll = h;
-  op.onPull = () => PullAfterNext(none$4());
+  op.onPull = () => PullAfterNext(none$1());
   op.onEmit = () => Continue;
   op.value = () => self;
   op.k = f;
@@ -13870,14 +11781,14 @@ const mergeAllWith = ({
   yield* addFinalizer(scope, shutdown(queue));
   const cancelers = yield* unbounded();
   yield* addFinalizer(scope, shutdown(cancelers));
-  const lastDone = yield* make$d(none$4());
+  const lastDone = yield* make$d(none$1());
   const errorSignal = yield* make$k();
   const withPermits = (yield* makeSemaphore(concurrencyN)).withPermits;
   const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
   function evaluatePull(pull) {
     return pull.pipe(flatMap$2(match$7({
       onLeft: done => succeed$1(some(done)),
-      onRight: outElem => as(offer(queue, succeed$1(right(outElem))), none$4())
+      onRight: outElem => as(offer(queue, succeed$1(right(outElem))), none$1())
     })), repeat({
       until: _ => isSome(_)
     }), flatMap$2(outDone => update$1(lastDone, match$6({
@@ -14155,14 +12066,14 @@ class TakeImpl {
 /** @internal */
 const chunk = chunk => new TakeImpl(succeed$2(chunk));
 /** @internal */
-const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/fail$3(/*#__PURE__*/none$4()));
+const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/fail$3(/*#__PURE__*/none$1()));
 /** @internal */
 const failCause$1 = cause => new TakeImpl(failCause$4(pipe(cause, map$4(some))));
 /** @internal */
 const of = value => new TakeImpl(succeed$2(of$2(value)));
 
 /** @internal */
-const end = () => fail$1(none$4());
+const end = () => fail$1(none$1());
 /** @internal */
 const failCause = cause => mapError(failCause$3(cause), some);
 
@@ -14199,7 +12110,7 @@ const flatMap = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options)
   if (options?.switch) {
     return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
   }
-  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$c(a => toChannel(f(a))), reduce$5(void_, (left, right) => pipe(left, zipRight(right)))))), _ => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$b(a => toChannel(f(a))), reduce$3(void_, (left, right) => pipe(left, zipRight(right)))))), _ => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
 });
 /** @internal */
 const matchConcurrency = (concurrency, sequential, bounded) => {
@@ -14242,7 +12153,7 @@ const flattenExitOption = self => {
         onSuccess: () => void_
       })
     }));
-    return pipe(write(pipe(toEmit, filterMap(exit => isSuccess(exit) ? some(exit.value) : none$4()))), flatMap$1(() => next));
+    return pipe(write(pipe(toEmit, filterMap(exit => isSuccess(exit) ? some(exit.value) : none$1()))), flatMap$1(() => next));
   };
   const process = readWithCause({
     onInput: chunk => processChunk(chunk, process),
@@ -14276,7 +12187,7 @@ const fromEffectOption = effect => new StreamImpl(unwrap(match$1(effect, {
 /** @internal */
 const fromQueue$1 = (queue, options) => pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), catchAllCause(cause => pipe(isShutdown(queue), flatMap$2(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
 /** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => new StreamImpl(pipe(toChannel(self), mapOut(map$c(f)))));
+const map = /*#__PURE__*/dual(2, (self, f) => new StreamImpl(pipe(toChannel(self), mapOut(map$b(f)))));
 /** @internal */
 const mapEffectSequential = /*#__PURE__*/dual(2, (self, f) => {
   const loop = iterator => {
@@ -14292,13 +12203,13 @@ const mapEffectSequential = /*#__PURE__*/dual(2, (self, f) => {
       return unwrap(map$2(f(value), a2 => flatMap$1(write(of$2(a2)), () => loop(iterator))));
     }
   };
-  return new StreamImpl(pipe(toChannel(self), pipeTo(suspend$1(() => loop(empty$g()[Symbol.iterator]())))));
+  return new StreamImpl(pipe(toChannel(self), pipeTo(suspend$1(() => loop(empty$b()[Symbol.iterator]())))));
 });
 /** @internal */
 const mapEffectPar = /*#__PURE__*/dual(3, (self, n, f) => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mapOutEffectPar(f, n), mapOut(of$2))));
 /** @internal */
 const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => pipe(map$2(effect, chunk => some([chunk, effect])), catchAll(match$6({
-  onNone: () => succeed$1(none$4()),
+  onNone: () => succeed$1(none$1()),
   onSome: fail$1
 }))));
 /** @internal */
@@ -14370,14 +12281,14 @@ const groupByKey = /*#__PURE__*/dual(args => typeof args[0] !== "function", (sel
       if (innerQueue === undefined) {
         return pipe(bounded(options?.bufferSize ?? 16), flatMap$2(innerQueue => pipe(sync$1(() => {
           map.set(key, innerQueue);
-        }), zipRight$1(offer(outerQueue, of([key, innerQueue]))), zipRight$1(pipe(offer(innerQueue, chunk(values)), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none$4()))))));
+        }), zipRight$1(offer(outerQueue, of([key, innerQueue]))), zipRight$1(pipe(offer(innerQueue, chunk(values)), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none$1()))))));
       }
-      return catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? some(_void) : none$4());
+      return catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? some(_void) : none$1());
     }, {
       discard: true
     })), () => loop(map, outerQueue)),
     onFailure: cause => fromEffect$3(offer(outerQueue, failCause$1(cause))),
-    onDone: () => fromEffect$3(pipe(forEach(map.entries(), ([_, innerQueue]) => pipe(offer(innerQueue, end$1), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none$4())), {
+    onDone: () => fromEffect$3(pipe(forEach(map.entries(), ([_, innerQueue]) => pipe(offer(innerQueue, end$1), catchSomeCause(cause => isInterruptedOnly(cause) ? some(_void) : none$1())), {
       discard: true
     }), zipRight$1(offer(outerQueue, end$1))))
   });