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

package/dist/cjs/{aria-validation-controller-B7unOPxT.js → aria-validation-controller-B3hMkau3.js}

@@ -1,7 +1,8 @@
 'use strict';
 
 var index = require('./index-9ZJx0550.js');
-var Effect = require('./Effect-BIlTHtLK.js');
+var Effect = require('./Effect-CNhHt4Xb.js');
+var MutableQueue = require('./MutableQueue-Bk9tBfaK.js');
 
 /**
  * @since 2.0.0
@@ -68,7 +69,7 @@ const die = Effect.die;
  * @since 2.0.0
  * @category Constructors
  */
-const interrupt$1 = Effect.interrupt$1;
+const interrupt$1 = Effect.interrupt;
 /**
  * Checks if a `Cause` is a `Die` type.
  *
@@ -159,7 +160,7 @@ const flipCauseOption = Effect.flipCauseOption;
  */
 const map$2 = Effect.map$1;
 
-const _await = Effect._await$1;
+const _await = Effect._await;
 /**
  * Inherits values from all `FiberRef` instances into current fiber. This
  * will resume immediately.
@@ -264,13 +265,13 @@ class QueueImpl extends Effect.Class {
     return this.queue.capacity();
   }
   get size() {
-    return Effect.suspend(() => Effect.catchAll$1(this.unsafeSize(), () => Effect.interrupt$2));
+    return Effect.suspend(() => Effect.catchAll$1(this.unsafeSize(), () => Effect.interrupt$1));
   }
   unsafeSize() {
     if (Effect.get$2(this.shutdownFlag)) {
       return Effect.none();
     }
-    return Effect.some(this.queue.length() - Effect.length(this.takers) + this.strategy.surplusSize());
+    return Effect.some(this.queue.length() - MutableQueue.length(this.takers) + this.strategy.surplusSize());
   }
   get isEmpty() {
     return Effect.map(this.size, size => size <= 0);
@@ -299,8 +300,8 @@ class QueueImpl extends Effect.Class {
     }
     let noRemaining;
     if (this.queue.length() === 0) {
-      const taker = Effect.pipe(this.takers, Effect.poll(Effect.EmptyMutableQueue));
-      if (taker !== Effect.EmptyMutableQueue) {
+      const taker = Effect.pipe(this.takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
+      if (taker !== MutableQueue.EmptyMutableQueue) {
         unsafeCompleteDeferred(taker, value);
         noRemaining = true;
       } else {
@@ -320,12 +321,12 @@ class QueueImpl extends Effect.Class {
   offer(value) {
     return Effect.suspend(() => {
       if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$2;
+        return Effect.interrupt$1;
       }
       let noRemaining;
       if (this.queue.length() === 0) {
-        const taker = Effect.pipe(this.takers, Effect.poll(Effect.EmptyMutableQueue));
-        if (taker !== Effect.EmptyMutableQueue) {
+        const taker = Effect.pipe(this.takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
+        if (taker !== MutableQueue.EmptyMutableQueue) {
           unsafeCompleteDeferred(taker, value);
           noRemaining = true;
         } else {
@@ -346,7 +347,7 @@ class QueueImpl extends Effect.Class {
   offerAll(iterable) {
     return Effect.suspend(() => {
       if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$2;
+        return Effect.interrupt$1;
       }
       const values = Effect.fromIterable(iterable);
       const pTakers = this.queue.length() === 0 ? Effect.fromIterable(unsafePollN(this.takers, values.length)) : Effect.empty$1;
@@ -368,10 +369,10 @@ class QueueImpl extends Effect.Class {
   get take() {
     return Effect.withFiberRuntime(state => {
       if (Effect.get$2(this.shutdownFlag)) {
-        return Effect.interrupt$2;
+        return Effect.interrupt$1;
       }
-      const item = this.queue.poll(Effect.EmptyMutableQueue);
-      if (item !== Effect.EmptyMutableQueue) {
+      const item = this.queue.poll(MutableQueue.EmptyMutableQueue);
+      if (item !== MutableQueue.EmptyMutableQueue) {
         this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
         return Effect.succeed$1(item);
       } else {
@@ -381,9 +382,9 @@ class QueueImpl extends Effect.Class {
         // - Clean up resources in case of interruption
         const deferred = Effect.deferredUnsafeMake(state.id());
         return Effect.pipe(Effect.suspend(() => {
-          Effect.pipe(this.takers, Effect.offer(deferred));
+          Effect.pipe(this.takers, MutableQueue.offer(deferred));
           unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-          return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : Effect.deferredAwait(deferred);
+          return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.deferredAwait(deferred);
         }), Effect.onInterrupt(() => {
           return Effect.sync(() => unsafeRemove(this.takers, deferred));
         }));
@@ -392,7 +393,7 @@ class QueueImpl extends Effect.Class {
   }
   get takeAll() {
     return Effect.suspend(() => {
-      return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : Effect.sync(() => {
+      return Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.sync(() => {
         const values = this.queue.pollUpTo(Number.POSITIVE_INFINITY);
         this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
         return Effect.fromIterable$1(values);
@@ -400,7 +401,7 @@ class QueueImpl extends Effect.Class {
     });
   }
   takeUpTo(max) {
-    return Effect.suspend(() => Effect.get$2(this.shutdownFlag) ? Effect.interrupt$2 : Effect.sync(() => {
+    return Effect.suspend(() => Effect.get$2(this.shutdownFlag) ? Effect.interrupt$1 : Effect.sync(() => {
       const values = this.queue.pollUpTo(max);
       this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
       return Effect.fromIterable$1(values);
@@ -427,15 +428,15 @@ const takeRemainderLoop = (self, min, max, acc) => {
   }));
 };
 /** @internal */
-const bounded$1 = requestedCapacity => Effect.pipe(Effect.sync(() => Effect.bounded(requestedCapacity)), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
+const bounded$1 = requestedCapacity => Effect.pipe(Effect.sync(() => MutableQueue.bounded(requestedCapacity)), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), backPressureStrategy())));
 /** @internal */
-const unbounded$1 = () => Effect.pipe(Effect.sync(() => Effect.unbounded()), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), droppingStrategy())));
+const unbounded$1 = () => Effect.pipe(Effect.sync(() => MutableQueue.unbounded()), Effect.flatMap(queue => make$2(backingQueueFromMutableQueue(queue), droppingStrategy())));
 /** @internal */
 const unsafeMake = (queue, takers, shutdownHook, shutdownFlag, strategy) => {
   return new QueueImpl(queue, takers, shutdownHook, shutdownFlag, strategy);
 };
 /** @internal */
-const make$2 = (queue, strategy) => Effect.pipe(Effect.deferredMake(), Effect.map(deferred => unsafeMake(queue, Effect.unbounded(), deferred, Effect.make(false), strategy)));
+const make$2 = (queue, strategy) => Effect.pipe(Effect.deferredMake(), Effect.map(deferred => unsafeMake(queue, MutableQueue.unbounded(), deferred, Effect.make(false), strategy)));
 /** @internal */
 class BackingQueueFromMutableQueue {
   mutable;
@@ -444,22 +445,22 @@ class BackingQueueFromMutableQueue {
     this.mutable = mutable;
   }
   poll(def) {
-    return Effect.poll(this.mutable, def);
+    return MutableQueue.poll(this.mutable, def);
   }
   pollUpTo(limit) {
-    return Effect.pollUpTo(this.mutable, limit);
+    return MutableQueue.pollUpTo(this.mutable, limit);
   }
   offerAll(elements) {
-    return Effect.offerAll(this.mutable, elements);
+    return MutableQueue.offerAll(this.mutable, elements);
   }
   offer(element) {
-    return Effect.offer(this.mutable, element);
+    return MutableQueue.offer(this.mutable, element);
   }
   capacity() {
-    return Effect.capacity(this.mutable);
+    return MutableQueue.capacity(this.mutable);
   }
   length() {
-    return Effect.length(this.mutable);
+    return MutableQueue.length(this.mutable);
   }
 }
 /** @internal */
@@ -488,14 +489,14 @@ const droppingStrategy = () => new DroppingStrategy();
 /** @internal */
 class BackPressureStrategy {
   [QueueStrategyTypeId] = queueStrategyVariance;
-  putters = /*#__PURE__*/Effect.unbounded();
+  putters = /*#__PURE__*/MutableQueue.unbounded();
   surplusSize() {
-    return Effect.length(this.putters);
+    return MutableQueue.length(this.putters);
   }
   onCompleteTakersWithEmptyQueue(takers) {
-    while (!Effect.isEmpty$1(this.putters) && !Effect.isEmpty$1(takers)) {
-      const taker = Effect.poll(takers, void 0);
-      const putter = Effect.poll(this.putters, void 0);
+    while (!MutableQueue.isEmpty(this.putters) && !MutableQueue.isEmpty(takers)) {
+      const taker = MutableQueue.poll(takers, void 0);
+      const putter = MutableQueue.poll(this.putters, void 0);
       if (putter[2]) {
         unsafeCompleteDeferred(putter[1], true);
       }
@@ -512,15 +513,15 @@ class BackPressureStrategy {
         this.unsafeOffer(iterable, deferred);
         this.unsafeOnQueueEmptySpace(queue, takers);
         unsafeCompleteTakers(this, queue, takers);
-        return Effect.get$2(isShutdown) ? Effect.interrupt$2 : Effect.deferredAwait(deferred);
+        return Effect.get$2(isShutdown) ? Effect.interrupt$1 : Effect.deferredAwait(deferred);
       }), Effect.onInterrupt(() => Effect.sync(() => this.unsafeRemove(deferred))));
     });
   }
   unsafeOnQueueEmptySpace(queue, takers) {
     let keepPolling = true;
     while (keepPolling && (queue.capacity() === Number.POSITIVE_INFINITY || queue.length() < queue.capacity())) {
-      const putter = Effect.pipe(this.putters, Effect.poll(Effect.EmptyMutableQueue));
-      if (putter === Effect.EmptyMutableQueue) {
+      const putter = Effect.pipe(this.putters, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
+      if (putter === MutableQueue.EmptyMutableQueue) {
         keepPolling = false;
       } else {
         const offered = queue.offer(putter[0]);
@@ -538,9 +539,9 @@ class BackPressureStrategy {
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i];
       if (i === stuff.length - 1) {
-        Effect.pipe(this.putters, Effect.offer([value, deferred, true]));
+        Effect.pipe(this.putters, MutableQueue.offer([value, deferred, true]));
       } else {
-        Effect.pipe(this.putters, Effect.offer([value, deferred, false]));
+        Effect.pipe(this.putters, MutableQueue.offer([value, deferred, false]));
       }
     }
   }
@@ -571,15 +572,15 @@ const unsafeCompleteDeferred = (deferred, a) => {
 };
 /** @internal */
 const unsafeOfferAll = (queue, as) => {
-  return Effect.pipe(queue, Effect.offerAll(as));
+  return Effect.pipe(queue, MutableQueue.offerAll(as));
 };
 /** @internal */
 const unsafePollAll = queue => {
-  return Effect.pipe(queue, Effect.pollUpTo(Number.POSITIVE_INFINITY));
+  return Effect.pipe(queue, MutableQueue.pollUpTo(Number.POSITIVE_INFINITY));
 };
 /** @internal */
 const unsafePollN = (queue, max) => {
-  return Effect.pipe(queue, Effect.pollUpTo(max));
+  return Effect.pipe(queue, MutableQueue.pollUpTo(max));
 };
 /** @internal */
 const unsafeRemove = (queue, a) => {
@@ -590,10 +591,10 @@ const unsafeCompleteTakers = (strategy, queue, takers) => {
   // Check both a taker and an item are in the queue, starting with the taker
   let keepPolling = true;
   while (keepPolling && queue.length() !== 0) {
-    const taker = Effect.pipe(takers, Effect.poll(Effect.EmptyMutableQueue));
-    if (taker !== Effect.EmptyMutableQueue) {
-      const element = queue.poll(Effect.EmptyMutableQueue);
-      if (element !== Effect.EmptyMutableQueue) {
+    const taker = Effect.pipe(takers, MutableQueue.poll(MutableQueue.EmptyMutableQueue));
+    if (taker !== MutableQueue.EmptyMutableQueue) {
+      const element = queue.poll(MutableQueue.EmptyMutableQueue);
+      if (element !== MutableQueue.EmptyMutableQueue) {
         unsafeCompleteDeferred(taker, element);
         strategy.unsafeOnQueueEmptySpace(queue, takers);
       } else {
@@ -604,7 +605,7 @@ const unsafeCompleteTakers = (strategy, queue, takers) => {
       keepPolling = false;
     }
   }
-  if (keepPolling && queue.length() === 0 && !Effect.isEmpty$1(takers)) {
+  if (keepPolling && queue.length() === 0 && !MutableQueue.isEmpty(takers)) {
     strategy.onCompleteTakersWithEmptyQueue(takers);
   }
 };
@@ -738,7 +739,7 @@ class ContinuationKImpl {
     this.onHalt = onHalt;
   }
   onExit(exit) {
-    return Effect.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
+    return MutableQueue.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
   }
 }
 /** @internal */
@@ -1049,7 +1050,7 @@ class PullFromChild {
     const fin1 = this.childExecutor.close(exit);
     const fin2 = this.parentSubexecutor.close(exit);
     if (fin1 !== undefined && fin2 !== undefined) {
-      return Effect.zipWith(Effect.exit$1(fin1), Effect.exit$1(fin2), (exit1, exit2) => Effect.pipe(exit1, Effect.zipRight$1(exit2)));
+      return Effect.zipWith(Effect.exit$1(fin1), Effect.exit$1(fin2), (exit1, exit2) => Effect.pipe(exit1, MutableQueue.zipRight(exit2)));
     } else if (fin1 !== undefined) {
       return fin1;
     } else if (fin2 !== undefined) {
@@ -1093,7 +1094,7 @@ class PullFromUpstream {
     const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
     const result = fins.reduce((acc, next) => {
       if (acc !== undefined && next !== undefined) {
-        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => Effect.zipRight$1(exit1, exit2));
+        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => MutableQueue.zipRight(exit1, exit2));
       } else if (acc !== undefined) {
         return acc;
       } else if (next !== undefined) {
@@ -1137,7 +1138,7 @@ class DrainChildExecutors {
     const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
     const result = fins.reduce((acc, next) => {
       if (acc !== undefined && next !== undefined) {
-        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => Effect.zipRight$1(exit1, exit2));
+        return Effect.zipWith(acc, Effect.exit$1(next), (exit1, exit2) => MutableQueue.zipRight(exit1, exit2));
       } else if (acc !== undefined) {
         return acc;
       } else if (next !== undefined) {
@@ -1256,7 +1257,7 @@ class ChannelExecutor {
                       switch (state._tag) {
                         case OP_DONE$1:
                           {
-                            return Effect.match$2(inputExecutor.getDone(), {
+                            return MutableQueue.match(inputExecutor.getDone(), {
                               onFailure: cause => bridgeInput.error(cause),
                               onSuccess: value => bridgeInput.done(value)
                             });
@@ -1289,7 +1290,7 @@ class ChannelExecutor {
                 {
                   const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => Effect.sync$1(() => {
                     const prevLastClose = this._closeLastSubstream === undefined ? Effect._void : this._closeLastSubstream;
-                    this._closeLastSubstream = Effect.pipe(prevLastClose, Effect.zipRight$2(effect));
+                    this._closeLastSubstream = Effect.pipe(prevLastClose, Effect.zipRight$1(effect));
                   }));
                   executor._input = this._input;
                   const channel = this._currentChannel;
@@ -1366,7 +1367,7 @@ class ChannelExecutor {
                     try {
                       this._currentChannel = read.more(emitted);
                     } catch (error) {
-                      this._currentChannel = read.done.onExit(Effect.die$1(error));
+                      this._currentChannel = read.done.onExit(MutableQueue.die(error));
                     }
                     return undefined;
                   }, exit => {
@@ -1466,13 +1467,13 @@ class ChannelExecutor {
     if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
       return undefined;
     }
-    return Effect.pipe(Effect.exit$1(ifNotNull(closeSubexecutors)), Effect.zip(Effect.exit$1(ifNotNull(runInProgressFinalizers))), Effect.zip(Effect.exit$1(ifNotNull(closeSelf))), Effect.map$2(([[exit1, exit2], exit3]) => Effect.pipe(exit1, Effect.zipRight$1(exit2), Effect.zipRight$1(exit3))), Effect.uninterruptible$1,
+    return Effect.pipe(Effect.exit$1(ifNotNull(closeSubexecutors)), Effect.zip(Effect.exit$1(ifNotNull(runInProgressFinalizers))), Effect.zip(Effect.exit$1(ifNotNull(closeSelf))), Effect.map$2(([[exit1, exit2], exit3]) => Effect.pipe(exit1, MutableQueue.zipRight(exit2), MutableQueue.zipRight(exit3))), Effect.uninterruptible$1,
     // TODO: remove
     Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
   }
   doneSucceed(value) {
     if (this._doneStack.length === 0) {
-      this._done = Effect.succeed$2(value);
+      this._done = MutableQueue.succeed(value);
       this._currentChannel = undefined;
       return Done();
     }
@@ -1485,18 +1486,18 @@ class ChannelExecutor {
     const finalizers = this.popNextFinalizers();
     if (this._doneStack.length === 0) {
       this._doneStack = finalizers.reverse();
-      this._done = Effect.succeed$2(value);
+      this._done = MutableQueue.succeed(value);
       this._currentChannel = undefined;
       return Done();
     }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.succeed$2(value));
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), MutableQueue.succeed(value));
     this.storeInProgressFinalizer(finalizerEffect);
     const effect = Effect.pipe(finalizerEffect, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())), Effect.uninterruptible$1, Effect.flatMap$1(() => Effect.sync$1(() => this.doneSucceed(value))));
     return fromEffect$2(effect);
   }
   doneHalt(cause) {
     if (this._doneStack.length === 0) {
-      this._done = Effect.failCause(cause);
+      this._done = MutableQueue.failCause(cause);
       this._currentChannel = undefined;
       return Done();
     }
@@ -1513,11 +1514,11 @@ class ChannelExecutor {
     const finalizers = this.popNextFinalizers();
     if (this._doneStack.length === 0) {
       this._doneStack = finalizers.reverse();
-      this._done = Effect.failCause(cause);
+      this._done = MutableQueue.failCause(cause);
       this._currentChannel = undefined;
       return Done();
     }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Effect.failCause(cause));
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), MutableQueue.failCause(cause));
     this.storeInProgressFinalizer(finalizerEffect);
     const effect = Effect.pipe(finalizerEffect, Effect.ensuring(Effect.sync$1(() => this.clearInProgressFinalizer())), Effect.uninterruptible$1, Effect.flatMap$1(() => Effect.sync$1(() => this.doneHalt(cause))));
     return fromEffect$2(effect);
@@ -1581,7 +1582,7 @@ class ChannelExecutor {
     this._activeSubexecutor = nextSubExec;
   }
   finishWithExit(exit) {
-    const state = Effect.match$2(exit, {
+    const state = MutableQueue.match(exit, {
       onFailure: cause => this.doneHalt(cause),
       onSuccess: value => this.doneSucceed(value)
     });
@@ -1592,7 +1593,7 @@ class ChannelExecutor {
     this.addFinalizer(() => Effect.pipe(closeFuncs, Effect.forEach(closeFunc => Effect.pipe(Effect.sync$1(() => closeFunc(subexecutorDone)), Effect.flatMap$1(closeEffect => closeEffect !== undefined ? closeEffect : Effect._void)), {
       discard: true
     })));
-    const state = Effect.pipe(subexecutorDone, Effect.match$2({
+    const state = Effect.pipe(subexecutorDone, MutableQueue.match({
       onFailure: cause => this.doneHalt(cause),
       onSuccess: value => this.doneSucceed(value)
     }));
@@ -1635,7 +1636,7 @@ class ChannelExecutor {
       }
       this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
       return undefined;
-    }, Effect.match$2({
+    }, MutableQueue.match({
       onFailure: cause => {
         const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
         return state === undefined ? undefined : effectOrUndefinedIgnored(state);
@@ -1652,21 +1653,21 @@ class ChannelExecutor {
       case OP_PULL_FROM_UPSTREAM:
         {
           const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
-          this._closeLastSubstream = childExecutor.close(Effect.succeed$2(doneValue));
+          this._closeLastSubstream = childExecutor.close(MutableQueue.succeed(doneValue));
           this.replaceSubexecutor(modifiedParent);
           break;
         }
       case OP_DRAIN_CHILD_EXECUTORS:
         {
           const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-          this._closeLastSubstream = childExecutor.close(Effect.succeed$2(doneValue));
+          this._closeLastSubstream = childExecutor.close(MutableQueue.succeed(doneValue));
           this.replaceSubexecutor(modifiedParent);
           break;
         }
     }
   }
   handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
-    return this.finishSubexecutorWithCloseEffect(Effect.failCause(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
+    return this.finishSubexecutorWithCloseEffect(MutableQueue.failCause(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
   }
   pullFromUpstream(subexecutor) {
     if (subexecutor.activeChildExecutors.length === 0) {
@@ -1684,7 +1685,7 @@ class ChannelExecutor {
     return Read(subexecutor.upstreamExecutor, effect => {
       const closeLastSubstream = this._closeLastSubstream === undefined ? Effect._void : this._closeLastSubstream;
       this._closeLastSubstream = undefined;
-      return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.zipRight$2(effect));
+      return Effect.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect.zipRight$1(effect));
     }, emitted => {
       if (this._closeLastSubstream !== undefined) {
         const closeLastSubstream = this._closeLastSubstream;
@@ -1720,7 +1721,7 @@ class ChannelExecutor {
         return undefined;
       }
       const closeLastSubstream = this._closeLastSubstream;
-      const state = this.finishSubexecutorWithCloseEffect(Effect.pipe(exit, Effect.map$3(a => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, exit => subexecutor.upstreamExecutor.close(exit));
+      const state = this.finishSubexecutorWithCloseEffect(Effect.pipe(exit, MutableQueue.map(a => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, exit => subexecutor.upstreamExecutor.close(exit));
       return state === undefined ? undefined :
       // NOTE: assuming finalizers cannot fail
       effectOrUndefinedIgnored(state);
@@ -1752,7 +1753,7 @@ class ChannelExecutor {
 }
 const ifNotNull = effect => effect !== undefined ? effect : Effect._void;
 const runFinalizers = (finalizers, exit) => {
-  return Effect.pipe(Effect.forEach(finalizers, fin => Effect.exit$1(fin(exit))), Effect.map$2(exits => Effect.pipe(Effect.all$1(exits), Effect.getOrElse(() => Effect.void_$1))), Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
+  return Effect.pipe(Effect.forEach(finalizers, fin => Effect.exit$1(fin(exit))), Effect.map$2(exits => Effect.pipe(MutableQueue.all(exits), Effect.getOrElse(() => MutableQueue.void_))), Effect.flatMap$1(exit => Effect.suspend$1(() => exit)));
 };
 /**
  * @internal
@@ -1810,7 +1811,7 @@ const readUpstream = (r, onSuccess, onFailure) => {
         {
           readStack.push(current);
           return Effect.pipe(current.onEffect(state.effect), Effect.catchAllCause(cause => Effect.suspend$1(() => {
-            const doneEffect = current.onDone(Effect.failCause(cause));
+            const doneEffect = current.onDone(MutableQueue.failCause(cause));
             return doneEffect === undefined ? Effect._void : doneEffect;
           })), Effect.matchCauseEffect({
             onFailure,
@@ -1829,17 +1830,17 @@ const readUpstream = (r, onSuccess, onFailure) => {
 };
 /** @internal */
 const runIn = /*#__PURE__*/Effect.dual(2, (self, scope) => {
-  const run = (channelDeferred, scopeDeferred, scope) => Effect.acquireUseRelease(Effect.sync$1(() => new ChannelExecutor(self, void 0, Effect.identity)), exec => Effect.suspend$1(() => runScopedInterpret(exec.run(), exec).pipe(Effect.intoDeferred(channelDeferred), Effect.zipRight$2(Effect._await(channelDeferred)), Effect.zipLeft(Effect._await(scopeDeferred)))), (exec, exit) => {
+  const run = (channelDeferred, scopeDeferred, scope) => Effect.acquireUseRelease(Effect.sync$1(() => new ChannelExecutor(self, void 0, Effect.identity)), exec => Effect.suspend$1(() => runScopedInterpret(exec.run(), exec).pipe(Effect.intoDeferred(channelDeferred), Effect.zipRight$1(MutableQueue._await(channelDeferred)), Effect.zipLeft(MutableQueue._await(scopeDeferred)))), (exec, exit) => {
     const finalize = exec.close(exit);
     if (finalize === undefined) {
       return Effect._void;
     }
-    return Effect.tapErrorCause(finalize, cause => Effect.addFinalizer(scope, Effect.failCause$1(cause)));
+    return Effect.tapErrorCause(finalize, cause => Effect.addFinalizer(scope, Effect.failCause(cause)));
   });
-  return Effect.uninterruptibleMask(restore => Effect.all$2([Effect.fork(scope, Effect.sequential), Effect.make$2(), Effect.make$2()]).pipe(Effect.flatMap$1(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(Effect.forkIn(scope), Effect.flatMap$1(fiber => scope.addFinalizer(exit => {
-    const interruptors$1 = Effect.isFailure(exit) ? interruptors(exit.cause) : undefined;
-    return Effect.isDone(channelDeferred).pipe(Effect.flatMap$1(isDone => isDone ? Effect.succeed$3(scopeDeferred, void 0).pipe(Effect.zipRight$2(_await(fiber)), Effect.zipRight$2(inheritAll(fiber))) : Effect.succeed$3(scopeDeferred, void 0).pipe(Effect.zipRight$2(interruptors$1 && Effect.size$1(interruptors$1) > 0 ? interruptAs(fiber, Effect.combineAll(interruptors$1)) : interrupt(fiber)), Effect.zipRight$2(inheritAll(fiber)))));
-  }).pipe(Effect.zipRight$2(restore(Effect._await(channelDeferred)))))))));
+  return Effect.uninterruptibleMask(restore => Effect.all$1([Effect.fork(scope, Effect.sequential), MutableQueue.make(), MutableQueue.make()]).pipe(Effect.flatMap$1(([child, channelDeferred, scopeDeferred]) => restore(run(channelDeferred, scopeDeferred, child)).pipe(Effect.forkIn(scope), Effect.flatMap$1(fiber => scope.addFinalizer(exit => {
+    const interruptors$1 = MutableQueue.isFailure(exit) ? interruptors(exit.cause) : undefined;
+    return MutableQueue.isDone(channelDeferred).pipe(Effect.flatMap$1(isDone => isDone ? MutableQueue.succeed$1(scopeDeferred, void 0).pipe(Effect.zipRight$1(_await(fiber)), Effect.zipRight$1(inheritAll(fiber))) : MutableQueue.succeed$1(scopeDeferred, void 0).pipe(Effect.zipRight$1(interruptors$1 && Effect.size$1(interruptors$1) > 0 ? interruptAs(fiber, Effect.combineAll(interruptors$1)) : interrupt(fiber)), Effect.zipRight$1(inheritAll(fiber)))));
+  }).pipe(Effect.zipRight$1(restore(MutableQueue._await(channelDeferred)))))))));
 });
 /** @internal */
 const runScopedInterpret = (channelState, exec) => {
@@ -1860,7 +1861,7 @@ const runScopedInterpret = (channelState, exec) => {
       }
     case OP_READ:
       {
-        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), Effect.failCause$1);
+        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), Effect.failCause);
       }
   }
 };
@@ -2007,7 +2008,7 @@ class SingleProducerAsyncInputImpl {
     this.ref = ref;
   }
   awaitRead() {
-    return Effect.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [Effect._await(state.notifyProducer), state] : [Effect._void, state]));
+    return Effect.flatten(modify(this.ref, state => state._tag === OP_STATE_EMPTY ? [MutableQueue._await(state.notifyProducer), state] : [Effect._void, state]));
   }
   get close() {
     return Effect.fiberIdWith(fiberId => this.error(interrupt$1(fiberId)));
@@ -2017,48 +2018,48 @@ class SingleProducerAsyncInputImpl {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [MutableQueue._await(state.notifyProducer), state];
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.forEach(state.notifyConsumers, deferred => Effect.succeed$3(deferred, Effect.left(value)), {
+            return [Effect.forEach(state.notifyConsumers, deferred => MutableQueue.succeed$1(deferred, Effect.left(value)), {
               discard: true
             }), stateDone(value)];
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
       }
     }));
   }
   emit(element) {
-    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+    return Effect.flatMap$1(MutableQueue.make(), deferred => Effect.flatten(modify(this.ref, state => {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [MutableQueue._await(state.notifyProducer), state];
           }
         case OP_STATE_EMIT:
           {
             const notifyConsumer = state.notifyConsumers[0];
             const notifyConsumers = state.notifyConsumers.slice(1);
             if (notifyConsumer !== undefined) {
-              return [Effect.succeed$3(notifyConsumer, Effect.right(element)), notifyConsumers.length === 0 ? stateEmpty(deferred) : stateEmit(notifyConsumers)];
+              return [MutableQueue.succeed$1(notifyConsumer, Effect.right(element)), notifyConsumers.length === 0 ? stateEmpty(deferred) : stateEmit(notifyConsumers)];
             }
             throw new Error("Bug: Channel.SingleProducerAsyncInput.emit - Queue was empty! please report an issue at https://github.com/Effect-TS/effect/issues");
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
       }
     })));
@@ -2068,34 +2069,34 @@ class SingleProducerAsyncInputImpl {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect._await(state.notifyProducer), state];
+            return [MutableQueue._await(state.notifyProducer), state];
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.forEach(state.notifyConsumers, deferred => Effect.failCause$2(deferred, cause), {
+            return [Effect.forEach(state.notifyConsumers, deferred => MutableQueue.failCause$1(deferred, cause), {
               discard: true
             }), stateError(cause)];
           }
         case OP_STATE_ERROR:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
         case OP_STATE_DONE:
           {
-            return [Effect.interrupt$3, state];
+            return [Effect.interrupt$2, state];
           }
       }
     }));
   }
   get take() {
-    return this.takeWith(cause => Effect.failCause(map$2(cause, Effect.left)), elem => Effect.succeed$2(elem), done => Effect.fail$1(Effect.right(done)));
+    return this.takeWith(cause => MutableQueue.failCause(map$2(cause, Effect.left)), elem => MutableQueue.succeed(elem), done => MutableQueue.fail(Effect.right(done)));
   }
   takeWith(onError, onElement, onDone) {
-    return Effect.flatMap$1(Effect.make$2(), deferred => Effect.flatten(modify(this.ref, state => {
+    return Effect.flatMap$1(MutableQueue.make(), deferred => Effect.flatten(modify(this.ref, state => {
       switch (state._tag) {
         case OP_STATE_EMPTY:
           {
-            return [Effect.zipRight$2(Effect.succeed$3(state.notifyProducer, void 0), Effect.matchCause(Effect._await(deferred), {
+            return [Effect.zipRight$1(MutableQueue.succeed$1(state.notifyProducer, void 0), Effect.matchCause(MutableQueue._await(deferred), {
               onFailure: onError,
               onSuccess: Effect.match$1({
                 onLeft: onDone,
@@ -2105,7 +2106,7 @@ class SingleProducerAsyncInputImpl {
           }
         case OP_STATE_EMIT:
           {
-            return [Effect.matchCause(Effect._await(deferred), {
+            return [Effect.matchCause(MutableQueue._await(deferred), {
               onFailure: onError,
               onSuccess: Effect.match$1({
                 onLeft: onDone,
@@ -2126,7 +2127,7 @@ class SingleProducerAsyncInputImpl {
   }
 }
 /** @internal */
-const make$1 = () => Effect.pipe(Effect.make$2(), Effect.flatMap$1(deferred => make$3(stateEmpty(deferred))), Effect.map$2(ref => new SingleProducerAsyncInputImpl(ref)));
+const make$1 = () => Effect.pipe(MutableQueue.make(), Effect.flatMap$1(deferred => make$3(stateEmpty(deferred))), Effect.map$2(ref => new SingleProducerAsyncInputImpl(ref)));
 
 /** @internal */
 const concatMap = /*#__PURE__*/Effect.dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
@@ -2168,19 +2169,19 @@ const mapOutEffectPar = /*#__PURE__*/Effect.dual(3, (self, f, n) => unwrapScoped
   const queueReader = fromInput(input);
   const queue = yield* bounded(n);
   yield* Effect.addFinalizer(scope, shutdown(queue));
-  const errorSignal = yield* Effect.make$2();
+  const errorSignal = yield* MutableQueue.make();
   const withPermits = n === Number.POSITIVE_INFINITY ? _ => Effect.identity : (yield* Effect.makeSemaphore(n)).withPermits;
   const pull = yield* queueReader.pipe(pipeTo(self), toPullIn(scope));
   yield* pull.pipe(Effect.matchCauseEffect({
-    onFailure: cause => offer(queue, Effect.failCause$1(cause)),
+    onFailure: cause => offer(queue, Effect.failCause(cause)),
     onSuccess: Effect.match$1({
-      onLeft: outDone => Effect.zipRight$2(Effect.interruptible(withPermits(n)(Effect._void)), Effect.asVoid$1(offer(queue, Effect.succeed(Effect.left(outDone))))),
+      onLeft: outDone => Effect.zipRight$1(Effect.interruptible(withPermits(n)(Effect._void)), Effect.asVoid$1(offer(queue, Effect.succeed(Effect.left(outDone))))),
       onRight: outElem => Effect.gen(function* () {
-        const deferred = yield* Effect.make$2();
-        const latch = yield* Effect.make$2();
-        yield* offer(queue, Effect.map$2(Effect._await(deferred), Effect.right));
-        yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(Effect.uninterruptibleMask(restore => Effect.exit$1(restore(Effect._await(errorSignal))).pipe(Effect.raceFirst(Effect.exit$1(restore(f(outElem)))), Effect.flatMap$1(Effect.identity))).pipe(Effect.tapErrorCause(cause => Effect.failCause$2(errorSignal, cause)), Effect.intoDeferred(deferred))), withPermits(1), Effect.forkIn(scope));
-        yield* Effect._await(latch);
+        const deferred = yield* MutableQueue.make();
+        const latch = yield* MutableQueue.make();
+        yield* offer(queue, Effect.map$2(MutableQueue._await(deferred), Effect.right));
+        yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(Effect.uninterruptibleMask(restore => Effect.exit$1(restore(MutableQueue._await(errorSignal))).pipe(Effect.raceFirst(Effect.exit$1(restore(f(outElem)))), Effect.flatMap$1(Effect.identity))).pipe(Effect.tapErrorCause(cause => MutableQueue.failCause$1(errorSignal, cause)), Effect.intoDeferred(deferred))), withPermits(1), Effect.forkIn(scope));
+        yield* MutableQueue._await(latch);
       })
     })
   }), Effect.forever, Effect.interruptible, Effect.forkIn(scope));
@@ -2211,7 +2212,7 @@ const mergeAllWith = ({
   const cancelers = yield* unbounded();
   yield* Effect.addFinalizer(scope, shutdown(cancelers));
   const lastDone = yield* make$3(Effect.none());
-  const errorSignal = yield* Effect.make$2();
+  const errorSignal = yield* MutableQueue.make();
   const withPermits = (yield* Effect.makeSemaphore(concurrencyN)).withPermits;
   const pull = yield* toPullIn(pipeTo(queueReader, channels), scope);
   function evaluatePull(pull) {
@@ -2223,37 +2224,37 @@ const mergeAllWith = ({
     }), Effect.flatMap$1(outDone => update(lastDone, Effect.match({
       onNone: () => Effect.some(outDone.value),
       onSome: lastDone => Effect.some(f(lastDone, outDone.value))
-    }))), Effect.catchAllCause(cause => isInterrupted(cause) ? Effect.failCause$1(cause) : offer(queue, Effect.failCause$1(cause)).pipe(Effect.zipRight$2(Effect.succeed$3(errorSignal, void 0)), Effect.asVoid$1)));
+    }))), Effect.catchAllCause(cause => isInterrupted(cause) ? Effect.failCause(cause) : offer(queue, Effect.failCause(cause)).pipe(Effect.zipRight$1(MutableQueue.succeed$1(errorSignal, void 0)), Effect.asVoid$1)));
   }
   yield* pull.pipe(Effect.matchCauseEffect({
-    onFailure: cause => offer(queue, Effect.failCause$1(cause)).pipe(Effect.zipRight$2(Effect.succeed(false))),
+    onFailure: cause => offer(queue, Effect.failCause(cause)).pipe(Effect.zipRight$1(Effect.succeed(false))),
     onSuccess: Effect.match$1({
-      onLeft: outDone => Effect.raceWith(Effect.interruptible(Effect._await(errorSignal)), Effect.interruptible(withPermits(concurrencyN)(Effect._void)), {
+      onLeft: outDone => Effect.raceWith(Effect.interruptible(MutableQueue._await(errorSignal)), Effect.interruptible(withPermits(concurrencyN)(Effect._void)), {
         onSelfDone: (_, permitAcquisition) => Effect.as(interrupt(permitAcquisition), false),
-        onOtherDone: (_, failureAwait) => Effect.zipRight$2(interrupt(failureAwait), get(lastDone).pipe(Effect.flatMap$1(Effect.match({
+        onOtherDone: (_, failureAwait) => Effect.zipRight$1(interrupt(failureAwait), get(lastDone).pipe(Effect.flatMap$1(Effect.match({
           onNone: () => offer(queue, Effect.succeed(Effect.left(outDone))),
           onSome: lastDone => offer(queue, Effect.succeed(Effect.left(f(lastDone, outDone))))
         })), Effect.as(false)))
       }),
       onRight: channel => match(mergeStrategy, {
         onBackPressure: () => Effect.gen(function* () {
-          const latch = yield* Effect.make$2();
-          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.race(Effect.exit$1(evaluatePull(pull)), Effect.exit$1(Effect.interruptible(Effect._await(errorSignal))))), Effect.flatMap$1(Effect.identity)));
-          yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(raceEffects), withPermits(1), Effect.forkIn(scope));
-          yield* Effect._await(latch);
-          const errored = yield* Effect.isDone(errorSignal);
+          const latch = yield* MutableQueue.make();
+          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.race(Effect.exit$1(evaluatePull(pull)), Effect.exit$1(Effect.interruptible(MutableQueue._await(errorSignal))))), Effect.flatMap$1(Effect.identity)));
+          yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(raceEffects), withPermits(1), Effect.forkIn(scope));
+          yield* MutableQueue._await(latch);
+          const errored = yield* MutableQueue.isDone(errorSignal);
           return !errored;
         }),
         onBufferSliding: () => Effect.gen(function* () {
-          const canceler = yield* Effect.make$2();
-          const latch = yield* Effect.make$2();
+          const canceler = yield* MutableQueue.make();
+          const latch = yield* MutableQueue.make();
           const size$1 = yield* size(cancelers);
-          yield* take(cancelers).pipe(Effect.flatMap$1(canceler => Effect.succeed$3(canceler, void 0)), Effect.when$1(() => size$1 >= concurrencyN));
+          yield* take(cancelers).pipe(Effect.flatMap$1(canceler => MutableQueue.succeed$1(canceler, void 0)), Effect.when$1(() => size$1 >= concurrencyN));
           yield* offer(cancelers, canceler);
-          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.exit$1(evaluatePull(pull)).pipe(Effect.race(Effect.exit$1(Effect.interruptible(Effect._await(errorSignal)))), Effect.race(Effect.exit$1(Effect.interruptible(Effect._await(canceler)))))), Effect.flatMap$1(Effect.identity)));
-          yield* Effect.succeed$3(latch, void 0).pipe(Effect.zipRight$2(raceEffects), withPermits(1), Effect.forkIn(scope));
-          yield* Effect._await(latch);
-          const errored = yield* Effect.isDone(errorSignal);
+          const raceEffects = Effect.scopedWith(scope => toPullIn(pipeTo(queueReader, channel), scope).pipe(Effect.flatMap$1(pull => Effect.exit$1(evaluatePull(pull)).pipe(Effect.race(Effect.exit$1(Effect.interruptible(MutableQueue._await(errorSignal)))), Effect.race(Effect.exit$1(Effect.interruptible(MutableQueue._await(canceler)))))), Effect.flatMap$1(Effect.identity)));
+          yield* MutableQueue.succeed$1(latch, void 0).pipe(Effect.zipRight$1(raceEffects), withPermits(1), Effect.forkIn(scope));
+          yield* MutableQueue._await(latch);
+          const errored = yield* MutableQueue.isDone(errorSignal);
           return !errored;
         })
       })
@@ -2285,20 +2286,20 @@ const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
           function onDecision(decision) {
             const op = decision;
             if (op._tag === OP_DONE) {
-              return Effect.succeed(fromEffect$3(Effect.zipRight$2(interrupt(fiber), op.effect)));
+              return Effect.succeed(fromEffect$3(Effect.zipRight$1(interrupt(fiber), op.effect)));
             }
-            return Effect.map$2(_await(fiber), Effect.match$2({
-              onFailure: cause => fromEffect$3(op.f(Effect.failCause(cause))),
+            return Effect.map$2(_await(fiber), MutableQueue.match({
+              onFailure: cause => fromEffect$3(op.f(MutableQueue.failCause(cause))),
               onSuccess: Effect.match$1({
-                onLeft: done => fromEffect$3(op.f(Effect.succeed$2(done))),
+                onLeft: done => fromEffect$3(op.f(MutableQueue.succeed(done))),
                 onRight: elem => zipRight(write(elem), go(single(op.f)))
               })
             }));
           }
-          return Effect.match$2(exit, {
-            onFailure: cause => onDecision(done(Effect.failCause(cause))),
+          return MutableQueue.match(exit, {
+            onFailure: cause => onDecision(done(MutableQueue.failCause(cause))),
             onSuccess: Effect.match$1({
-              onLeft: z => onDecision(done(Effect.succeed$2(z))),
+              onLeft: z => onDecision(done(MutableQueue.succeed(z))),
               onRight: elem => Effect.succeed(flatMap$1(write(elem), () => flatMap$1(fromEffect$3(Effect.forkIn(Effect.interruptible(pull), scope)), leftFiber => go(both(leftFiber, fiber)))))
             })
           });
@@ -2311,26 +2312,26 @@ const mergeWith = /*#__PURE__*/Effect.dual(2, (self, options) => {
               const leftJoin = Effect.interruptible(join(state.left));
               const rightJoin = Effect.interruptible(join(state.right));
               return unwrap(Effect.raceWith(leftJoin, rightJoin, {
-                onSelfDone: (leftExit, rf) => Effect.zipRight$2(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
-                onOtherDone: (rightExit, lf) => Effect.zipRight$2(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
+                onSelfDone: (leftExit, rf) => Effect.zipRight$1(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+                onOtherDone: (rightExit, lf) => Effect.zipRight$1(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
               }));
             }
           case OP_LEFT_DONE:
             {
-              return unwrap(Effect.map$2(Effect.exit$1(pullR), Effect.match$2({
-                onFailure: cause => fromEffect$3(state.f(Effect.failCause(cause))),
+              return unwrap(Effect.map$2(Effect.exit$1(pullR), MutableQueue.match({
+                onFailure: cause => fromEffect$3(state.f(MutableQueue.failCause(cause))),
                 onSuccess: Effect.match$1({
-                  onLeft: done => fromEffect$3(state.f(Effect.succeed$2(done))),
+                  onLeft: done => fromEffect$3(state.f(MutableQueue.succeed(done))),
                   onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
                 })
               })));
             }
           case OP_RIGHT_DONE:
             {
-              return unwrap(Effect.map$2(Effect.exit$1(pullL), Effect.match$2({
-                onFailure: cause => fromEffect$3(state.f(Effect.failCause(cause))),
+              return unwrap(Effect.map$2(Effect.exit$1(pullL), MutableQueue.match({
+                onFailure: cause => fromEffect$3(state.f(MutableQueue.failCause(cause))),
                 onSuccess: Effect.match$1({
-                  onLeft: done => fromEffect$3(state.f(Effect.succeed$2(done))),
+                  onLeft: done => fromEffect$3(state.f(MutableQueue.succeed(done))),
                   onRight: elem => flatMap$1(write(elem), () => go(RightDone(state.f)))
                 })
               })));
@@ -2373,7 +2374,7 @@ const run$1 = self => Effect.scopedWith(scope => runIn(self, scope));
 /** @internal */
 const runDrain$2 = self => run$1(drain$1(self));
 /** @internal */
-const scoped = effect => unwrap(Effect.uninterruptibleMask(restore => Effect.map$2(Effect.make$3(), scope => acquireReleaseOut(Effect.tapErrorCause(restore(Effect.extend(effect, scope)), cause => Effect.close(scope, Effect.failCause(cause))), (_, exit) => Effect.close(scope, exit)))));
+const scoped = effect => unwrap(Effect.uninterruptibleMask(restore => Effect.map$2(Effect.make$2(), scope => acquireReleaseOut(Effect.tapErrorCause(restore(Effect.extend(effect, scope)), cause => Effect.close(scope, MutableQueue.failCause(cause))), (_, exit) => Effect.close(scope, exit)))));
 /** @internal */
 const scopedWith$1 = f => unwrapScoped(Effect.map$2(Effect.scope, scope => flatMap$1(fromEffect$3(f(scope)), write)));
 /** @internal */
@@ -2387,8 +2388,8 @@ const interpretToPull = (channelState, exec) => {
   switch (state._tag) {
     case OP_DONE$1:
       {
-        return Effect.match$2(exec.getDone(), {
-          onFailure: Effect.failCause$1,
+        return MutableQueue.match(exec.getDone(), {
+          onFailure: Effect.failCause,
           onSuccess: done => Effect.succeed(Effect.left(done))
         });
       }
@@ -2402,7 +2403,7 @@ const interpretToPull = (channelState, exec) => {
       }
     case OP_READ:
       {
-        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => Effect.failCause$1(cause));
+        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => Effect.failCause(cause));
       }
   }
 };
@@ -2421,8 +2422,8 @@ const writeChunkWriter = (idx, len, chunk) => {
 /** @internal */
 const zip = /*#__PURE__*/Effect.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
   other: that,
-  onSelfDone: exit1 => Await(exit2 => Effect.suspend$1(() => Effect.zip$1(exit1, exit2))),
-  onOtherDone: exit2 => Await(exit1 => Effect.suspend$1(() => Effect.zip$1(exit1, exit2)))
+  onSelfDone: exit1 => Await(exit2 => Effect.suspend$1(() => MutableQueue.zip(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => Effect.suspend$1(() => MutableQueue.zip(exit1, exit2)))
 }) : flatMap$1(self, a => map$1(that, b => [a, b])));
 /** @internal */
 const zipRight = /*#__PURE__*/Effect.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$1(zip(self, that, {
@@ -2493,18 +2494,18 @@ class TakeImpl {
   }
 }
 /** @internal */
-const chunk = chunk => new TakeImpl(Effect.succeed$2(chunk));
+const chunk = chunk => new TakeImpl(MutableQueue.succeed(chunk));
 /** @internal */
-const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/Effect.fail$1(/*#__PURE__*/Effect.none()));
+const end$1 = /*#__PURE__*/new TakeImpl(/*#__PURE__*/MutableQueue.fail(/*#__PURE__*/Effect.none()));
 /** @internal */
-const failCause$1 = cause => new TakeImpl(Effect.failCause(Effect.pipe(cause, map$2(Effect.some))));
+const failCause$1 = cause => new TakeImpl(MutableQueue.failCause(Effect.pipe(cause, map$2(Effect.some))));
 /** @internal */
-const of = value => new TakeImpl(Effect.succeed$2(Effect.of(value)));
+const of = value => new TakeImpl(MutableQueue.succeed(Effect.of(value)));
 
 /** @internal */
-const end = () => Effect.fail$2(Effect.none());
+const end = () => Effect.fail$1(Effect.none());
 /** @internal */
-const failCause = cause => Effect.mapError(Effect.failCause$1(cause), Effect.some);
+const failCause = cause => Effect.mapError(Effect.failCause(cause), Effect.some);
 
 /** @internal */
 const StreamSymbolKey = "effect/Stream";
@@ -2539,7 +2540,7 @@ const flatMap = /*#__PURE__*/Effect.dual(args => isStream(args[0]), (self, f, op
   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 => Effect.pipe(as, Effect.map$4(a => toChannel(f(a))), Effect.reduce(void_, (left, right) => Effect.pipe(left, zipRight(right)))))), _ => new StreamImpl(Effect.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => Effect.pipe(as, Effect.map$3(a => toChannel(f(a))), Effect.reduce(void_, (left, right) => Effect.pipe(left, zipRight(right)))))), _ => new StreamImpl(Effect.pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), options))));
 });
 /** @internal */
 const matchConcurrency = (concurrency, sequential, bounded) => {
@@ -2571,10 +2572,10 @@ const flattenChunks = self => {
 /** @internal */
 const flattenExitOption = self => {
   const processChunk = (chunk, cont) => {
-    const [toEmit, rest] = Effect.pipe(chunk, Effect.splitWhere(exit => !Effect.isSuccess(exit)));
+    const [toEmit, rest] = Effect.pipe(chunk, Effect.splitWhere(exit => !MutableQueue.isSuccess(exit)));
     const next = Effect.pipe(Effect.head(rest), Effect.match({
       onNone: () => cont,
-      onSome: Effect.match$2({
+      onSome: MutableQueue.match({
         onFailure: cause => Effect.match(flipCauseOption(cause), {
           onNone: () => void_,
           onSome: failCause$2
@@ -2582,7 +2583,7 @@ const flattenExitOption = self => {
         onSuccess: () => void_
       })
     }));
-    return Effect.pipe(write(Effect.pipe(toEmit, Effect.filterMap(exit => Effect.isSuccess(exit) ? Effect.some(exit.value) : Effect.none()))), flatMap$1(() => next));
+    return Effect.pipe(write(Effect.pipe(toEmit, Effect.filterMap(exit => MutableQueue.isSuccess(exit) ? Effect.some(exit.value) : Effect.none()))), flatMap$1(() => next));
   };
   const process = readWithCause({
     onInput: chunk => processChunk(chunk, process),
@@ -2606,7 +2607,7 @@ const toChannel = stream => {
 /** @internal */
 const fromEffect = effect => Effect.pipe(effect, Effect.mapError(Effect.some), fromEffectOption);
 /** @internal */
-const fromEffectOption = effect => new StreamImpl(unwrap(Effect.match$3(effect, {
+const fromEffectOption = effect => new StreamImpl(unwrap(Effect.match$2(effect, {
   onFailure: Effect.match({
     onNone: () => void_,
     onSome: fail
@@ -2616,7 +2617,7 @@ const fromEffectOption = effect => new StreamImpl(unwrap(Effect.match$3(effect,
 /** @internal */
 const fromQueue$1 = (queue, options) => Effect.pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), Effect.catchAllCause(cause => Effect.pipe(isShutdown(queue), Effect.flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : Effect.identity);
 /** @internal */
-const map = /*#__PURE__*/Effect.dual(2, (self, f) => new StreamImpl(Effect.pipe(toChannel(self), mapOut(Effect.map$4(f)))));
+const map = /*#__PURE__*/Effect.dual(2, (self, f) => new StreamImpl(Effect.pipe(toChannel(self), mapOut(Effect.map$3(f)))));
 /** @internal */
 const mapEffectSequential = /*#__PURE__*/Effect.dual(2, (self, f) => {
   const loop = iterator => {
@@ -2639,7 +2640,7 @@ const mapEffectPar = /*#__PURE__*/Effect.dual(3, (self, n, f) => new StreamImpl(
 /** @internal */
 const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => Effect.pipe(Effect.map$2(effect, chunk => Effect.some([chunk, effect])), Effect.catchAll(Effect.match({
   onNone: () => Effect.succeed(Effect.none()),
-  onSome: Effect.fail$2
+  onSome: Effect.fail$1
 }))));
 /** @internal */
 const run = /*#__PURE__*/Effect.dual(2, (self, sink) => toChannel(self).pipe(pipeToOrFail(toChannel$1(sink)), runDrain$2));
@@ -2710,7 +2711,7 @@ const groupByKey = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "function
       if (innerQueue === undefined) {
         return Effect.pipe(bounded(options?.bufferSize ?? 16), Effect.flatMap$1(innerQueue => Effect.pipe(Effect.sync$1(() => {
           map.set(key, innerQueue);
-        }), Effect.zipRight$2(offer(outerQueue, of([key, innerQueue]))), Effect.zipRight$2(Effect.pipe(offer(innerQueue, chunk(values)), Effect.catchSomeCause(cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none()))))));
+        }), Effect.zipRight$1(offer(outerQueue, of([key, innerQueue]))), Effect.zipRight$1(Effect.pipe(offer(innerQueue, chunk(values)), Effect.catchSomeCause(cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none()))))));
       }
       return Effect.catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none());
     }, {
@@ -2719,7 +2720,7 @@ const groupByKey = /*#__PURE__*/Effect.dual(args => typeof args[0] !== "function
     onFailure: cause => fromEffect$3(offer(outerQueue, failCause$1(cause))),
     onDone: () => fromEffect$3(Effect.pipe(Effect.forEach(map.entries(), ([_, innerQueue]) => Effect.pipe(offer(innerQueue, end$1), Effect.catchSomeCause(cause => isInterruptedOnly(cause) ? Effect.some(Effect._void) : Effect.none())), {
       discard: true
-    }), Effect.zipRight$2(offer(outerQueue, end$1))))
+    }), Effect.zipRight$1(offer(outerQueue, end$1))))
   });
   return make(unwrapScopedWith(scope => Effect.gen(function* () {
     const map = new Map();