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

package/{dist/stream-e44fba40.esm.js → internal/stream.esm.js}

@@ -1,414 +1,43 @@
-import { m as map$1, g as flipCauseOption, a as failureOrCause, b as isInterrupted, d as die$2, I as IllegalArgumentException, R as RuntimeException, c as isDieType, h as isRuntimeException, s as squash } from './Cause-5946c7a3.esm.js';
-import { D as Done, A as Await } from './ChannelMergeDecision-e5f34de0.esm.js';
-import { f as fromIterable$1, o as of, e as empty$1, h as isNonEmpty, s as map$3, D as range$1, l as unsafeFromArray, E as reduceRight, p as prepend$1, i as isEmpty, A as dropWhile$1, g as filter$1, F as filterMap$1, G as filterMapWhile$1, H as findFirst, I as flatMap$3, J as takeWhile$1, K as take$3, d as drop$1, b as appendAll, w as unsafeLast, L as zipWith$2, y as reduce, c as append, C as last$1, x as splitWhere, k as head$1, M as mapAccum$1, m as make$7, u as unsafeGet$1, z as flatten$2, N as isChunk, B as splitAt, O as takeRight$1 } from './Chunk-4c1f4599.esm.js';
-import { s as sleep, a as currentTimeMillis } from './Clock-f8b987d7.esm.js';
-import { b as add, u as unsafeGet } from './Context-c41aa832.esm.js';
-import { m as make$4, _ as _await, s as succeed$2, f as failCause$5, p as poll, a as fail$4 } from './Deferred-9010d2ac.esm.js';
-import { t as toMillis, m as millis, c as greaterThan, z as zero } from './Duration-98bca14c.esm.js';
-import { w as succeed$1, a4 as die$1, F as dieMessage$1, l as suspend$1, a5 as fail$1, a6 as mapBoth$2, a7 as mapError$1, f as failCause$2, r as map$2, k as flatMap$1, d as flatten$1, j as zipRight$1, b as as$1, N as acquireRelease$1, D as all, V as when$1, A as forkScoped, y as scope, a8 as runtime, a9 as match$1, s as sync$1, e as unit$2, aa as onError$1, J as tap$1, M as gen, ab as transplant, ac as dieSync$1, O as makeSemaphore, m as matchCauseEffect, v as forEach, c as catchAllCause$2, a1 as dropUntil$1, a2 as dropWhile$2, K as context$1, ad as failSync$1, ae as failCauseSync$1, af as findFirst$1, ag as tryPromise, ah as promise, i as isEffect, t as zip$1, X as never$1, ai as orDie$1, aj as matchEffect, x as scoped$1, Q as asUnit, n as forkDaemon, o as ensuring$2, ak as timeoutFail$1, al as timeoutFailCause$1, am as runSync, an as catchTags$1, I as tapErrorCause$1, ao as runPromise, Y as withSpanScoped, T as raceWith, z as zipWith$1, ap as forkIn, aq as reduce$1, a3 as catchSomeCause$1, ar as orElse$2, C as zipLeft$1, as as catchAll$2, at as asSome, au as succeedNone, av as fork } from './Effect-ee05a487.esm.js';
-import { b as match, l as left, r as right } from './Either-aa46c018.esm.js';
-import { e as equals } from './Equal-2a99fde3.esm.js';
-import { n as mapBoth$1, m as match$3, a as failCause$4, f as fail$3, c as isSuccess, s as succeed$4, u as unit$3, e as isFailure } from './Exit-666b4f01.esm.js';
-import { j as join, i as interrupt, p as poll$1 } from './Fiber-ebef9c60.esm.js';
-import { f as constUndefined, p as pipe, d as dual, i as identity, c as constTrue } from './Function-12511160.esm.js';
-import { b as bounded$1, s as subscribe, a as shutdown$1 } from './Hub-121dbf51.esm.js';
-import { b as build, c as context$2, m as merge$1 } from './Layer-8586a429.esm.js';
-import { e as fromNullable, s as some$1, n as none, b as match$2, g as getOrElse, m as map$4, i as isSome, a as isNone } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { t as take$2, s as shutdown, b as bounded, m as dropping, n as sliding$1, i as isShutdown, k as takeBetween, c as offerAll, o as offer$1, u as unbounded } from './Queue-d99be5de.esm.js';
-import { m as make$3, a as modify, b as getAndSet, s as set, g as get, u as update } from './Ref-5eefaff1.esm.js';
-import { r as runPromiseExit } from './Runtime-7b6c0a8b.esm.js';
-import { f as forever$1, d as driver, s as spaced } from './Schedule-8502145c.esm.js';
-import { m as make$6, c as close, u as use } from './Scope-0253ac82.esm.js';
-import { f as fromInput, B as Both } from './StreamHaltStrategy-592df221.esm.js';
-import { a as readWithCause, f as flatMap$2, b as fromEffect$1, w as write, u as unwrap$1, c as failCause$3, z as zipRight$2, e as unit$1, p as pipeTo, g as run$1, h as pipeToOrFail, t as toChannel$1, i as collectElements, j as unwrapScoped$1, k as fail$2, r as runScoped$1, l as catchAllCause$1, m as concatMap, n as writeChunk, d as drain$1, o as readWith, s as suspend$2, q as identityChannel, v as succeedNow, x as ensuring$1, y as ensuringWith$1, A as succeed$3, B as mapOut, D as mapOutEffectPar, E as repeated, F as collectAllN, G as interruptWhen$1, H as interruptWhenDeferred$1, I as mapOutEffect, J as mapError$2, K as mapErrorCause$1, L as mergeWith$1, M as mkString$1, N as orDieWith$1, O as orElse$1, P as foldSink, Q as collectLeftover, R as zipRight$3, T as fromEffect$2, U as fail$5, V as fromChannel$1, W as provideContext$1, X as catchAll$1, Y as runDrain$1, Z as collectAll, _ as count, $ as drain$2, a0 as fold, a1 as foldEffect, a2 as forEach$1, a3 as forEachChunk, a4 as forEachWhile, a5 as head, a6 as last, a7 as sum, a8 as scoped$2, a9 as foldCauseChannel, aa as toPull$1, ab as fromInput$1, ac as embedInput, ad as mergeMap, ae as sync$2, af as writeAll } from './sink-637a9670.esm.js';
-import { a as BufferSliding } from './mergeStrategy-a88b5442.esm.js';
-import { m as make$5 } from './singleProducerAsyncInput-5b2ede75.esm.js';
-import './GlobalValue-b5edf230.esm.js';
-import './Effectable-a292d920.esm.js';
-import './Differ-a249bf4d.esm.js';
-import './timeout-4180303d.esm.js';
-import { d as done, m as match$4, c as chunk, f as failCause$6, e as end$2, a as fromPull$1, o as of$1 } from './take-0d5e0eab.esm.js';
-
-/** @internal */
-class RingBuffer {
-  size = 0;
-  current = 0;
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.array = Array.from({
-      length: capacity
-    }, constUndefined);
-  }
-  head() {
-    return fromNullable(this.array[this.current]);
-  }
-  lastOrNull() {
-    if (this.size === 0) {
-      return undefined;
-    }
-    const index = this.current === 0 ? this.array.length - 1 : this.current - 1;
-    return this.array[index] ?? undefined;
-  }
-  put(value) {
-    this.array[this.current] = value;
-    this.increment();
-  }
-  dropLast() {
-    if (this.size > 0) {
-      this.decrement();
-      this.array[this.current] = undefined;
-    }
-  }
-  toChunk() {
-    const begin = this.current - this.size;
-    const newArray = begin < 0 ? [...this.array.slice(this.capacity + begin, this.capacity), ...this.array.slice(0, this.current)] : this.array.slice(begin, this.current);
-    return fromIterable$1(newArray);
-  }
-  increment() {
-    if (this.size < this.capacity) {
-      this.size += 1;
-    }
-    this.current = (this.current + 1) % this.capacity;
-  }
-  decrement() {
-    this.size -= 1;
-    if (this.current > 0) {
-      this.current -= 1;
-    } else {
-      this.current = this.capacity - 1;
-    }
-  }
-}
-
-/** @internal */
-
-/** @internal */
-const OP_NOT_STARTED = "NotStarted";
-
-/** @internal */
-
-/** @internal */
-const OP_PREVIOUS = "Previous";
-
-/** @internal */
-
-/** @internal */
-const OP_CURRENT = "Current";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const notStarted = {
-  _tag: OP_NOT_STARTED
-};
-
-/** @internal */
-const previous = fiber => ({
-  _tag: OP_PREVIOUS,
-  fiber
-});
-
-/** @internal */
-const current = fiber => ({
-  _tag: OP_CURRENT,
-  fiber
-});
-
-/** @internal */
-const make$2 = emit => {
-  const ops = {
-    chunk(as) {
-      return this(succeed$1(as));
-    },
-    die(defect) {
-      return this(die$1(defect));
-    },
-    dieMessage(message) {
-      return this(dieMessage$1(message));
-    },
-    done(exit) {
-      return this(suspend$1(() => mapBoth$1(exit, {
-        onFailure: some$1,
-        onSuccess: of
-      })));
-    },
-    end() {
-      return this(fail$1(none()));
-    },
-    fail(e) {
-      return this(fail$1(some$1(e)));
-    },
-    fromEffect(effect) {
-      return this(mapBoth$2(effect, {
-        onFailure: some$1,
-        onSuccess: of
-      }));
-    },
-    fromEffectChunk(effect) {
-      return this(pipe(effect, mapError$1(some$1)));
-    },
-    halt(cause) {
-      return this(failCause$2(pipe(cause, map$1(some$1))));
-    },
-    single(value) {
-      return this(succeed$1(of(value)));
-    }
-  };
-  return Object.assign(emit, ops);
-};
-
-/** @internal */
-const HandoffTypeId = /*#__PURE__*/Symbol.for("effect/Stream/Handoff");
-
-/** @internal */
-
-/**
- * A synchronous queue-like abstraction that allows a producer to offer an
- * element and wait for it to be taken, and allows a consumer to wait for an
- * element to be available.
- *
- * @internal
- */
-
-/** @internal */
-const OP_HANDOFF_STATE_EMPTY = "Empty";
-
-/** @internal */
-
-/** @internal */
-const OP_HANDOFF_STATE_FULL = "Full";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const handoffStateEmpty = notifyConsumer => ({
-  _tag: OP_HANDOFF_STATE_EMPTY,
-  notifyConsumer
-});
-
-/** @internal */
-const handoffStateFull = (value, notifyProducer) => ({
-  _tag: OP_HANDOFF_STATE_FULL,
-  value,
-  notifyProducer
-});
-
-/** @internal */
-const handoffStateMatch = (onEmpty, onFull) => {
-  return self => {
-    switch (self._tag) {
-      case OP_HANDOFF_STATE_EMPTY:
-        {
-          return onEmpty(self.notifyConsumer);
-        }
-      case OP_HANDOFF_STATE_FULL:
-        {
-          return onFull(self.value, self.notifyProducer);
-        }
-    }
-  };
-};
-
-/** @internal */
-const handoffVariance = {
-  _A: _ => _
-};
-
-/** @internal */
-const make$1 = () => pipe(make$4(), flatMap$1(deferred => make$3(handoffStateEmpty(deferred))), map$2(ref => ({
-  [HandoffTypeId]: handoffVariance,
-  ref
-})));
-
-/** @internal */
-const offer = /*#__PURE__*/dual(2, (self, value) => {
-  return flatMap$1(make$4(), deferred => flatten$1(modify(self.ref, state => pipe(state, handoffStateMatch(notifyConsumer => [zipRight$1(succeed$2(notifyConsumer, void 0), _await(deferred)), handoffStateFull(value, deferred)], (_, notifyProducer) => [flatMap$1(_await(notifyProducer), () => pipe(self, offer(value))), state])))));
-});
-
-/** @internal */
-const take$1 = self => flatMap$1(make$4(), deferred => flatten$1(modify(self.ref, state => pipe(state, handoffStateMatch(notifyConsumer => [flatMap$1(_await(notifyConsumer), () => take$1(self)), state], (value, notifyProducer) => [as$1(succeed$2(notifyProducer, void 0), value), handoffStateEmpty(deferred)])))));
-
-/** @internal */
-
-/** @internal */
-const OP_EMIT = "Emit";
-
-/** @internal */
-
-/** @internal */
-const OP_HALT = "Halt";
-
-/** @internal */
-
-/** @internal */
-const OP_END = "End";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const emit = elements => ({
-  _tag: OP_EMIT,
-  elements
-});
-
-/** @internal */
-const halt = cause => ({
-  _tag: OP_HALT,
-  cause
-});
-
-/** @internal */
-const end$1 = reason => ({
-  _tag: OP_END,
-  reason
-});
-
-/** @internal */
-const end = () => fail$1(none());
-
-/** @internal */
-const failCause$1 = cause => mapError$1(failCause$2(cause), some$1);
-
-/** @internal */
-
-/** @internal */
-const OP_SCHEDULE_END = "ScheduleEnd";
-
-/** @internal */
-
-/** @internal */
-const OP_UPSTREAM_END = "UpstreamEnd";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const ScheduleEnd = {
-  _tag: OP_SCHEDULE_END
-};
-
-/** @internal */
-const UpstreamEnd = {
-  _tag: OP_UPSTREAM_END
-};
-
-/** @internal */
-
-/** @internal */
-const OP_DRAIN_LEFT = "DrainLeft";
-
-/** @internal */
-
-/** @internal */
-const OP_DRAIN_RIGHT = "DrainRight";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_BOTH$1 = "PullBoth";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_LEFT$1 = "PullLeft";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_RIGHT$1 = "PullRight";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const DrainLeft = {
-  _tag: OP_DRAIN_LEFT
-};
-
-/** @internal */
-const DrainRight = {
-  _tag: OP_DRAIN_RIGHT
-};
-
-/** @internal */
-const PullBoth$1 = {
-  _tag: OP_PULL_BOTH$1
-};
-
-/** @internal */
-const PullLeft$1 = rightChunk => ({
-  _tag: OP_PULL_LEFT$1,
-  rightChunk
-});
-
-/** @internal */
-const PullRight$1 = leftChunk => ({
-  _tag: OP_PULL_RIGHT$1,
-  leftChunk
-});
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_BOTH = "PullBoth";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_LEFT = "PullLet";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_RIGHT = "PullRight";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const PullBoth = {
-  _tag: OP_PULL_BOTH
-};
-
-/** @internal */
-const PullLeft = rightChunk => ({
-  _tag: OP_PULL_LEFT,
-  rightChunk
-});
-
-/** @internal */
-const PullRight = leftChunk => ({
-  _tag: OP_PULL_RIGHT,
-  leftChunk
-});
+import { flipCauseOption, failureOrCause, map as map$3, isInterrupted, die as die$2, IllegalArgumentException, RuntimeException, isDieType, isRuntimeException, squash } from '../Cause/dist/effect-Cause.esm.js';
+import { Done, Await } from '../ChannelMergeDecision/dist/effect-ChannelMergeDecision.esm.js';
+import { empty as empty$1, isNonEmpty, of, map as map$2, range as range$1, unsafeFromArray, reduceRight, prepend as prepend$1, isEmpty, dropWhile as dropWhile$1, filter as filter$1, filterMap as filterMap$1, filterMapWhile as filterMapWhile$1, findFirst, fromIterable as fromIterable$1, flatMap as flatMap$3, takeWhile as takeWhile$1, take as take$3, drop as drop$1, appendAll, unsafeLast, zipWith as zipWith$2, reduce, append, last as last$1, splitWhere, head as head$1, mapAccum as mapAccum$1, make as make$7, unsafeGet as unsafeGet$1, flatten as flatten$2, isChunk, splitAt, takeRight as takeRight$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { sleep, currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
+import { add, unsafeGet } from '../Context/dist/effect-Context.esm.js';
+import { make as make$4, succeed as succeed$2, await as _await, failCause as failCause$3, poll, fail as fail$4 } from '../Deferred/dist/effect-Deferred.esm.js';
+import { toMillis, millis, greaterThan, zero } from '../Duration/dist/effect-Duration.esm.js';
+import { acquireRelease as acquireRelease$1, all, when as when$1, flatMap as flatMap$2, zipRight as zipRight$1, succeed as succeed$1, map as map$1, forkScoped, scope, runtime, match as match$1, sync as sync$1, as as as$1, unit as unit$2, onError as onError$1, tap as tap$1, gen, suspend as suspend$1, transplant, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, makeSemaphore, matchCauseEffect, flatten as flatten$1, forEach, catchAllCause as catchAllCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, fail as fail$3, failSync as failSync$1, failCause as failCause$4, failCauseSync as failCauseSync$1, findFirst as findFirst$1, tryPromise, promise, isEffect, mapError as mapError$1, zip as zip$1, never as never$1, orDie as orDie$1, matchEffect, scoped as scoped$1, asUnit, forkDaemon, ensuring as ensuring$2, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, runSync, catchTags as catchTags$1, tapErrorCause as tapErrorCause$1, runPromise, withSpanScoped, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, orElse as orElse$2, zipLeft as zipLeft$1, catchAll as catchAll$2, asSome, succeedNone, fork } from '../Effect/dist/effect-Effect.esm.js';
+import { match, left, right } from '../Either/dist/effect-Either.esm.js';
+import { equals } from '../Equal/dist/effect-Equal.esm.js';
+import { match as match$3, failCause as failCause$2, fail as fail$2, isSuccess, succeed as succeed$4, unit as unit$3, isFailure } from '../Exit/dist/effect-Exit.esm.js';
+import { join, interrupt, poll as poll$1 } from '../Fiber/dist/effect-Fiber.esm.js';
+import { dual, pipe, identity, constTrue } from '../Function/dist/effect-Function.esm.js';
+import { bounded as bounded$1, subscribe, shutdown as shutdown$1 } from '../Hub/dist/effect-Hub.esm.js';
+import { build, context as context$2, merge as merge$1 } from '../Layer/dist/effect-Layer.esm.js';
+import { none, some as some$1, match as match$2, getOrElse, map as map$4, isSome, isNone } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { take as take$2, shutdown, bounded, dropping, sliding as sliding$1, isShutdown, takeBetween, offerAll, offer as offer$1, unbounded } from '../Queue/dist/effect-Queue.esm.js';
+import { make as make$2, getAndSet, set, get, update, modify } from '../Ref/dist/effect-Ref.esm.js';
+import { runPromiseExit } from '../Runtime/dist/effect-Runtime.esm.js';
+import { forever as forever$1, driver, spaced } from '../Schedule/dist/effect-Schedule.esm.js';
+import { make as make$6, close, use } from '../Scope/dist/effect-Scope.esm.js';
+import { Both } from '../StreamHaltStrategy/dist/effect-StreamHaltStrategy.esm.js';
+import { unwrap as unwrap$1, zipRight as zipRight$2, pipeToOrFail, unwrapScoped as unwrapScoped$1, concatMap, writeChunk, drain as drain$1, identityChannel, ensuring as ensuring$1, mapOut, mapOutEffectPar, repeated, interruptWhen as interruptWhen$1, interruptWhenDeferred as interruptWhenDeferred$1, mapOutEffect, mapError as mapError$2, mapErrorCause as mapErrorCause$1, mergeWith as mergeWith$1, orDieWith as orDieWith$1, orElse as orElse$1, catchAll as catchAll$1, runDrain as runDrain$1, scoped as scoped$2, toPull as toPull$1, fromInput as fromInput$1, mergeMap, writeAll } from './channel.esm.js';
+import { run as run$1, runScoped as runScoped$1 } from './channel/channelExecutor.esm.js';
+import { BufferSliding } from './channel/mergeStrategy.esm.js';
+import { make as make$5 } from './channel/singleProducerAsyncInput.esm.js';
+import { readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, pipeTo, collectElements, fail as fail$1, catchAllCause as catchAllCause$1, readWith, suspend as suspend$2, succeedNow, ensuringWith as ensuringWith$1, succeed as succeed$3, provideContext as provideContext$1, foldCauseChannel, embedInput, sync as sync$2 } from './core-stream.esm.js';
+import { RingBuffer } from './ringBuffer.esm.js';
+import { toChannel as toChannel$1, collectAllN, mkString as mkString$1, foldSink, collectLeftover, zipRight as zipRight$3, fromEffect as fromEffect$2, fail as fail$5, fromChannel as fromChannel$1, collectAll, count, drain as drain$2, fold, foldEffect, forEach as forEach$1, forEachChunk, forEachWhile, head, last, sum } from './sink.esm.js';
+import { OP_CURRENT, OP_PREVIOUS, current, OP_NOT_STARTED, notStarted, previous } from './stream/debounceState.esm.js';
+import { make as make$3 } from './stream/emit.esm.js';
+import { fromInput } from './stream/haltStrategy.esm.js';
+import { make as make$1, offer, take as take$1 } from './stream/handoff.esm.js';
+import { emit, halt, end, OP_END, OP_HALT, OP_EMIT } from './stream/handoffSignal.esm.js';
+import { end as end$1, failCause as failCause$5 } from './stream/pull.esm.js';
+import { ScheduleEnd, OP_SCHEDULE_END, UpstreamEnd, OP_UPSTREAM_END } from './stream/sinkEndReason.esm.js';
+import { PullBoth, OP_PULL_RIGHT, DrainLeft, PullRight, OP_PULL_LEFT, DrainRight, PullLeft, OP_PULL_BOTH, OP_DRAIN_RIGHT, OP_DRAIN_LEFT } from './stream/zipAllState.esm.js';
+import { PullBoth as PullBoth$1, OP_PULL_RIGHT as OP_PULL_RIGHT$1, PullRight as PullRight$1, PullLeft as PullLeft$1, OP_PULL_LEFT as OP_PULL_LEFT$1, OP_PULL_BOTH as OP_PULL_BOTH$1 } from './stream/zipChunksState.esm.js';
+import { done, match as match$4, chunk, failCause as failCause$6, end as end$2, fromPull as fromPull$1, of as of$1 } from './take.esm.js';
 
 /** @internal */
 const StreamSymbolKey = "effect/Stream";
@@ -454,31 +83,31 @@ const aggregateWithin = /*#__PURE__*/dual(3, (self, sink, schedule) => filterMap
 
 /** @internal */
 const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule) => {
-  const layer = all([make$1(), make$3(ScheduleEnd), make$3(empty$1()), driver(schedule), make$3(false), make$3(false)]);
+  const layer = all([make$1(), make$2(ScheduleEnd), make$2(empty$1()), driver(schedule), make$2(false), make$2(false)]);
   return pipe(fromEffect(layer), flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
     const handoffProducer = readWithCause({
-      onInput: input => flatMap$2(fromEffect$1(pipe(handoff, offer(emit(input)), when$1(() => isNonEmpty(input)))), () => handoffProducer),
+      onInput: input => flatMap$1(fromEffect$1(pipe(handoff, offer(emit(input)), when$1(() => isNonEmpty(input)))), () => handoffProducer),
       onFailure: cause => fromEffect$1(offer(handoff, halt(cause))),
-      onDone: () => fromEffect$1(offer(handoff, end$1(UpstreamEnd)))
+      onDone: () => fromEffect$1(offer(handoff, end(UpstreamEnd)))
     });
-    const handoffConsumer = pipe(getAndSet(sinkLeftovers, empty$1()), flatMap$1(leftovers => {
+    const handoffConsumer = pipe(getAndSet(sinkLeftovers, empty$1()), flatMap$2(leftovers => {
       if (isNonEmpty(leftovers)) {
-        return pipe(set(consumed, true), zipRight$1(succeed$1(pipe(write(leftovers), flatMap$2(() => handoffConsumer)))));
+        return pipe(set(consumed, true), zipRight$1(succeed$1(pipe(write(leftovers), flatMap$1(() => handoffConsumer)))));
       }
-      return pipe(take$1(handoff), map$2(signal => {
+      return pipe(take$1(handoff), map$1(signal => {
         switch (signal._tag) {
           case OP_EMIT:
             {
-              return pipe(fromEffect$1(set(consumed, true)), zipRight$2(write(signal.elements)), zipRight$2(fromEffect$1(get(endAfterEmit))), flatMap$2(bool => bool ? unit$1 : handoffConsumer));
+              return pipe(fromEffect$1(set(consumed, true)), zipRight$2(write(signal.elements)), zipRight$2(fromEffect$1(get(endAfterEmit))), flatMap$1(bool => bool ? unit$1 : handoffConsumer));
             }
           case OP_HALT:
             {
-              return failCause$3(signal.cause);
+              return failCause$1(signal.cause);
             }
           case OP_END:
             {
               if (signal.reason._tag === OP_SCHEDULE_END) {
-                return pipe(get(consumed), map$2(bool => bool ? fromEffect$1(pipe(set(sinkEndReason, ScheduleEnd), zipRight$1(set(endAfterEmit, true)))) : pipe(fromEffect$1(pipe(set(sinkEndReason, ScheduleEnd), zipRight$1(set(endAfterEmit, true)))), flatMap$2(() => handoffConsumer))), unwrap$1);
+                return pipe(get(consumed), map$1(bool => bool ? fromEffect$1(pipe(set(sinkEndReason, ScheduleEnd), zipRight$1(set(endAfterEmit, true)))) : pipe(fromEffect$1(pipe(set(sinkEndReason, ScheduleEnd), zipRight$1(set(endAfterEmit, true)))), flatMap$1(() => handoffConsumer))), unwrap$1);
               }
               return pipe(set(sinkEndReason, signal.reason), zipRight$1(set(endAfterEmit, true)), fromEffect$1);
             }
@@ -488,39 +117,39 @@ const aggregateWithinEither = /*#__PURE__*/dual(3, (self, sink, schedule) => {
     const timeout = lastB => scheduleDriver.next(lastB);
     const scheduledAggregator = (sinkFiber, scheduleFiber, scope) => {
       const forkSink = pipe(set(consumed, false), zipRight$1(set(endAfterEmit, false)), zipRight$1(pipe(handoffConsumer, pipeToOrFail(toChannel$1(sink)), collectElements, run$1, forkIn(scope))));
-      const handleSide = (leftovers, b, c) => pipe(set(sinkLeftovers, flatten$2(leftovers)), zipRight$1(map$2(get(sinkEndReason), reason => {
+      const handleSide = (leftovers, b, c) => pipe(set(sinkLeftovers, flatten$2(leftovers)), zipRight$1(map$1(get(sinkEndReason), reason => {
         switch (reason._tag) {
           case OP_SCHEDULE_END:
             {
-              return pipe(all([get(consumed), forkSink, pipe(timeout(some$1(b)), forkIn(scope))]), map$2(([wasConsumed, sinkFiber, scheduleFiber]) => {
+              return pipe(all([get(consumed), forkSink, pipe(timeout(some$1(b)), forkIn(scope))]), map$1(([wasConsumed, sinkFiber, scheduleFiber]) => {
                 const toWrite = pipe(c, match$2({
                   onNone: () => of(right(b)),
                   onSome: c => make$7(right(b), left(c))
                 }));
                 if (wasConsumed) {
-                  return pipe(write(toWrite), flatMap$2(() => scheduledAggregator(sinkFiber, scheduleFiber, scope)));
+                  return pipe(write(toWrite), flatMap$1(() => scheduledAggregator(sinkFiber, scheduleFiber, scope)));
                 }
                 return scheduledAggregator(sinkFiber, scheduleFiber, scope);
               }), unwrap$1);
             }
           case OP_UPSTREAM_END:
             {
-              return pipe(get(consumed), map$2(wasConsumed => wasConsumed ? write(of(right(b))) : unit$1), unwrap$1);
+              return pipe(get(consumed), map$1(wasConsumed => wasConsumed ? write(of(right(b))) : unit$1), unwrap$1);
             }
         }
       })), unwrap$1);
       return unwrap$1(raceWith(join(sinkFiber), join(scheduleFiber), {
-        onSelfDone: (sinkExit, _) => pipe(interrupt(scheduleFiber), zipRight$1(pipe(suspend$1(() => sinkExit), map$2(([leftovers, b]) => handleSide(leftovers, b, none()))))),
+        onSelfDone: (sinkExit, _) => pipe(interrupt(scheduleFiber), zipRight$1(pipe(suspend$1(() => sinkExit), map$1(([leftovers, b]) => handleSide(leftovers, b, none()))))),
         onOtherDone: (scheduleExit, _) => matchCauseEffect(suspend$1(() => scheduleExit), {
           onFailure: cause => match(failureOrCause(cause), {
-            onLeft: () => pipe(handoff, offer(end$1(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([leftovers, b]) => handleSide(leftovers, b, none()))))),
-            onRight: cause => pipe(handoff, offer(halt(cause)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([leftovers, b]) => handleSide(leftovers, b, none())))))
+            onLeft: () => pipe(handoff, offer(end(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$1(([leftovers, b]) => handleSide(leftovers, b, none()))))),
+            onRight: cause => pipe(handoff, offer(halt(cause)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$1(([leftovers, b]) => handleSide(leftovers, b, none())))))
           }),
-          onSuccess: c => pipe(handoff, offer(end$1(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([leftovers, b]) => handleSide(leftovers, b, some$1(c))))))
+          onSuccess: c => pipe(handoff, offer(end(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$1(([leftovers, b]) => handleSide(leftovers, b, some$1(c))))))
         })
       }));
     };
-    return unwrapScoped(pipe(self, toChannel, pipeTo(handoffProducer), run$1, forkScoped, zipRight$1(pipe(handoffConsumer, pipeToOrFail(toChannel$1(sink)), collectElements, run$1, forkScoped, flatMap$1(sinkFiber => pipe(forkScoped(timeout(none())), flatMap$1(scheduleFiber => pipe(scope, map$2(scope => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))))));
+    return unwrapScoped(pipe(self, toChannel, pipeTo(handoffProducer), run$1, forkScoped, zipRight$1(pipe(handoffConsumer, pipeToOrFail(toChannel$1(sink)), collectElements, run$1, forkScoped, flatMap$2(sinkFiber => pipe(forkScoped(timeout(none())), flatMap$2(scheduleFiber => pipe(scope, map$1(scope => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))))));
   }));
 });
 
@@ -534,38 +163,38 @@ const _async = (register, outputBuffer = 16) => asyncOption(cb => {
 }, outputBuffer);
 
 /** @internal */
-const asyncEffect = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$1(output => pipe(runtime(), flatMap$1(runtime => pipe(register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+const asyncEffect = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$2(output => pipe(runtime(), flatMap$2(runtime => pipe(register(make$3(k => pipe(fromPull$1(k), flatMap$2(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
   if (isFailure(exit)) {
     if (!isInterrupted(exit.cause)) {
       throw squash(exit.cause);
     }
   }
-}))), map$2(() => {
-  const loop = pipe(take$2(output), flatMap$1(done), match$1({
+}))), map$1(() => {
+  const loop = pipe(take$2(output), flatMap$2(done), match$1({
     onFailure: maybeError => pipe(fromEffect$1(shutdown(output)), zipRight$2(match$2(maybeError, {
       onNone: () => unit$1,
-      onSome: fail$2
+      onSome: fail$1
     }))),
-    onSuccess: chunk => pipe(write(chunk), flatMap$2(() => loop))
+    onSuccess: chunk => pipe(write(chunk), flatMap$1(() => loop))
   }), unwrap$1);
   return loop;
 }))))), unwrapScoped$1, fromChannel);
 
 /** @internal */
-const asyncInterrupt = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$1(output => pipe(runtime(), flatMap$1(runtime => pipe(sync$1(() => register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+const asyncInterrupt = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$2(output => pipe(runtime(), flatMap$2(runtime => pipe(sync$1(() => register(make$3(k => pipe(fromPull$1(k), flatMap$2(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
   if (isFailure(exit)) {
     if (!isInterrupted(exit.cause)) {
       throw squash(exit.cause);
     }
   }
-})))), map$2(match({
+})))), map$1(match({
   onLeft: canceler => {
-    const loop = pipe(take$2(output), flatMap$1(done), match$1({
+    const loop = pipe(take$2(output), flatMap$2(done), match$1({
       onFailure: maybeError => zipRight$2(fromEffect$1(shutdown(output)), match$2(maybeError, {
         onNone: () => unit$1,
-        onSome: fail$2
+        onSome: fail$1
       })),
-      onSuccess: chunk => pipe(write(chunk), flatMap$2(() => loop))
+      onSuccess: chunk => pipe(write(chunk), flatMap$1(() => loop))
     }), unwrap$1);
     return pipe(fromChannel(loop), ensuring(canceler));
   },
@@ -579,13 +208,13 @@ const asyncOption = (register, outputBuffer = 16) => asyncInterrupt(emit => matc
 }), outputBuffer);
 
 /** @internal */
-const asyncScoped = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$1(output => pipe(runtime(), flatMap$1(runtime => pipe(register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+const asyncScoped = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$2(output => pipe(runtime(), flatMap$2(runtime => pipe(register(make$3(k => pipe(fromPull$1(k), flatMap$2(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
   if (isFailure(exit)) {
     if (!isInterrupted(exit.cause)) {
       throw squash(exit.cause);
     }
   }
-}))), zipRight$1(make$3(false)), flatMap$1(ref => pipe(get(ref), map$2(isDone => isDone ? end() : pipe(take$2(output), flatMap$1(done), onError$1(() => pipe(set(ref, true), zipRight$1(shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
+}))), zipRight$1(make$2(false)), flatMap$2(ref => pipe(get(ref), map$1(isDone => isDone ? end$1() : pipe(take$2(output), flatMap$2(done), onError$1(() => pipe(set(ref, true), zipRight$1(shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
 
 /** @internal */
 const branchAfter = /*#__PURE__*/dual(3, (self, n, f) => suspend(() => {
@@ -598,7 +227,7 @@ const branchAfter = /*#__PURE__*/dual(3, (self, n, f) => suspend(() => {
       }
       return buffering(pipe(acc, appendAll(input)));
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => running(acc, empty$1())
   });
   const running = (prefix, leftover) => pipeTo(zipRight$2(write(leftover), identityChannel()), toChannel(f(prefix)));
@@ -606,20 +235,20 @@ const branchAfter = /*#__PURE__*/dual(3, (self, n, f) => suspend(() => {
 }));
 
 /** @internal */
-const broadcast = /*#__PURE__*/dual(3, (self, n, maximumLag) => pipe(self, broadcastedQueues(n, maximumLag), map$2(tuple => tuple.map(queue => flattenTake(fromQueue(queue, {
+const broadcast = /*#__PURE__*/dual(3, (self, n, maximumLag) => pipe(self, broadcastedQueues(n, maximumLag), map$1(tuple => tuple.map(queue => flattenTake(fromQueue(queue, {
   shutdown: true
 }))))));
 
 /** @internal */
-const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => pipe(self, broadcastedQueuesDynamic(maximumLag), map$2(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
+const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => pipe(self, broadcastedQueuesDynamic(maximumLag), map$1(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
 
 /** @internal */
-const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => flatMap$1(bounded$1(maximumLag), hub => pipe(all(Array.from({
+const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => flatMap$2(bounded$1(maximumLag), hub => pipe(all(Array.from({
   length: n
 }, () => subscribe(hub))), tap$1(() => forkScoped(runIntoHubScoped(self, hub))))));
 
 /** @internal */
-const broadcastedQueuesDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => map$2(toHub(self, maximumLag), subscribe));
+const broadcastedQueuesDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => map$1(toHub(self, maximumLag), subscribe));
 
 /** @internal */
 const buffer = /*#__PURE__*/dual(2, (self, options) => {
@@ -631,13 +260,13 @@ const buffer = /*#__PURE__*/dual(2, (self, options) => {
     return bufferSliding(self, options.capacity);
   }
   const queue = toQueueOfElements(self, options);
-  return new StreamImpl(unwrapScoped$1(map$2(queue, queue => {
-    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$3({
+  return new StreamImpl(unwrapScoped$1(map$1(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$1(match$3({
       onFailure: cause => pipe(flipCauseOption(cause), match$2({
         onNone: () => unit$1,
-        onSome: failCause$3
+        onSome: failCause$1
       })),
-      onSuccess: value => flatMap$2(write(of(value)), () => process)
+      onSuccess: value => flatMap$1(write(of(value)), () => process)
     })));
     return process;
   })));
@@ -651,11 +280,11 @@ const bufferChunks = /*#__PURE__*/dual(2, (self, options) => {
     return bufferChunksSliding(self, options.capacity);
   }
   const queue = toQueue(self, options);
-  return new StreamImpl(unwrapScoped$1(map$2(queue, queue => {
-    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$4({
+  return new StreamImpl(unwrapScoped$1(map$1(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$1(match$4({
       onEnd: () => unit$1,
-      onFailure: failCause$3,
-      onSuccess: value => pipe(write(value), flatMap$2(() => process))
+      onFailure: failCause$1,
+      onSuccess: value => pipe(write(value), flatMap$1(() => process))
     })));
     return process;
   })));
@@ -680,11 +309,11 @@ const bufferUnbounded = self => {
   const queue = toQueue(self, {
     strategy: "unbounded"
   });
-  return new StreamImpl(unwrapScoped$1(map$2(queue, queue => {
-    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$4({
+  return new StreamImpl(unwrapScoped$1(map$1(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$1(match$4({
       onEnd: () => unit$1,
-      onFailure: failCause$3,
-      onSuccess: value => flatMap$2(write(value), () => process)
+      onFailure: failCause$1,
+      onSuccess: value => flatMap$1(write(value), () => process)
     })));
     return process;
   })));
@@ -693,22 +322,22 @@ const bufferUnbounded = self => {
 /** @internal */
 const bufferSignal = (scoped, bufferChannel) => {
   const producer = (queue, ref) => {
-    const terminate = take => pipe(get(ref), tap$1(_await), zipRight$1(make$4()), flatMap$1(deferred => pipe(offer$1(queue, [take, deferred]), zipRight$1(set(ref, deferred)), zipRight$1(_await(deferred)))), asUnit, fromEffect$1);
+    const terminate = take => pipe(get(ref), tap$1(_await), zipRight$1(make$4()), flatMap$2(deferred => pipe(offer$1(queue, [take, deferred]), zipRight$1(set(ref, deferred)), zipRight$1(_await(deferred)))), asUnit, fromEffect$1);
     return readWithCause({
-      onInput: input => pipe(make$4(), flatMap$1(deferred => pipe(offer$1(queue, [chunk(input), deferred]), flatMap$1(added => pipe(set(ref, deferred), when$1(() => added))))), asUnit, fromEffect$1, flatMap$2(() => producer(queue, ref))),
+      onInput: input => pipe(make$4(), flatMap$2(deferred => pipe(offer$1(queue, [chunk(input), deferred]), flatMap$2(added => pipe(set(ref, deferred), when$1(() => added))))), asUnit, fromEffect$1, flatMap$1(() => producer(queue, ref))),
       onFailure: error => terminate(failCause$6(error)),
       onDone: () => terminate(end$2)
     });
   };
   const consumer = queue => {
-    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(([take, deferred]) => zipRight$2(fromEffect$1(succeed$2(deferred, void 0)), match$4(take, {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$1(([take, deferred]) => zipRight$2(fromEffect$1(succeed$2(deferred, void 0)), match$4(take, {
       onEnd: () => unit$1,
-      onFailure: failCause$3,
-      onSuccess: value => pipe(write(value), flatMap$2(() => process))
+      onFailure: failCause$1,
+      onSuccess: value => pipe(write(value), flatMap$1(() => process))
     }))));
     return process;
   };
-  return unwrapScoped$1(pipe(scoped, flatMap$1(queue => pipe(make$4(), tap$1(start => succeed$2(start, void 0)), flatMap$1(start => pipe(make$3(start), flatMap$1(ref => pipe(bufferChannel, pipeTo(producer(queue, ref)), runScoped$1, forkScoped)), as$1(consumer(queue))))))));
+  return unwrapScoped$1(pipe(scoped, flatMap$2(queue => pipe(make$4(), tap$1(start => succeed$2(start, void 0)), flatMap$2(start => pipe(make$2(start), flatMap$2(ref => pipe(bufferChannel, pipeTo(producer(queue, ref)), runScoped$1, forkScoped)), as$1(consumer(queue))))))));
 };
 
 /** @internal */
@@ -756,9 +385,9 @@ const changesWith = /*#__PURE__*/dual(2, (self, f) => {
         }
         return [some$1(output), pipe(outputs, append(output))];
       });
-      return flatMap$2(write(newChunk), () => writer(newLast));
+      return flatMap$1(write(newChunk), () => writer(newLast));
     },
-    onFailure: failCause$3,
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(writer(none()))));
@@ -769,11 +398,11 @@ const changesWithEffect = /*#__PURE__*/dual(2, (self, f) => {
   const writer = last => readWithCause({
     onInput: input => pipe(input, reduce$1([last, empty$1()], ([option, outputs], output) => {
       if (isSome(option)) {
-        return pipe(f(option.value, output), map$2(bool => bool ? [some$1(output), outputs] : [some$1(output), pipe(outputs, append(output))]));
+        return pipe(f(option.value, output), map$1(bool => bool ? [some$1(output), outputs] : [some$1(output), pipe(outputs, append(output))]));
       }
       return succeed$1([some$1(output), pipe(outputs, append(output))]);
-    }), fromEffect$1, flatMap$2(([newLast, newChunk]) => pipe(write(newChunk), flatMap$2(() => writer(newLast))))),
-    onFailure: failCause$3,
+    }), fromEffect$1, flatMap$1(([newLast, newChunk]) => pipe(write(newChunk), flatMap$1(() => writer(newLast))))),
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(writer(none()))));
@@ -784,14 +413,14 @@ const chunks = self => pipe(self, mapChunks(of));
 
 /** @internal */
 const chunksWith = /*#__PURE__*/dual(2, (self, f) => flattenChunks(f(chunks(self))));
-const unsome = effect => catchAll$2(asSome(effect), o => o._tag === "None" ? succeedNone : fail$1(o.value));
+const unsome = effect => catchAll$2(asSome(effect), o => o._tag === "None" ? succeedNone : fail$3(o.value));
 
 /** @internal */
 const combine = /*#__PURE__*/dual(4, (self, that, s, f) => {
   const producer = (handoff, latch) => pipe(fromEffect$1(take$1(latch)), zipRight$2(readWithCause({
-    onInput: input => flatMap$2(fromEffect$1(pipe(handoff, offer(succeed$4(input)))), () => producer(handoff, latch)),
-    onFailure: cause => fromEffect$1(offer(handoff, failCause$4(pipe(cause, map$1(some$1))))),
-    onDone: () => flatMap$2(fromEffect$1(offer(handoff, fail$3(none()))), () => producer(handoff, latch))
+    onInput: input => flatMap$1(fromEffect$1(pipe(handoff, offer(succeed$4(input)))), () => producer(handoff, latch)),
+    onFailure: cause => fromEffect$1(offer(handoff, failCause$2(pipe(cause, map$3(some$1))))),
+    onDone: () => flatMap$1(fromEffect$1(offer(handoff, fail$2(none()))), () => producer(handoff, latch))
   })));
   return new StreamImpl(unwrapScoped$1(gen(function* ($) {
     const left = yield* $(make$1());
@@ -802,25 +431,25 @@ const combine = /*#__PURE__*/dual(4, (self, that, s, f) => {
     yield* $(toChannel(that), concatMap(writeChunk), pipeTo(producer(right, latchR)), runScoped$1, forkScoped);
     const pullLeft = pipe(latchL, offer(void 0),
     // TODO: remove
-    zipRight$1(pipe(take$1(left), flatMap$1(exit => suspend$1(() => exit)))));
+    zipRight$1(pipe(take$1(left), flatMap$2(exit => suspend$1(() => exit)))));
     const pullRight = pipe(latchR, offer(void 0),
     // TODO: remove
-    zipRight$1(pipe(take$1(right), flatMap$1(exit => suspend$1(() => exit)))));
-    return toChannel(unfoldEffect(s, s => flatMap$1(f(s, pullLeft, pullRight), unsome)));
+    zipRight$1(pipe(take$1(right), flatMap$2(exit => suspend$1(() => exit)))));
+    return toChannel(unfoldEffect(s, s => flatMap$2(f(s, pullLeft, pullRight), unsome)));
   })));
 });
 
 /** @internal */
 const combineChunks = /*#__PURE__*/dual(4, (self, that, s, f) => {
   const producer = (handoff, latch) => zipRight$2(fromEffect$1(take$1(latch)), readWithCause({
-    onInput: input => flatMap$2(fromEffect$1(pipe(handoff, offer(chunk(input)))), () => producer(handoff, latch)),
+    onInput: input => flatMap$1(fromEffect$1(pipe(handoff, offer(chunk(input)))), () => producer(handoff, latch)),
     onFailure: cause => fromEffect$1(offer(handoff, failCause$6(cause))),
     onDone: () => fromEffect$1(offer(handoff, end$2))
   }));
-  return new StreamImpl(pipe(all([make$1(), make$1(), make$1(), make$1()]), tap$1(([left, _, latchL]) => pipe(toChannel(self), pipeTo(producer(left, latchL)), runScoped$1, forkScoped)), tap$1(([_, right, __, latchR]) => pipe(toChannel(that), pipeTo(producer(right, latchR)), runScoped$1, forkScoped)), map$2(([left, right, latchL, latchR]) => {
-    const pullLeft = pipe(latchL, offer(void 0), zipRight$1(pipe(take$1(left), flatMap$1(done))));
-    const pullRight = pipe(latchR, offer(void 0), zipRight$1(pipe(take$1(right), flatMap$1(done))));
-    return toChannel(unfoldChunkEffect(s, s => flatMap$1(f(s, pullLeft, pullRight), unsome)));
+  return new StreamImpl(pipe(all([make$1(), make$1(), make$1(), make$1()]), tap$1(([left, _, latchL]) => pipe(toChannel(self), pipeTo(producer(left, latchL)), runScoped$1, forkScoped)), tap$1(([_, right, __, latchR]) => pipe(toChannel(that), pipeTo(producer(right, latchR)), runScoped$1, forkScoped)), map$1(([left, right, latchL, latchR]) => {
+    const pullLeft = pipe(latchL, offer(void 0), zipRight$1(pipe(take$1(left), flatMap$2(done))));
+    const pullRight = pipe(latchR, offer(void 0), zipRight$1(pipe(take$1(right), flatMap$2(done))));
+    return toChannel(unfoldChunkEffect(s, s => flatMap$2(f(s, pullLeft, pullRight), unsome)));
   }), unwrapScoped$1));
 });
 
@@ -843,21 +472,21 @@ const crossRight = /*#__PURE__*/dual(2, (self, that) => flatMap(self, () => that
 const crossWith = /*#__PURE__*/dual(3, (self, that, f) => pipe(self, flatMap(a => pipe(that, map(b => f(a, b))))));
 
 /** @internal */
-const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap$1(input => transplant(grafter => pipe(make$1(), map$2(handoff => {
-  const enqueue = last => pipe(sleep(duration), as$1(last), fork, grafter, map$2(fiber => consumer(previous(fiber))));
+const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap$2(input => transplant(grafter => pipe(make$1(), map$1(handoff => {
+  const enqueue = last => pipe(sleep(duration), as$1(last), fork, grafter, map$1(fiber => consumer(previous(fiber))));
   const producer = readWithCause({
     onInput: input => match$2(last$1(input), {
       onNone: () => producer,
-      onSome: last => flatMap$2(fromEffect$1(offer(handoff, emit(of(last)))), () => producer)
+      onSome: last => flatMap$1(fromEffect$1(offer(handoff, emit(of(last)))), () => producer)
     }),
     onFailure: cause => fromEffect$1(offer(handoff, halt(cause))),
-    onDone: () => fromEffect$1(offer(handoff, end$1(UpstreamEnd)))
+    onDone: () => fromEffect$1(offer(handoff, end(UpstreamEnd)))
   });
   const consumer = state => {
     switch (state._tag) {
       case OP_NOT_STARTED:
         {
-          return pipe(take$1(handoff), map$2(signal => {
+          return pipe(take$1(handoff), map$1(signal => {
             switch (signal._tag) {
               case OP_EMIT:
                 {
@@ -865,7 +494,7 @@ const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap
                 }
               case OP_HALT:
                 {
-                  return failCause$3(signal.cause);
+                  return failCause$1(signal.cause);
                 }
               case OP_END:
                 {
@@ -878,11 +507,11 @@ const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap
         {
           return unwrap$1(raceWith(join(state.fiber), take$1(handoff), {
             onSelfDone: (leftExit, current$1) => match$3(leftExit, {
-              onFailure: cause => pipe(interrupt(current$1), as$1(failCause$3(cause))),
-              onSuccess: chunk => succeed$1(pipe(write(chunk), flatMap$2(() => consumer(current(current$1)))))
+              onFailure: cause => pipe(interrupt(current$1), as$1(failCause$1(cause))),
+              onSuccess: chunk => succeed$1(pipe(write(chunk), flatMap$1(() => consumer(current(current$1)))))
             }),
             onOtherDone: (rightExit, previous) => match$3(rightExit, {
-              onFailure: cause => pipe(interrupt(previous), as$1(failCause$3(cause))),
+              onFailure: cause => pipe(interrupt(previous), as$1(failCause$1(cause))),
               onSuccess: signal => {
                 switch (signal._tag) {
                   case OP_EMIT:
@@ -891,11 +520,11 @@ const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap
                     }
                   case OP_HALT:
                     {
-                      return pipe(interrupt(previous), as$1(failCause$3(signal.cause)));
+                      return pipe(interrupt(previous), as$1(failCause$1(signal.cause)));
                     }
                   case OP_END:
                     {
-                      return pipe(join(previous), map$2(chunk => pipe(write(chunk), zipRight$2(unit$1))));
+                      return pipe(join(previous), map$1(chunk => pipe(write(chunk), zipRight$2(unit$1))));
                     }
                 }
               }
@@ -904,7 +533,7 @@ const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap
         }
       case OP_CURRENT:
         {
-          return pipe(join(state.fiber), map$2(signal => {
+          return pipe(join(state.fiber), map$1(signal => {
             switch (signal._tag) {
               case OP_EMIT:
                 {
@@ -912,7 +541,7 @@ const debounce = /*#__PURE__*/dual(2, (self, duration) => pipe(make$5(), flatMap
                 }
               case OP_HALT:
                 {
-                  return failCause$3(signal.cause);
+                  return failCause$1(signal.cause);
                 }
               case OP_END:
                 {
@@ -937,12 +566,12 @@ const dieSync = evaluate => fromEffect(dieSync$1(evaluate));
 const dieMessage = message => fromEffect(dieMessage$1(message));
 
 /** @internal */
-const distributedWith = /*#__PURE__*/dual(2, (self, options) => pipe(make$4(), flatMap$1(deferred => pipe(self, distributedWithDynamic({
+const distributedWith = /*#__PURE__*/dual(2, (self, options) => pipe(make$4(), flatMap$2(deferred => pipe(self, distributedWithDynamic({
   maximumLag: options.maximumLag,
-  decide: a => flatMap$1(_await(deferred), f => f(a))
-}), flatMap$1(next => pipe(all(map$3(range$1(0, options.size - 1), id => map$2(next, ([key, queue]) => [[key, id], queue]))), map$2(unsafeFromArray), flatMap$1(entries => {
+  decide: a => flatMap$2(_await(deferred), f => f(a))
+}), flatMap$2(next => pipe(all(map$2(range$1(0, options.size - 1), id => map$1(next, ([key, queue]) => [[key, id], queue]))), map$1(unsafeFromArray), flatMap$2(entries => {
   const [mappings, queues] = reduceRight(entries, [new Map(), empty$1()], ([mappings, queues], [mapping, queue]) => [mappings.set(mapping[0], mapping[1]), pipe(queues, prepend$1(queue))]);
-  return pipe(succeed$2(deferred, a => map$2(options.decide(a), f => key => pipe(f(mappings.get(key))))), as$1(Array.from(queues)));
+  return pipe(succeed$2(deferred, a => map$1(options.decide(a), f => key => pipe(f(mappings.get(key))))), as$1(Array.from(queues)));
 })))))));
 
 /** @internal */
@@ -957,19 +586,19 @@ const newDistributedWithDynamicId = () => {
 
 /** @internal */
 const distributedWithDynamic = /*#__PURE__*/dual(2, (self, options) => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => unit$2));
-const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, decide, done) => pipe(acquireRelease$1(make$3(new Map()), (ref, _) => pipe(get(ref), flatMap$1(queues => pipe(queues.values(), forEach(shutdown))))), flatMap$1(queuesRef => gen(function* ($) {
-  const offer = a => pipe(decide(a), flatMap$1(shouldProcess => pipe(get(queuesRef), flatMap$1(queues => pipe(queues.entries(), reduce$1(empty$1(), (acc, [id, queue]) => {
+const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, decide, done) => pipe(acquireRelease$1(make$2(new Map()), (ref, _) => pipe(get(ref), flatMap$2(queues => pipe(queues.values(), forEach(shutdown))))), flatMap$2(queuesRef => gen(function* ($) {
+  const offer = a => pipe(decide(a), flatMap$2(shouldProcess => pipe(get(queuesRef), flatMap$2(queues => pipe(queues.entries(), reduce$1(empty$1(), (acc, [id, queue]) => {
     if (shouldProcess(id)) {
       return pipe(offer$1(queue, succeed$4(a)), matchCauseEffect({
         onFailure: cause =>
         // Ignore all downstream queues that were shut
         // down and remove them later
-        isInterrupted(cause) ? succeed$1(pipe(acc, prepend$1(id))) : failCause$2(cause),
+        isInterrupted(cause) ? succeed$1(pipe(acc, prepend$1(id))) : failCause$4(cause),
         onSuccess: () => succeed$1(acc)
       }));
     }
     return succeed$1(acc);
-  }), flatMap$1(ids => {
+  }), flatMap$2(ids => {
     if (isNonEmpty(ids)) {
       return pipe(update(queuesRef, map => {
         for (const id of ids) {
@@ -981,7 +610,7 @@ const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, d
     return unit$2;
   }))))), asUnit);
   const queuesLock = yield* $(makeSemaphore(1));
-  const newQueue = yield* $(make$3(pipe(bounded(maximumLag), flatMap$1(queue => {
+  const newQueue = yield* $(make$2(pipe(bounded(maximumLag), flatMap$2(queue => {
     const id = newDistributedWithDynamicId();
     return pipe(update(queuesRef, map => map.set(id, queue)), as$1([id, queue]));
   }))));
@@ -989,13 +618,13 @@ const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, d
   // Make sure that no queues are currently being added
   queuesLock.withPermits(1)(pipe(set(newQueue, pipe(
   // All newly created queues should end immediately
-  bounded(1), tap$1(queue => offer$1(queue, endTake)), flatMap$1(queue => {
+  bounded(1), tap$1(queue => offer$1(queue, endTake)), flatMap$2(queue => {
     const id = newDistributedWithDynamicId();
     return pipe(update(queuesRef, map => map.set(id, queue)), as$1([id, queue]));
-  }))), zipRight$1(pipe(get(queuesRef), flatMap$1(map => pipe(fromIterable$1(map.values()), forEach(queue => pipe(offer$1(queue, endTake), catchSomeCause$1(cause => isInterrupted(cause) ? some$1(unit$2) : none()))))))), zipRight$1(done(endTake)), asUnit));
+  }))), zipRight$1(pipe(get(queuesRef), flatMap$2(map => pipe(fromIterable$1(map.values()), forEach(queue => pipe(offer$1(queue, endTake), catchSomeCause$1(cause => isInterrupted(cause) ? some$1(unit$2) : none()))))))), zipRight$1(done(endTake)), asUnit));
   yield* $(self, runForEachScoped(offer), matchCauseEffect({
-    onFailure: cause => finalize(failCause$4(pipe(cause, map$1(some$1)))),
-    onSuccess: () => finalize(fail$3(none()))
+    onFailure: cause => finalize(failCause$2(pipe(cause, map$3(some$1)))),
+    onSuccess: () => finalize(fail$2(none()))
   }), forkScoped);
   return queuesLock.withPermits(1)(flatten$1(get(newQueue)));
 }))));
@@ -1004,7 +633,7 @@ const distributedWithDynamicCallback = /*#__PURE__*/dual(4, (self, maximumLag, d
 const drain = self => new StreamImpl(drain$1(toChannel(self)));
 
 /** @internal */
-const drainFork = /*#__PURE__*/dual(2, (self, that) => pipe(fromEffect(make$4()), flatMap(backgroundDied => pipe(scoped(pipe(that, runForEachScoped(() => unit$2), catchAllCause$2(cause => failCause$5(backgroundDied, cause)), forkScoped)), crossRight(pipe(self, interruptWhenDeferred(backgroundDied)))))));
+const drainFork = /*#__PURE__*/dual(2, (self, that) => pipe(fromEffect(make$4()), flatMap(backgroundDied => pipe(scoped(pipe(that, runForEachScoped(() => unit$2), catchAllCause$2(cause => failCause$3(backgroundDied, cause)), forkScoped)), crossRight(pipe(self, interruptWhenDeferred(backgroundDied)))))));
 
 /** @internal */
 const drop = /*#__PURE__*/dual(2, (self, n) => {
@@ -1018,7 +647,7 @@ const drop = /*#__PURE__*/dual(2, (self, n) => {
       }
       return pipe(write(dropped), zipRight$2(identityChannel()));
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(loop(n))));
@@ -1038,9 +667,9 @@ const dropRight = /*#__PURE__*/dual(2, (self, n) => {
           queue.put(elem);
           return head;
         }));
-        return pipe(write(outputs), flatMap$2(() => reader));
+        return pipe(write(outputs), flatMap$1(() => reader));
       },
-      onFailure: fail$2,
+      onFailure: fail$1,
       onDone: () => unit$1
     });
     return new StreamImpl(pipe(toChannel(self), pipeToOrFail(reader)));
@@ -1053,14 +682,14 @@ const dropUntil = /*#__PURE__*/dual(2, (self, predicate) => drop(dropWhile(self,
 /** @internal */
 const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => {
   const loop = readWith({
-    onInput: input => pipe(dropUntil$1(input, predicate), map$2(unsafeFromArray), map$2(leftover => {
+    onInput: input => pipe(dropUntil$1(input, predicate), map$1(unsafeFromArray), map$1(leftover => {
       const more = isEmpty(leftover);
       if (more) {
         return suspend$2(() => loop);
       }
       return pipe(write(leftover), zipRight$2(identityChannel()));
     }), unwrap$1),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(loop)));
@@ -1076,7 +705,7 @@ const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => {
       }
       return zipRight$2(write(output), identityChannel());
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: succeedNow
   });
   return new StreamImpl(pipeToOrFail(toChannel(self), loop));
@@ -1085,14 +714,14 @@ const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => {
 /** @internal */
 const dropWhileEffect = /*#__PURE__*/dual(2, (self, predicate) => {
   const loop = readWith({
-    onInput: input => pipe(dropWhile$2(input, predicate), map$2(unsafeFromArray), map$2(leftover => {
+    onInput: input => pipe(dropWhile$2(input, predicate), map$1(unsafeFromArray), map$1(leftover => {
       const more = isEmpty(leftover);
       if (more) {
         return suspend$2(() => loop);
       }
       return zipRight$2(write(leftover), identityChannel());
     }), unwrap$1),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipeToOrFail(toChannel(self), loop));
@@ -1126,13 +755,13 @@ const contextWithStream = f => pipe(context(), flatMap(f));
 const execute = effect => drain(fromEffect(effect));
 
 /** @internal */
-const fail = error => fromEffectOption(fail$1(some$1(error)));
+const fail = error => fromEffectOption(fail$3(some$1(error)));
 
 /** @internal */
 const failSync = evaluate => fromEffectOption(failSync$1(() => some$1(evaluate())));
 
 /** @internal */
-const failCause = cause => fromEffect(failCause$2(cause));
+const failCause = cause => fromEffect(failCause$4(cause));
 
 /** @internal */
 const failCauseSync = evaluate => fromEffect(failCauseSync$1(evaluate));
@@ -1147,11 +776,11 @@ const filterEffect = /*#__PURE__*/dual(2, (self, f) => {
     if (next.done) {
       return readWithCause({
         onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeed$3
       });
     } else {
-      return pipe(f(next.value), map$2(bool => bool ? pipe(write(of(next.value)), flatMap$2(() => loop(iterator))) : loop(iterator)), unwrap$1);
+      return pipe(f(next.value), map$1(bool => bool ? pipe(write(of(next.value)), flatMap$1(() => loop(iterator))) : loop(iterator)), unwrap$1);
     }
   };
   return new StreamImpl(suspend$2(() => pipe(toChannel(self), pipeTo(loop(empty$1()[Symbol.iterator]())))));
@@ -1167,13 +796,13 @@ const filterMapEffect = /*#__PURE__*/dual(2, (self, pf) => suspend(() => {
     if (next.done) {
       return readWithCause({
         onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeed$3
       });
     } else {
       return pipe(pf(next.value), match$2({
         onNone: () => sync$1(() => loop(iterator)),
-        onSome: map$2(a2 => flatMap$2(write(of(a2)), () => loop(iterator)))
+        onSome: map$1(a2 => flatMap$1(write(of(a2)), () => loop(iterator)))
       }), unwrap$1);
     }
   };
@@ -1186,11 +815,11 @@ const filterMapWhile = /*#__PURE__*/dual(2, (self, pf) => {
     onInput: input => {
       const mapped = filterMapWhile$1(input, pf);
       if (mapped.length === input.length) {
-        return pipe(write(mapped), flatMap$2(() => loop));
+        return pipe(write(mapped), flatMap$1(() => loop));
       }
       return write(mapped);
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: succeed$3
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(loop)));
@@ -1203,13 +832,13 @@ const filterMapWhileEffect = /*#__PURE__*/dual(2, (self, pf) => suspend(() => {
     if (next.done) {
       return readWithCause({
         onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeed$3
       });
     } else {
       return unwrap$1(match$2(pf(next.value), {
         onNone: () => succeed$1(unit$1),
-        onSome: map$2(a2 => flatMap$2(write(of(a2)), () => loop(iterator)))
+        onSome: map$1(a2 => flatMap$1(write(of(a2)), () => loop(iterator)))
       }));
     }
   };
@@ -1226,7 +855,7 @@ const find = /*#__PURE__*/dual(2, (self, predicate) => {
       onNone: () => loop,
       onSome: n => write(of(n))
     }),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(loop)));
@@ -1235,11 +864,11 @@ const find = /*#__PURE__*/dual(2, (self, predicate) => {
 /** @internal */
 const findEffect = /*#__PURE__*/dual(2, (self, predicate) => {
   const loop = readWith({
-    onInput: input => pipe(findFirst$1(input, predicate), map$2(match$2({
+    onInput: input => pipe(findFirst$1(input, predicate), map$1(match$2({
       onNone: () => loop,
       onSome: n => write(of(n))
     })), unwrap$1),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(loop)));
@@ -1251,7 +880,7 @@ const flatMap = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self,
   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$3(a => toChannel(f(a))), reduce(unit$1, (left, right) => pipe(left, zipRight$2(right)))))), n => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(concatMap(toChannel(self), as => pipe(as, map$2(a => toChannel(f(a))), reduce(unit$1, (left, right) => pipe(left, zipRight$2(right)))))), n => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
     concurrency: n,
     bufferSize
   }))));
@@ -1280,8 +909,8 @@ const flatten = /*#__PURE__*/dual(args => isStream(args[0]), (self, options) =>
 /** @internal */
 const flattenChunks = self => {
   const flatten = readWithCause({
-    onInput: chunks => flatMap$2(writeChunk(chunks), () => flatten),
-    onFailure: failCause$3,
+    onInput: chunks => flatMap$1(writeChunk(chunks), () => flatten),
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(flatten)));
@@ -1301,16 +930,16 @@ const flattenExitOption = self => {
       onSome: match$3({
         onFailure: cause => match$2(flipCauseOption(cause), {
           onNone: () => unit$1,
-          onSome: failCause$3
+          onSome: failCause$1
         }),
         onSuccess: () => unit$1
       })
     }));
-    return pipe(write(pipe(toEmit, filterMap$1(exit => isSuccess(exit) ? some$1(exit.value) : none()))), flatMap$2(() => next));
+    return pipe(write(pipe(toEmit, filterMap$1(exit => isSuccess(exit) ? some$1(exit.value) : none()))), flatMap$1(() => next));
   };
   const process = readWithCause({
     onInput: chunk => processChunk(chunk, process),
-    onFailure: cause => failCause$3(cause),
+    onFailure: cause => failCause$1(cause),
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(process)));
@@ -1326,10 +955,10 @@ const flattenTake = self => flattenChunks(flattenExitOption(pipe(self, map(take
 const forever = self => new StreamImpl(repeated(toChannel(self)));
 
 /** @internal */
-const fromAsyncIterable = (iterable, onError) => pipe(acquireRelease$1(sync$1(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? promise(async () => iterator.return()) : unit$2), map$2(iterator => repeatEffectOption(pipe(tryPromise({
+const fromAsyncIterable = (iterable, onError) => pipe(acquireRelease$1(sync$1(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? promise(async () => iterator.return()) : unit$2), map$1(iterator => repeatEffectOption(pipe(tryPromise({
   try: async () => iterator.next(),
   catch: reason => some$1(onError(reason))
-}), flatMap$1(result => result.done ? fail$1(none()) : succeed$1(result.value))))), unwrapScoped);
+}), flatMap$2(result => result.done ? fail$3(none()) : succeed$1(result.value))))), unwrapScoped);
 
 /** @internal */
 const fromChannel = channel => new StreamImpl(channel);
@@ -1348,15 +977,15 @@ const fromChunk = chunk => new StreamImpl(isEmpty(chunk) ? unit$1 : write(chunk)
 /** @internal */
 const fromChunkHub = (hub, options) => {
   if (options?.scoped) {
-    const effect = map$2(subscribe(hub), fromChunkQueue);
-    return options.shutdown ? map$2(effect, ensuring(shutdown$1(hub))) : effect;
+    const effect = map$1(subscribe(hub), fromChunkQueue);
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
   }
   const stream = flatMap(scoped(subscribe(hub)), fromChunkQueue);
   return options?.shutdown ? ensuring(stream, shutdown$1(hub)) : stream;
 };
 
 /** @internal */
-const fromChunkQueue = (queue, options) => pipe(take$2(queue), catchAllCause$2(cause => pipe(isShutdown(queue), flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
+const fromChunkQueue = (queue, options) => pipe(take$2(queue), catchAllCause$2(cause => pipe(isShutdown(queue), flatMap$2(isShutdown => isShutdown && isInterrupted(cause) ? end$1() : failCause$5(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
 
 /** @internal */
 const fromChunks = (...chunks) => pipe(fromIterable(chunks), flatMap(fromChunk));
@@ -1368,7 +997,7 @@ const fromEffect = effect => pipe(effect, mapError$1(some$1), fromEffectOption);
 const fromEffectOption = effect => new StreamImpl(unwrap$1(match$1(effect, {
   onFailure: match$2({
     onNone: () => unit$1,
-    onSome: fail$2
+    onSome: fail$1
   }),
   onSuccess: a => write(of(a))
 })));
@@ -1377,11 +1006,11 @@ const fromEffectOption = effect => new StreamImpl(unwrap$1(match$1(effect, {
 const fromHub = (hub, options) => {
   const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
   if (options?.scoped) {
-    const effect = map$2(subscribe(hub), queue => fromQueue(queue, {
+    const effect = map$1(subscribe(hub), queue => fromQueue(queue, {
       maxChunkSize,
       shutdown: true
     }));
-    return options.shutdown ? map$2(effect, ensuring(shutdown$1(hub))) : effect;
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
   }
   const stream = flatMap(scoped(subscribe(hub)), queue => fromQueue(queue, {
     maxChunkSize
@@ -1393,7 +1022,7 @@ const fromHub = (hub, options) => {
 const fromIterable = iterable => suspend(() => isChunk(iterable) ? fromChunk(iterable) : fromIteratorSucceed(iterable[Symbol.iterator]()));
 
 /** @internal */
-const fromIterableEffect = effect => pipe(effect, map$2(fromIterable), unwrap);
+const fromIterableEffect = effect => pipe(effect, map$1(fromIterable), unwrap);
 
 /** @internal */
 const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
@@ -1405,7 +1034,7 @@ const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
         if (next.done) {
           return unit$1;
         }
-        return pipe(write(of(next.value)), flatMap$2(() => loop(iterator)));
+        return pipe(write(of(next.value)), flatMap$1(() => loop(iterator)));
       }
       builder = [];
       let count = 0;
@@ -1415,7 +1044,7 @@ const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
         count = count + 1;
       }
       if (count > 0) {
-        return pipe(write(unsafeFromArray(builder)), flatMap$2(() => loop(iterator)));
+        return pipe(write(unsafeFromArray(builder)), flatMap$1(() => loop(iterator)));
       }
       return unit$1;
     }), unwrap$1);
@@ -1424,30 +1053,30 @@ const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
 };
 
 /** @internal */
-const fromPull = effect => pipe(effect, map$2(repeatEffectChunkOption), unwrapScoped);
+const fromPull = effect => pipe(effect, map$1(repeatEffectChunkOption), unwrapScoped);
 
 /** @internal */
-const fromQueue = (queue, options) => pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), catchAllCause$2(cause => pipe(isShutdown(queue), flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
+const fromQueue = (queue, options) => pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), catchAllCause$2(cause => pipe(isShutdown(queue), flatMap$2(isShutdown => isShutdown && isInterrupted(cause) ? end$1() : failCause$5(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
 
 /** @internal */
-const fromSchedule = schedule => pipe(driver(schedule), map$2(driver => repeatEffectOption(driver.next(void 0))), unwrap);
+const fromSchedule = schedule => pipe(driver(schedule), map$1(driver => repeatEffectOption(driver.next(void 0))), unwrap);
 
 /** @internal */
-const fromReadableStream = (evaluate, onError) => unwrapScoped(map$2(acquireRelease$1(sync$1(() => evaluate().getReader()), reader => promise(() => reader.cancel())), reader => repeatEffectOption(flatMap$1(tryPromise({
+const fromReadableStream = (evaluate, onError) => unwrapScoped(map$1(acquireRelease$1(sync$1(() => evaluate().getReader()), reader => promise(() => reader.cancel())), reader => repeatEffectOption(flatMap$2(tryPromise({
   try: () => reader.read(),
   catch: reason => some$1(onError(reason))
 }), ({
   done,
   value
-}) => done ? fail$1(none()) : succeed$1(value)))));
+}) => done ? fail$3(none()) : succeed$1(value)))));
 
 /** @internal */
-const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(map$2(acquireRelease$1(sync$1(() => evaluate().getReader({
+const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(map$1(acquireRelease$1(sync$1(() => evaluate().getReader({
   mode: "byob"
 })), reader => promise(() => reader.cancel())), reader => catchAll(forever(readChunkStreamByobReader(reader, onError, allocSize)), error => typeof error === "object" && error !== null && "_tag" in error && error._tag === "EOF" ? empty : fail(error))));
 const readChunkStreamByobReader = (reader, onError, size) => {
   const buffer = new ArrayBuffer(size);
-  return paginateEffect(0, offset => flatMap$1(tryPromise({
+  return paginateEffect(0, offset => flatMap$2(tryPromise({
     try: () => reader.read(new Uint8Array(buffer, offset, buffer.byteLength - offset)),
     catch: reason => onError(reason)
   }), ({
@@ -1455,7 +1084,7 @@ const readChunkStreamByobReader = (reader, onError, size) => {
     value
   }) => {
     if (done) {
-      return fail$1({
+      return fail$3({
         _tag: "EOF"
       });
     }
@@ -1521,15 +1150,15 @@ const groupAdjacentBy = /*#__PURE__*/dual(2, (self, f) => {
   const groupAdjacent = state => readWithCause({
     onInput: input => {
       const [updatedState, output] = groupAdjacentByChunk(state, input);
-      return isEmpty(output) ? groupAdjacent(updatedState) : flatMap$2(write(output), () => groupAdjacent(updatedState));
+      return isEmpty(output) ? groupAdjacent(updatedState) : flatMap$1(write(output), () => groupAdjacent(updatedState));
     },
     onFailure: cause => match$2(state, {
-      onNone: () => failCause$3(cause),
-      onSome: output => flatMap$2(write(of(output)), () => failCause$3(cause))
+      onNone: () => failCause$1(cause),
+      onSome: output => flatMap$1(write(of(output)), () => failCause$1(cause))
     }),
     onDone: done => match$2(state, {
       onNone: () => succeedNow(done),
-      onSome: output => flatMap$2(write(of(output)), () => succeedNow(done))
+      onSome: output => flatMap$1(write(of(output)), () => succeedNow(done))
     })
   });
   return new StreamImpl(pipeToOrFail(toChannel(self), groupAdjacent(none())));
@@ -1543,18 +1172,18 @@ const groupedWithin = /*#__PURE__*/dual(3, (self, chunkSize, duration) => aggreg
 
 /** @internal */
 const haltWhen = /*#__PURE__*/dual(2, (self, effect) => {
-  const writer = fiber => pipe(poll$1(fiber), map$2(match$2({
+  const writer = fiber => pipe(poll$1(fiber), map$1(match$2({
     onNone: () => readWith({
-      onInput: input => flatMap$2(write(input), () => writer(fiber)),
-      onFailure: fail$2,
+      onInput: input => flatMap$1(write(input), () => writer(fiber)),
+      onFailure: fail$1,
       onDone: () => unit$1
     }),
     onSome: match$3({
-      onFailure: failCause$3,
+      onFailure: failCause$1,
       onSuccess: () => unit$1
     })
   })), unwrap$1);
-  return new StreamImpl(pipe(forkScoped(effect), map$2(fiber => pipe(toChannel(self), pipeTo(writer(fiber)))), unwrapScoped$1));
+  return new StreamImpl(pipe(forkScoped(effect), map$1(fiber => pipe(toChannel(self), pipeTo(writer(fiber)))), unwrapScoped$1));
 });
 
 /** @internal */
@@ -1562,14 +1191,14 @@ const haltAfter = /*#__PURE__*/dual(2, (self, duration) => pipe(self, haltWhen(s
 
 /** @internal */
 const haltWhenDeferred = /*#__PURE__*/dual(2, (self, deferred) => {
-  const writer = pipe(poll(deferred), map$2(match$2({
+  const writer = pipe(poll(deferred), map$1(match$2({
     onNone: () => readWith({
-      onInput: input => pipe(write(input), flatMap$2(() => writer)),
-      onFailure: fail$2,
+      onInput: input => pipe(write(input), flatMap$1(() => writer)),
+      onFailure: fail$1,
       onDone: () => unit$1
     }),
     onSome: effect => unwrap$1(match$1(effect, {
-      onFailure: fail$2,
+      onFailure: fail$1,
       onSuccess: () => unit$1
     }))
   })), unwrap$1);
@@ -1585,30 +1214,30 @@ const interleave = /*#__PURE__*/dual(2, (self, that) => pipe(self, interleaveWit
 /** @internal */
 const interleaveWith = /*#__PURE__*/dual(3, (self, that, decider) => {
   const producer = handoff => readWithCause({
-    onInput: value => flatMap$2(fromEffect$1(offer(handoff, of$1(value))), () => producer(handoff)),
+    onInput: value => flatMap$1(fromEffect$1(offer(handoff, of$1(value))), () => producer(handoff)),
     onFailure: cause => fromEffect$1(offer(handoff, failCause$6(cause))),
     onDone: () => fromEffect$1(offer(handoff, end$2))
   });
-  return new StreamImpl(unwrapScoped$1(pipe(make$1(), zip$1(make$1()), tap$1(([left]) => pipe(toChannel(self), concatMap(writeChunk), pipeTo(producer(left)), runScoped$1, forkScoped)), tap$1(([_, right]) => pipe(toChannel(that), concatMap(writeChunk), pipeTo(producer(right)), runScoped$1, forkScoped)), map$2(([left, right]) => {
+  return new StreamImpl(unwrapScoped$1(pipe(make$1(), zip$1(make$1()), tap$1(([left]) => pipe(toChannel(self), concatMap(writeChunk), pipeTo(producer(left)), runScoped$1, forkScoped)), tap$1(([_, right]) => pipe(toChannel(that), concatMap(writeChunk), pipeTo(producer(right)), runScoped$1, forkScoped)), map$1(([left, right]) => {
     const process = (leftDone, rightDone) => readWithCause({
       onInput: bool => {
         if (bool && !leftDone) {
-          return pipe(fromEffect$1(take$1(left)), flatMap$2(match$4({
+          return pipe(fromEffect$1(take$1(left)), flatMap$1(match$4({
             onEnd: () => rightDone ? unit$1 : process(true, rightDone),
-            onFailure: failCause$3,
-            onSuccess: chunk => pipe(write(chunk), flatMap$2(() => process(leftDone, rightDone)))
+            onFailure: failCause$1,
+            onSuccess: chunk => pipe(write(chunk), flatMap$1(() => process(leftDone, rightDone)))
           })));
         }
         if (!bool && !rightDone) {
-          return pipe(fromEffect$1(take$1(right)), flatMap$2(match$4({
+          return pipe(fromEffect$1(take$1(right)), flatMap$1(match$4({
             onEnd: () => leftDone ? unit$1 : process(leftDone, true),
-            onFailure: failCause$3,
-            onSuccess: chunk => pipe(write(chunk), flatMap$2(() => process(leftDone, rightDone)))
+            onFailure: failCause$1,
+            onSuccess: chunk => pipe(write(chunk), flatMap$1(() => process(leftDone, rightDone)))
           })));
         }
         return process(leftDone, rightDone);
       },
-      onFailure: failCause$3,
+      onFailure: failCause$1,
       onDone: () => unit$1
     });
     return pipe(toChannel(decider), concatMap(writeChunk), pipeTo(process(false, false)));
@@ -1630,9 +1259,9 @@ const intersperse = /*#__PURE__*/dual(2, (self, element) => new StreamImpl(pipe(
           builder.push(output);
         }
       }
-      return pipe(write(unsafeFromArray(builder)), flatMap$2(() => writer(flagResult)));
+      return pipe(write(unsafeFromArray(builder)), flatMap$1(() => writer(flagResult)));
     },
-    onFailure: failCause$3,
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
   return writer(true);
@@ -1661,16 +1290,16 @@ const iterate = (value, next) => unfold(value, a => some$1([a, next(a)]));
 const make = (...as) => fromIterable(as);
 
 /** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => new StreamImpl(pipe(toChannel(self), mapOut(map$3(f)))));
+const map = /*#__PURE__*/dual(2, (self, f) => new StreamImpl(pipe(toChannel(self), mapOut(map$2(f)))));
 
 /** @internal */
 const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
   const accumulator = s => readWith({
     onInput: input => {
       const [nextS, chunk] = mapAccum$1(input, s, f);
-      return flatMap$2(write(chunk), () => accumulator(nextS));
+      return flatMap$1(write(chunk), () => accumulator(nextS));
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(accumulator(s))));
@@ -1684,17 +1313,17 @@ const mapAccumEffect = /*#__PURE__*/dual(3, (self, s, f) => suspend(() => {
       const emit = output => sync$1(() => {
         outputs.push(output);
       });
-      return pipe(input, reduce$1(s, (s, a) => pipe(f(s, a), flatMap$1(([s, a]) => pipe(emit(a), as$1(s))))), match$1({
+      return pipe(input, reduce$1(s, (s, a) => pipe(f(s, a), flatMap$2(([s, a]) => pipe(emit(a), as$1(s))))), match$1({
         onFailure: error => {
           if (outputs.length !== 0) {
-            return zipRight$2(write(unsafeFromArray(outputs)), fail$2(error));
+            return zipRight$2(write(unsafeFromArray(outputs)), fail$1(error));
           }
-          return fail$2(error);
+          return fail$1(error);
         },
-        onSuccess: s => flatMap$2(write(unsafeFromArray(outputs)), () => accumulator(s))
+        onSuccess: s => flatMap$1(write(unsafeFromArray(outputs)), () => accumulator(s))
       }));
     }), unwrap$1),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => unit$1
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(accumulator(s))));
@@ -1719,7 +1348,7 @@ const mapConcatChunk = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapChunks(fl
 const mapConcatChunkEffect = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapEffectSequential(f), mapConcatChunk(identity)));
 
 /** @internal */
-const mapConcatEffect = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapEffectSequential(a => pipe(f(a), map$2(fromIterable$1))), mapConcatChunk(identity)));
+const mapConcatEffect = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapEffectSequential(a => pipe(f(a), map$1(fromIterable$1))), mapConcatChunk(identity)));
 
 /** @internal */
 const mapEffectSequential = /*#__PURE__*/dual(2, (self, f) => {
@@ -1728,12 +1357,12 @@ const mapEffectSequential = /*#__PURE__*/dual(2, (self, f) => {
     if (next.done) {
       return readWithCause({
         onInput: elem => loop(elem[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeed$3
       });
     } else {
       const value = next.value;
-      return unwrap$1(map$2(f(value), a2 => flatMap$2(write(of(a2)), () => loop(iterator))));
+      return unwrap$1(map$1(f(value), a2 => flatMap$1(write(of(a2)), () => loop(iterator))));
     }
   };
   return new StreamImpl(pipe(toChannel(self), pipeTo(suspend$2(() => loop(empty$1()[Symbol.iterator]())))));
@@ -1790,7 +1419,7 @@ const mkString = self => run(self, mkString$1);
 const never = /*#__PURE__*/fromEffect(never$1);
 
 /** @internal */
-const onError = /*#__PURE__*/dual(2, (self, cleanup) => pipe(self, catchAllCause(cause => fromEffect(pipe(cleanup(cause), zipRight$1(failCause$2(cause)))))));
+const onError = /*#__PURE__*/dual(2, (self, cleanup) => pipe(self, catchAllCause(cause => fromEffect(pipe(cleanup(cause), zipRight$1(failCause$4(cause)))))));
 
 /** @internal */
 const onDone = /*#__PURE__*/dual(2, (self, cleanup) => new StreamImpl(pipe(toChannel(self), ensuringWith$1(exit => isSuccess(exit) ? cleanup() : unit$2))));
@@ -1825,7 +1454,7 @@ const orElseIfEmptyStream = /*#__PURE__*/dual(2, (self, stream) => {
       }
       return pipe(write(input), zipRight$2(identityChannel()));
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => suspend$2(() => toChannel(stream()))
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(writer)));
@@ -1846,7 +1475,7 @@ const paginateChunk = (s, f) => {
     const page = f(s);
     return match$2(page[1], {
       onNone: () => zipRight$2(write(page[0]), unit$1),
-      onSome: s => flatMap$2(write(page[0]), () => loop(s))
+      onSome: s => flatMap$1(write(page[0]), () => loop(s))
     });
   };
   return new StreamImpl(suspend$2(() => loop(s)));
@@ -1854,34 +1483,34 @@ const paginateChunk = (s, f) => {
 
 /** @internal */
 const paginateChunkEffect = (s, f) => {
-  const loop = s => unwrap$1(map$2(f(s), ([chunk, option]) => match$2(option, {
+  const loop = s => unwrap$1(map$1(f(s), ([chunk, option]) => match$2(option, {
     onNone: () => zipRight$2(write(chunk), unit$1),
-    onSome: s => flatMap$2(write(chunk), () => loop(s))
+    onSome: s => flatMap$1(write(chunk), () => loop(s))
   })));
   return new StreamImpl(suspend$2(() => loop(s)));
 };
 
 /** @internal */
-const paginateEffect = (s, f) => paginateChunkEffect(s, s => pipe(f(s), map$2(([a, s]) => [of(a), s])));
+const paginateEffect = (s, f) => paginateChunkEffect(s, s => pipe(f(s), map$1(([a, s]) => [of(a), s])));
 
 /** @internal */
 const peel = /*#__PURE__*/dual(2, (self, sink) => {
   const OP_EMIT = "Emit";
   const OP_HALT = "Halt";
   const OP_END = "End";
-  return pipe(make$4(), flatMap$1(deferred => pipe(make$1(), map$2(handoff => {
+  return pipe(make$4(), flatMap$2(deferred => pipe(make$1(), map$1(handoff => {
     const consumer = foldSink(collectLeftover(sink), {
       onFailure: error => zipRight$3(fromEffect$2(fail$4(deferred, error)), fail$5(error)),
       onSuccess: ([z, leftovers]) => {
         const loop = readWithCause({
-          onInput: elements => flatMap$2(fromEffect$1(offer(handoff, {
+          onInput: elements => flatMap$1(fromEffect$1(offer(handoff, {
             _tag: OP_EMIT,
             elements
           })), () => loop),
           onFailure: cause => zipRight$2(fromEffect$1(offer(handoff, {
             _tag: OP_HALT,
             cause
-          })), failCause$3(cause)),
+          })), failCause$1(cause)),
           onDone: _ => zipRight$2(fromEffect$1(offer(handoff, {
             _tag: OP_END
           })), unit$1)
@@ -1892,15 +1521,15 @@ const peel = /*#__PURE__*/dual(2, (self, sink) => {
         })))), zipRight$2(loop)));
       }
     });
-    const producer = pipe(take$1(handoff), map$2(signal => {
+    const producer = pipe(take$1(handoff), map$1(signal => {
       switch (signal._tag) {
         case OP_EMIT:
           {
-            return pipe(write(signal.elements), flatMap$2(() => producer));
+            return pipe(write(signal.elements), flatMap$1(() => producer));
           }
         case OP_HALT:
           {
-            return failCause$3(signal.cause);
+            return failCause$1(signal.cause);
           }
         case OP_END:
           {
@@ -1908,7 +1537,7 @@ const peel = /*#__PURE__*/dual(2, (self, sink) => {
           }
       }
     }), unwrap$1);
-    return pipe(self, tapErrorCause(cause => failCause$5(deferred, cause)), run(consumer), forkScoped, zipRight$1(_await(deferred)), map$2(z => [z, new StreamImpl(producer)]));
+    return pipe(self, tapErrorCause(cause => failCause$3(deferred, cause)), run(consumer), forkScoped, zipRight$1(_await(deferred)), map$1(z => [z, new StreamImpl(producer)]));
   }))), flatten$1);
 });
 
@@ -1923,7 +1552,7 @@ const partitionEither = /*#__PURE__*/dual(args => typeof args[1] === "function",
     onLeft: () => succeed$1(n => n === 0),
     onRight: () => succeed$1(n => n === 1)
   })
-}), flatMap$1(([queue1, queue2]) => succeed$1([filterMap(flattenExitOption(fromQueue(queue1, {
+}), flatMap$2(([queue1, queue2]) => succeed$1([filterMap(flattenExitOption(fromQueue(queue1, {
   shutdown: true
 })), _ => match(_, {
   onLeft: some$1,
@@ -1951,7 +1580,7 @@ const prepend = /*#__PURE__*/dual(2, (self, values) => new StreamImpl(zipRight$2
 const provideContext = /*#__PURE__*/dual(2, (self, context) => new StreamImpl(pipe(toChannel(self), provideContext$1(context))));
 
 /** @internal */
-const provideLayer = /*#__PURE__*/dual(2, (self, layer) => new StreamImpl(unwrapScoped$1(pipe(build(layer), map$2(env => pipe(toChannel(self), provideContext$1(env)))))));
+const provideLayer = /*#__PURE__*/dual(2, (self, layer) => new StreamImpl(unwrapScoped$1(pipe(build(layer), map$1(env => pipe(toChannel(self), provideContext$1(env)))))));
 
 /** @internal */
 const provideService = /*#__PURE__*/dual(3, (self, tag, resource) => provideServiceEffect(self, tag, succeed$1(resource)));
@@ -1978,7 +1607,7 @@ const range = (min, max, chunkSize = DefaultChunkSize) => suspend(() => {
   const go = (min, max, chunkSize) => {
     const remaining = max - min + 1;
     if (remaining > chunkSize) {
-      return pipe(write(range$1(min, min + chunkSize - 1)), flatMap$2(() => go(min + chunkSize, max, chunkSize)));
+      return pipe(write(range$1(min, min + chunkSize - 1)), flatMap$1(() => go(min + chunkSize, max, chunkSize)));
     }
     return write(range$1(min, min + remaining - 1));
   };
@@ -1996,7 +1625,7 @@ const rechunk = /*#__PURE__*/dual(2, (self, n) => suspend(() => {
 const rechunkProcess = (rechunker, target) => readWithCause({
   onInput: chunk => {
     if (chunk.length === target && rechunker.isEmpty()) {
-      return flatMap$2(write(chunk), () => rechunkProcess(rechunker, target));
+      return flatMap$1(write(chunk), () => rechunkProcess(rechunker, target));
     }
     if (chunk.length > 0) {
       const chunks = [];
@@ -2012,11 +1641,11 @@ const rechunkProcess = (rechunker, target) => readWithCause({
           result = undefined;
         }
       }
-      return flatMap$2(writeAll(...chunks), () => rechunkProcess(rechunker, target));
+      return flatMap$1(writeAll(...chunks), () => rechunkProcess(rechunker, target));
     }
     return suspend$2(() => rechunkProcess(rechunker, target));
   },
-  onFailure: cause => zipRight$2(rechunker.emitIfNotEmpty(), failCause$3(cause)),
+  onFailure: cause => zipRight$2(rechunker.emitIfNotEmpty(), failCause$1(cause)),
   onDone: () => rechunker.emitIfNotEmpty()
 });
 
@@ -2054,8 +1683,8 @@ const refineOrDie = /*#__PURE__*/dual(2, (self, pf) => pipe(self, refineOrDieWit
 
 /** @internal */
 const refineOrDieWith = /*#__PURE__*/dual(3, (self, pf, f) => new StreamImpl(catchAll$1(toChannel(self), error => match$2(pf(error), {
-  onNone: () => failCause$3(die$2(f(error))),
-  onSome: fail$2
+  onNone: () => failCause$1(die$2(f(error))),
+  onSome: fail$1
 }))));
 
 /** @internal */
@@ -2071,13 +1700,13 @@ const repeatEffect = effect => repeatEffectOption(pipe(effect, mapError$1(some$1
 const repeatEffectChunk = effect => repeatEffectChunkOption(pipe(effect, mapError$1(some$1)));
 
 /** @internal */
-const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => pipe(map$2(effect, chunk => some$1([chunk, effect])), catchAll$2(match$2({
+const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => pipe(map$1(effect, chunk => some$1([chunk, effect])), catchAll$2(match$2({
   onNone: () => succeed$1(none()),
-  onSome: fail$1
+  onSome: fail$3
 }))));
 
 /** @internal */
-const repeatEffectOption = effect => repeatEffectChunkOption(pipe(effect, map$2(of)));
+const repeatEffectOption = effect => repeatEffectChunkOption(pipe(effect, map$1(of)));
 
 /** @internal */
 const repeatEither = /*#__PURE__*/dual(2, (self, schedule) => repeatWith(self, schedule, {
@@ -2093,19 +1722,19 @@ const repeatElements = /*#__PURE__*/dual(2, (self, schedule) => filterMap(repeat
 
 /** @internal */
 const repeatElementsWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
-  const driver$1 = pipe(driver(schedule), map$2(driver => {
+  const driver$1 = pipe(driver(schedule), map$1(driver => {
     const feed = input => match$2(head$1(input), {
       onNone: () => loop,
       onSome: a => zipRight$2(write(of(options.onElement(a))), step(pipe(input, drop$1(1)), a))
     });
     const step = (input, a) => {
-      const advance = pipe(driver.next(a), as$1(pipe(write(of(options.onElement(a))), flatMap$2(() => step(input, a)))));
-      const reset = pipe(driver.last(), orDie$1, flatMap$1(b => pipe(driver.reset(), map$2(() => pipe(write(of(options.onSchedule(b))), zipRight$2(feed(input)))))));
+      const advance = pipe(driver.next(a), as$1(pipe(write(of(options.onElement(a))), flatMap$1(() => step(input, a)))));
+      const reset = pipe(driver.last(), orDie$1, flatMap$2(b => pipe(driver.reset(), map$1(() => pipe(write(of(options.onSchedule(b))), zipRight$2(feed(input)))))));
       return pipe(advance, orElse$2(() => reset), unwrap$1);
     };
     const loop = readWith({
       onInput: feed,
-      onFailure: fail$2,
+      onFailure: fail$1,
       onDone: () => unit$1
     });
     return loop;
@@ -2118,12 +1747,12 @@ const repeatValue = value => new StreamImpl(repeated(write(of(value))));
 
 /** @internal */
 const repeatWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
-  return pipe(driver(schedule), map$2(driver => {
-    const scheduleOutput = pipe(driver.last(), orDie$1, map$2(options.onSchedule));
+  return pipe(driver(schedule), map$1(driver => {
+    const scheduleOutput = pipe(driver.last(), orDie$1, map$1(options.onSchedule));
     const process = pipe(self, map(options.onElement), toChannel);
     const loop = unwrap$1(match$1(driver.next(void 0), {
       onFailure: () => unit$1,
-      onSuccess: () => pipe(process, zipRight$2(pipe(scheduleOutput, map$2(c => pipe(write(of(c)), flatMap$2(() => loop))), unwrap$1)))
+      onSuccess: () => pipe(process, zipRight$2(pipe(scheduleOutput, map$1(c => pipe(write(of(c)), flatMap$1(() => loop))), unwrap$1)))
     }));
     return new StreamImpl(pipe(process, zipRight$2(loop)));
   }), unwrap);
@@ -2135,13 +1764,13 @@ const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(succeed
 /** @internal */
 const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(zip$1(effect, driver(schedule))), ([a, driver]) => concat(succeed(a), unfoldEffect(a, s => matchEffect(driver.next(s), {
   onFailure: succeed$1,
-  onSuccess: () => map$2(effect, nextA => some$1([nextA, nextA]))
+  onSuccess: () => map$1(effect, nextA => some$1([nextA, nextA]))
 }))));
 
 /** @internal */
-const retry = /*#__PURE__*/dual(2, (self, schedule) => unwrap(map$2(driver(schedule), driver => {
+const retry = /*#__PURE__*/dual(2, (self, schedule) => unwrap(map$1(driver(schedule), driver => {
   const loop = catchAll(self, error => unwrap(matchEffect(driver.next(error), {
-    onFailure: () => fail$1(error),
+    onFailure: () => fail$3(error),
     onSuccess: () => succeed$1(pipe(loop, tap(() => driver.reset())))
   })));
   return loop;
@@ -2216,9 +1845,9 @@ const runIntoQueue = /*#__PURE__*/dual(2, (self, queue) => pipe(self, runIntoQue
 /** @internal */
 const runIntoQueueElementsScoped = /*#__PURE__*/dual(2, (self, queue) => {
   const writer = readWithCause({
-    onInput: input => flatMap$2(fromEffect$1(offerAll(queue, map$3(input, succeed$4))), () => writer),
-    onFailure: cause => fromEffect$1(offer$1(queue, failCause$4(map$1(cause, some$1)))),
-    onDone: () => fromEffect$1(offer$1(queue, fail$3(none())))
+    onInput: input => flatMap$1(fromEffect$1(offerAll(queue, map$2(input, succeed$4))), () => writer),
+    onFailure: cause => fromEffect$1(offer$1(queue, failCause$2(map$3(cause, some$1)))),
+    onDone: () => fromEffect$1(offer$1(queue, fail$2(none())))
   });
   return pipe(pipeTo(toChannel(self), writer), drain$1, runScoped$1, asUnit);
 });
@@ -2226,7 +1855,7 @@ const runIntoQueueElementsScoped = /*#__PURE__*/dual(2, (self, queue) => {
 /** @internal */
 const runIntoQueueScoped = /*#__PURE__*/dual(2, (self, queue) => {
   const writer = readWithCause({
-    onInput: input => flatMap$2(write(chunk(input)), () => writer),
+    onInput: input => flatMap$1(write(chunk(input)), () => writer),
     onFailure: cause => write(failCause$6(cause)),
     onDone: () => write(end$2)
   });
@@ -2257,7 +1886,7 @@ const scanReduceEffect = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapAccumEf
       }
     case "Some":
       {
-        return pipe(f(option.value, a), map$2(b => [some$1(b), b]));
+        return pipe(f(option.value, a), map$1(b => [some$1(b), b]));
       }
   }
 })));
@@ -2275,23 +1904,23 @@ const scheduleWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
     if (next.done) {
       return readWithCause({
         onInput: chunk => loop(driver, chunk[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeedNow
       });
     }
     return unwrap$1(matchEffect(driver.next(next.value), {
-      onFailure: () => pipe(driver.last(), orDie$1, map$2(b => pipe(write(make$7(options.onElement(next.value), options.onSchedule(b))), flatMap$2(() => loop(driver, iterator)))), zipLeft$1(driver.reset())),
-      onSuccess: () => succeed$1(pipe(write(of(options.onElement(next.value))), flatMap$2(() => loop(driver, iterator))))
+      onFailure: () => pipe(driver.last(), orDie$1, map$1(b => pipe(write(make$7(options.onElement(next.value), options.onSchedule(b))), flatMap$1(() => loop(driver, iterator)))), zipLeft$1(driver.reset())),
+      onSuccess: () => succeed$1(pipe(write(of(options.onElement(next.value))), flatMap$1(() => loop(driver, iterator))))
     }));
   };
-  return new StreamImpl(pipe(fromEffect$1(driver(schedule)), flatMap$2(driver => pipe(toChannel(self), pipeTo(loop(driver, empty$1()[Symbol.iterator]()))))));
+  return new StreamImpl(pipe(fromEffect$1(driver(schedule)), flatMap$1(driver => pipe(toChannel(self), pipeTo(loop(driver, empty$1()[Symbol.iterator]()))))));
 });
 
 /** @internal */
-const scanEffect = /*#__PURE__*/dual(3, (self, s, f) => new StreamImpl(pipe(write(of(s)), flatMap$2(() => toChannel(pipe(self, mapAccumEffect(s, (s, a) => pipe(f(s, a), map$2(s => [s, s])))))))));
+const scanEffect = /*#__PURE__*/dual(3, (self, s, f) => new StreamImpl(pipe(write(of(s)), flatMap$1(() => toChannel(pipe(self, mapAccumEffect(s, (s, a) => pipe(f(s, a), map$1(s => [s, s])))))))));
 
 /** @internal */
-const scoped = effect => new StreamImpl(ensuring$1(scoped$2(pipe(effect, map$2(of))), unit$2));
+const scoped = effect => new StreamImpl(ensuring$1(scoped$2(pipe(effect, map$1(of))), unit$2));
 
 /** @internal */
 const some = self => pipe(self, mapError(some$1), someOrFail(() => none()));
@@ -2319,7 +1948,7 @@ const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => {
       if (queueSize < chunkSize) {
         const items = queue.toChunk();
         const result = isEmpty(items) ? empty$1() : of(items);
-        return pipe(write(result), flatMap$2(() => channelEnd));
+        return pipe(write(result), flatMap$1(() => channelEnd));
       }
       const lastEmitIndex = queueSize - (queueSize - chunkSize) % stepSize;
       if (lastEmitIndex === queueSize) {
@@ -2328,10 +1957,10 @@ const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => {
       const leftovers = queueSize - (lastEmitIndex - chunkSize + stepSize);
       const lastItems = pipe(queue.toChunk(), takeRight$1(leftovers));
       const result = isEmpty(lastItems) ? empty$1() : of(lastItems);
-      return pipe(write(result), flatMap$2(() => channelEnd));
+      return pipe(write(result), flatMap$1(() => channelEnd));
     };
     const reader = queueSize => readWithCause({
-      onInput: input => flatMap$2(write(filterMap$1(input, (element, index) => {
+      onInput: input => flatMap$1(write(filterMap$1(input, (element, index) => {
         queue.put(element);
         const currentIndex = queueSize + index + 1;
         if (currentIndex < chunkSize || (currentIndex - chunkSize) % stepSize > 0) {
@@ -2339,7 +1968,7 @@ const slidingSize = /*#__PURE__*/dual(3, (self, chunkSize, stepSize) => {
         }
         return some$1(queue.toChunk());
       })), () => reader(queueSize + input.length)),
-      onFailure: cause => emitOnStreamEnd(queueSize, failCause$3(cause)),
+      onFailure: cause => emitOnStreamEnd(queueSize, failCause$1(cause)),
       onDone: () => emitOnStreamEnd(queueSize, unit$1)
     });
     return pipe(toChannel(self), pipeTo(reader(0)));
@@ -2353,11 +1982,11 @@ const split = /*#__PURE__*/dual(2, (self, predicate) => {
     if (isEmpty(chunk) || isEmpty(remaining)) {
       return loop(pipe(chunk, appendAll(pipe(remaining, drop$1(1)))));
     }
-    return pipe(write(of(chunk)), flatMap$2(() => split(empty$1(), pipe(remaining, drop$1(1)))));
+    return pipe(write(of(chunk)), flatMap$1(() => split(empty$1(), pipe(remaining, drop$1(1)))));
   };
   const loop = leftovers => readWith({
     onInput: input => split(leftovers, input),
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: () => {
       if (isEmpty(leftovers)) {
         return unit$1;
@@ -2391,11 +2020,11 @@ const splitOnChunk = /*#__PURE__*/dual(2, (self, delimiter) => {
         return [concatenated, equals(a, pipe(delimiter, unsafeGet$1(0))) ? 1 : 0];
       }));
       const output = buffer === undefined ? empty$1() : unsafeFromArray(buffer);
-      return flatMap$2(write(output), () => next(isNonEmpty(carry) ? some$1(carry) : none(), delimiterCursor));
+      return flatMap$1(write(output), () => next(isNonEmpty(carry) ? some$1(carry) : none(), delimiterCursor));
     },
     onFailure: cause => match$2(leftover, {
-      onNone: () => failCause$3(cause),
-      onSome: chunk => zipRight$2(write(of(chunk)), failCause$3(cause))
+      onNone: () => failCause$1(cause),
+      onSome: chunk => zipRight$2(write(of(chunk)), failCause$1(cause))
     }),
     onDone: done => match$2(leftover, {
       onNone: () => succeed$3(done),
@@ -2411,7 +2040,7 @@ const splitLines = self => suspend(() => {
   let midCRLF = false;
   const splitLinesChunk = chunk => {
     const chunkBuilder = [];
-    map$3(chunk, str => {
+    map$2(chunk, str => {
       if (str.length !== 0) {
         let from = 0;
         let indexOfCR = str.indexOf("\r");
@@ -2471,10 +2100,10 @@ const splitLines = self => suspend(() => {
   const loop = readWithCause({
     onInput: input => {
       const out = splitLinesChunk(input);
-      return isEmpty(out) ? loop : flatMap$2(write(out), () => loop);
+      return isEmpty(out) ? loop : flatMap$1(write(out), () => loop);
     },
-    onFailure: cause => stringBuilder.length === 0 ? failCause$3(cause) : flatMap$2(write(of(stringBuilder)), () => failCause$3(cause)),
-    onDone: done => stringBuilder.length === 0 ? succeed$3(done) : flatMap$2(write(of(stringBuilder)), () => succeed$3(done))
+    onFailure: cause => stringBuilder.length === 0 ? failCause$1(cause) : flatMap$1(write(of(stringBuilder)), () => failCause$1(cause)),
+    onDone: done => stringBuilder.length === 0 ? succeed$3(done) : flatMap$1(write(of(stringBuilder)), () => succeed$3(done))
   });
   return new StreamImpl(pipeTo(toChannel(self), loop));
 });
@@ -2499,11 +2128,11 @@ const take = /*#__PURE__*/dual(2, (self, n) => {
       const leftover = Math.max(0, n - taken.length);
       const more = leftover > 0;
       if (more) {
-        return pipe(write(taken), flatMap$2(() => loop(leftover)));
+        return pipe(write(taken), flatMap$1(() => loop(leftover)));
       }
       return write(taken);
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: succeed$3
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(0 < n ? loop(n) : unit$1)));
@@ -2514,7 +2143,7 @@ const takeRight = /*#__PURE__*/dual(2, (self, n) => {
   if (n <= 0) {
     return empty;
   }
-  return new StreamImpl(pipe(succeed$1(new RingBuffer(n)), map$2(queue => {
+  return new StreamImpl(pipe(succeed$1(new RingBuffer(n)), map$1(queue => {
     const reader = readWith({
       onInput: input => {
         for (const element of input) {
@@ -2522,7 +2151,7 @@ const takeRight = /*#__PURE__*/dual(2, (self, n) => {
         }
         return reader;
       },
-      onFailure: fail$2,
+      onFailure: fail$1,
       onDone: () => pipe(write(queue.toChunk()), zipRight$2(unit$1))
     });
     return pipe(toChannel(self), pipeTo(reader));
@@ -2536,11 +2165,11 @@ const takeUntil = /*#__PURE__*/dual(2, (self, predicate) => {
       const taken = pipe(input, takeWhile$1(a => !predicate(a)));
       const last = pipe(input, drop$1(taken.length), take$3(1));
       if (isEmpty(last)) {
-        return pipe(write(taken), flatMap$2(() => loop));
+        return pipe(write(taken), flatMap$1(() => loop));
       }
       return write(pipe(taken, appendAll(last)));
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: succeed$3
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(loop)));
@@ -2553,11 +2182,11 @@ const takeUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => {
     if (next.done) {
       return readWithCause({
         onInput: elem => loop(elem[Symbol.iterator]()),
-        onFailure: failCause$3,
+        onFailure: failCause$1,
         onDone: succeed$3
       });
     }
-    return pipe(predicate(next.value), map$2(bool => bool ? write(of(next.value)) : pipe(write(of(next.value)), flatMap$2(() => loop(iterator)))), unwrap$1);
+    return pipe(predicate(next.value), map$1(bool => bool ? write(of(next.value)) : pipe(write(of(next.value)), flatMap$1(() => loop(iterator)))), unwrap$1);
   };
   return new StreamImpl(pipe(toChannel(self), pipeTo(loop(empty$1()[Symbol.iterator]()))));
 });
@@ -2569,11 +2198,11 @@ const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => {
       const taken = pipe(input, takeWhile$1(predicate));
       const more = taken.length === input.length;
       if (more) {
-        return pipe(write(taken), flatMap$2(() => loop));
+        return pipe(write(taken), flatMap$1(() => loop));
       }
       return write(taken);
     },
-    onFailure: fail$2,
+    onFailure: fail$1,
     onDone: succeed$3
   });
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(loop)));
@@ -2589,13 +2218,13 @@ const tapBoth = /*#__PURE__*/dual(2, (self, {
 }) => pipe(self, tapError(onFailure), tap(onSuccess)));
 
 /** @internal */
-const tapError = /*#__PURE__*/dual(2, (self, f) => catchAll(self, error => fromEffect(zipRight$1(f(error), fail$1(error)))));
+const tapError = /*#__PURE__*/dual(2, (self, f) => catchAll(self, error => fromEffect(zipRight$1(f(error), fail$3(error)))));
 
 /** @internal */
 const tapErrorCause = /*#__PURE__*/dual(2, (self, f) => {
   const loop = readWithCause({
-    onInput: chunk => flatMap$2(write(chunk), () => loop),
-    onFailure: cause => fromEffect$1(zipRight$1(f(cause), failCause$2(cause))),
+    onInput: chunk => flatMap$1(write(chunk), () => loop),
+    onFailure: cause => fromEffect$1(zipRight$1(f(cause), failCause$4(cause))),
     onDone: succeedNow
   });
   return new StreamImpl(pipe(toChannel(self), pipeTo(loop)));
@@ -2608,12 +2237,12 @@ const tapSink = /*#__PURE__*/dual(2, (self, sink) => pipe(fromEffect(all([bounde
   }));
   const loop = readWithCause({
     onInput: chunk$1 => pipe(fromEffect$1(offer$1(queue, chunk(chunk$1))), foldCauseChannel({
-      onFailure: () => flatMap$2(write(chunk$1), () => identityChannel()),
-      onSuccess: () => flatMap$2(write(chunk$1), () => loop)
+      onFailure: () => flatMap$1(write(chunk$1), () => identityChannel()),
+      onSuccess: () => flatMap$1(write(chunk$1), () => loop)
     })),
     onFailure: cause => pipe(fromEffect$1(offer$1(queue, failCause$6(cause))), foldCauseChannel({
-      onFailure: () => failCause$3(cause),
-      onSuccess: () => failCause$3(cause)
+      onFailure: () => failCause$1(cause),
+      onSuccess: () => failCause$1(cause)
     })),
     onDone: () => pipe(fromEffect$1(offer$1(queue, end$2)), foldCauseChannel({
       onFailure: () => unit$1,
@@ -2638,26 +2267,26 @@ const throttleEffect = /*#__PURE__*/dual(2, (self, options) => {
 });
 const throttleEnforceEffect = (self, cost, units, duration, burst) => {
   const loop = (tokens, timestampMillis) => readWithCause({
-    onInput: input => pipe(cost(input), zip$1(currentTimeMillis), map$2(([weight, currentTimeMillis]) => {
+    onInput: input => pipe(cost(input), zip$1(currentTimeMillis), map$1(([weight, currentTimeMillis]) => {
       const elapsed = currentTimeMillis - timestampMillis;
       const cycles = elapsed / toMillis(duration);
       const sum = tokens + cycles * units;
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
       const available = sum < 0 ? max : Math.min(sum, max);
       if (weight <= available) {
-        return pipe(write(input), flatMap$2(() => loop(available - weight, currentTimeMillis)));
+        return pipe(write(input), flatMap$1(() => loop(available - weight, currentTimeMillis)));
       }
       return loop(tokens, timestampMillis);
     }), unwrap$1),
-    onFailure: failCause$3,
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
-  const throttled = pipe(currentTimeMillis, map$2(currentTimeMillis => loop(units, currentTimeMillis)), unwrap$1);
+  const throttled = pipe(currentTimeMillis, map$1(currentTimeMillis => loop(units, currentTimeMillis)), unwrap$1);
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(throttled)));
 };
 const throttleShapeEffect = (self, costFn, units, duration, burst) => {
   const loop = (tokens, timestampMillis) => readWithCause({
-    onInput: input => pipe(costFn(input), zip$1(currentTimeMillis), map$2(([weight, currentTimeMillis]) => {
+    onInput: input => pipe(costFn(input), zip$1(currentTimeMillis), map$1(([weight, currentTimeMillis]) => {
       const elapsed = currentTimeMillis - timestampMillis;
       const cycles = elapsed / toMillis(duration);
       const sum = tokens + cycles * units;
@@ -2667,14 +2296,14 @@ const throttleShapeEffect = (self, costFn, units, duration, burst) => {
       const waitCycles = remaining >= 0 ? 0 : -remaining / units;
       const delay = millis(Math.max(0, waitCycles * toMillis(duration)));
       if (greaterThan(delay, zero)) {
-        return pipe(fromEffect$1(sleep(delay)), zipRight$2(write(input)), flatMap$2(() => loop(remaining, currentTimeMillis)));
+        return pipe(fromEffect$1(sleep(delay)), zipRight$2(write(input)), flatMap$1(() => loop(remaining, currentTimeMillis)));
       }
-      return flatMap$2(write(input), () => loop(remaining, currentTimeMillis));
+      return flatMap$1(write(input), () => loop(remaining, currentTimeMillis));
     }), unwrap$1),
-    onFailure: failCause$3,
+    onFailure: failCause$1,
     onDone: () => unit$1
   });
-  const throttled = pipe(currentTimeMillis, map$2(currentTimeMillis => loop(units, currentTimeMillis)), unwrap$1);
+  const throttled = pipe(currentTimeMillis, map$1(currentTimeMillis => loop(units, currentTimeMillis)), unwrap$1);
   return new StreamImpl(pipe(toChannel(self), pipeToOrFail(throttled)));
 };
 
@@ -2682,7 +2311,7 @@ const throttleShapeEffect = (self, costFn, units, duration, burst) => {
 const tick = interval => repeatWithSchedule(void 0, spaced(interval));
 
 /** @internal */
-const timeout = /*#__PURE__*/dual(2, (self, duration) => pipe(toPull(self), map$2(timeoutFail$1({
+const timeout = /*#__PURE__*/dual(2, (self, duration) => pipe(toPull(self), map$1(timeoutFail$1({
   onTimeout: () => none(),
   duration
 })), fromPull));
@@ -2691,8 +2320,8 @@ const timeout = /*#__PURE__*/dual(2, (self, duration) => pipe(toPull(self), map$
 const timeoutFail = /*#__PURE__*/dual(3, (self, error, duration) => pipe(self, timeoutTo(duration, failSync(error))));
 
 /** @internal */
-const timeoutFailCause = /*#__PURE__*/dual(3, (self, cause, duration) => pipe(toPull(self), map$2(timeoutFailCause$1({
-  onTimeout: () => map$1(cause(), some$1),
+const timeoutFailCause = /*#__PURE__*/dual(3, (self, cause, duration) => pipe(toPull(self), map$1(timeoutFailCause$1({
+  onTimeout: () => map$3(cause(), some$1),
   duration
 })), fromPull));
 
@@ -2706,8 +2335,8 @@ const timeoutTo = /*#__PURE__*/dual(3, (self, duration, that) => {
 const toHub = /*#__PURE__*/dual(2, (self, capacity) => pipe(acquireRelease$1(bounded$1(capacity), hub => shutdown$1(hub)), tap$1(hub => pipe(self, runIntoHubScoped(hub), forkScoped))));
 
 /** @internal */
-const toPull = self => map$2(toPull$1(toChannel(self)), pull => pipe(pull, mapError$1(some$1), flatMap$1(match({
-  onLeft: () => fail$1(none()),
+const toPull = self => map$1(toPull$1(toChannel(self)), pull => pipe(pull, mapError$1(some$1), flatMap$2(match({
+  onLeft: () => fail$3(none()),
   onRight: succeed$1
 }))));
 
@@ -2725,7 +2354,7 @@ const toReadableStream = source => {
     start(controller) {
       scope = runSync(make$6());
       pull = pipe(toPull(source), use(scope), runSync, tap$1(chunk => sync$1(() => {
-        map$3(chunk, a => {
+        map$2(chunk, a => {
           controller.enqueue(a);
         });
       })), tapErrorCause$1(() => close(scope, unit$3)), catchTags$1({
@@ -2759,13 +2388,13 @@ const transduce = /*#__PURE__*/dual(2, (self, sink) => {
       const leftover = leftovers.ref;
       if (isEmpty(leftover)) {
         return readWith({
-          onInput: input => pipe(write(input), flatMap$2(() => buffer)),
-          onFailure: fail$2,
+          onInput: input => pipe(write(input), flatMap$1(() => buffer)),
+          onFailure: fail$1,
           onDone: succeedNow
         });
       }
       leftovers.ref = empty$1();
-      return pipe(writeChunk(leftover), flatMap$2(() => buffer));
+      return pipe(writeChunk(leftover), flatMap$1(() => buffer));
     });
     const concatAndGet = chunk => {
       const leftover = leftovers.ref;
@@ -2774,15 +2403,15 @@ const transduce = /*#__PURE__*/dual(2, (self, sink) => {
       return concatenated;
     };
     const upstreamMarker = readWith({
-      onInput: input => flatMap$2(write(input), () => upstreamMarker),
-      onFailure: fail$2,
+      onInput: input => flatMap$1(write(input), () => upstreamMarker),
+      onFailure: fail$1,
       onDone: done => zipRight$2(sync$2(() => {
         upstreamDone.ref = true;
       }), succeedNow(done))
     });
-    const transducer = pipe(sink, toChannel$1, collectElements, flatMap$2(([leftover, z]) => pipe(succeed$3([upstreamDone.ref, concatAndGet(leftover)]), flatMap$2(([done, newLeftovers]) => {
+    const transducer = pipe(sink, toChannel$1, collectElements, flatMap$1(([leftover, z]) => pipe(succeed$3([upstreamDone.ref, concatAndGet(leftover)]), flatMap$1(([done, newLeftovers]) => {
       const nextChannel = done && isEmpty(newLeftovers) ? unit$1 : transducer;
-      return pipe(write(of(z)), flatMap$2(() => nextChannel));
+      return pipe(write(of(z)), flatMap$1(() => nextChannel));
     }))));
     return pipe(toChannel(self), pipeTo(upstreamMarker), pipeTo(buffer), pipeToOrFail(transducer));
   });
@@ -2796,22 +2425,22 @@ const unfold = (s, f) => unfoldChunk(s, s => pipe(f(s), map$4(([a, s]) => [of(a)
 const unfoldChunk = (s, f) => {
   const loop = s => match$2(f(s), {
     onNone: () => unit$1,
-    onSome: ([chunk, s]) => flatMap$2(write(chunk), () => loop(s))
+    onSome: ([chunk, s]) => flatMap$1(write(chunk), () => loop(s))
   });
   return new StreamImpl(suspend$2(() => loop(s)));
 };
 
 /** @internal */
 const unfoldChunkEffect = (s, f) => suspend(() => {
-  const loop = s => unwrap$1(map$2(f(s), match$2({
+  const loop = s => unwrap$1(map$1(f(s), match$2({
     onNone: () => unit$1,
-    onSome: ([chunk, s]) => flatMap$2(write(chunk), () => loop(s))
+    onSome: ([chunk, s]) => flatMap$1(write(chunk), () => loop(s))
   })));
   return new StreamImpl(loop(s));
 });
 
 /** @internal */
-const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => pipe(f(s), map$2(map$4(([a, s]) => [of(a), s]))));
+const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => pipe(f(s), map$1(map$4(([a, s]) => [of(a), s]))));
 
 /** @internal */
 const unit = /*#__PURE__*/succeed(void 0);
@@ -2904,33 +2533,33 @@ const zipAllSortedByKeyWith = /*#__PURE__*/dual(2, (self, options) => {
       case OP_DRAIN_LEFT:
         {
           return pipe(pullLeft, match$1({
-            onFailure: fail$3,
-            onSuccess: leftChunk => succeed$4([map$3(leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])
+            onFailure: fail$2,
+            onSuccess: leftChunk => succeed$4([map$2(leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])
           }));
         }
       case OP_DRAIN_RIGHT:
         {
           return pipe(pullRight, match$1({
-            onFailure: fail$3,
-            onSuccess: rightChunk => succeed$4([map$3(rightChunk, ([k, a2]) => [k, options.onOther(a2)]), DrainRight])
+            onFailure: fail$2,
+            onSuccess: rightChunk => succeed$4([map$2(rightChunk, ([k, a2]) => [k, options.onOther(a2)]), DrainRight])
           }));
         }
-      case OP_PULL_BOTH$1:
+      case OP_PULL_BOTH:
         {
           return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
             concurrent: true
           }), matchEffect({
-            onFailure: error => succeed$1(fail$3(some$1(error))),
+            onFailure: error => succeed$1(fail$2(some$1(error))),
             onSuccess: ([leftOption, rightOption]) => {
               if (isSome(leftOption) && isSome(rightOption)) {
                 if (isEmpty(leftOption.value) && isEmpty(rightOption.value)) {
-                  return pull(PullBoth$1, pullLeft, pullRight);
+                  return pull(PullBoth, pullLeft, pullRight);
                 }
                 if (isEmpty(leftOption.value)) {
-                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
+                  return pull(PullLeft(rightOption.value), pullLeft, pullRight);
                 }
                 if (isEmpty(rightOption.value)) {
-                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
+                  return pull(PullRight(leftOption.value), pullLeft, pullRight);
                 }
                 return succeed$1(succeed$4(merge(leftOption.value, rightOption.value)));
               }
@@ -2938,36 +2567,36 @@ const zipAllSortedByKeyWith = /*#__PURE__*/dual(2, (self, options) => {
                 if (isEmpty(leftOption.value)) {
                   return pull(DrainLeft, pullLeft, pullRight);
                 }
-                return succeed$1(succeed$4([pipe(leftOption.value, map$3(([k, a]) => [k, options.onSelf(a)])), DrainLeft]));
+                return succeed$1(succeed$4([pipe(leftOption.value, map$2(([k, a]) => [k, options.onSelf(a)])), DrainLeft]));
               }
               if (isNone(leftOption) && isSome(rightOption)) {
                 if (isEmpty(rightOption.value)) {
                   return pull(DrainRight, pullLeft, pullRight);
                 }
-                return succeed$1(succeed$4([pipe(rightOption.value, map$3(([k, a2]) => [k, options.onOther(a2)])), DrainRight]));
+                return succeed$1(succeed$4([pipe(rightOption.value, map$2(([k, a2]) => [k, options.onOther(a2)])), DrainRight]));
               }
-              return succeed$1(fail$3(none()));
+              return succeed$1(fail$2(none()));
             }
           }));
         }
-      case OP_PULL_LEFT$1:
+      case OP_PULL_LEFT:
         {
           return matchEffect(pullLeft, {
             onFailure: match$2({
-              onNone: () => succeed$1(succeed$4([pipe(state.rightChunk, map$3(([k, a2]) => [k, options.onOther(a2)])), DrainRight])),
-              onSome: error => succeed$1(fail$3(some$1(error)))
+              onNone: () => succeed$1(succeed$4([pipe(state.rightChunk, map$2(([k, a2]) => [k, options.onOther(a2)])), DrainRight])),
+              onSome: error => succeed$1(fail$2(some$1(error)))
             }),
-            onSuccess: leftChunk => isEmpty(leftChunk) ? pull(PullLeft$1(state.rightChunk), pullLeft, pullRight) : succeed$1(succeed$4(merge(leftChunk, state.rightChunk)))
+            onSuccess: leftChunk => isEmpty(leftChunk) ? pull(PullLeft(state.rightChunk), pullLeft, pullRight) : succeed$1(succeed$4(merge(leftChunk, state.rightChunk)))
           });
         }
-      case OP_PULL_RIGHT$1:
+      case OP_PULL_RIGHT:
         {
           return matchEffect(pullRight, {
             onFailure: match$2({
-              onNone: () => succeed$1(succeed$4([map$3(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])),
-              onSome: error => succeed$1(fail$3(some$1(error)))
+              onNone: () => succeed$1(succeed$4([map$2(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])),
+              onSome: error => succeed$1(fail$2(some$1(error)))
             }),
-            onSuccess: rightChunk => isEmpty(rightChunk) ? pull(PullRight$1(state.leftChunk), pullLeft, pullRight) : succeed$1(succeed$4(merge(state.leftChunk, rightChunk)))
+            onSuccess: rightChunk => isEmpty(rightChunk) ? pull(PullRight(state.leftChunk), pullLeft, pullRight) : succeed$1(succeed$4(merge(state.leftChunk, rightChunk)))
           });
         }
     }
@@ -2999,13 +2628,13 @@ const zipAllSortedByKeyWith = /*#__PURE__*/dual(2, (self, options) => {
           k2 = rightTuple[0];
           a2 = rightTuple[1];
         } else if (hasNext(leftChunk, leftIndex)) {
-          state = PullRight$1(pipe(leftChunk, drop$1(leftIndex + 1)));
+          state = PullRight(pipe(leftChunk, drop$1(leftIndex + 1)));
           loop = false;
         } else if (hasNext(rightChunk, rightIndex)) {
-          state = PullLeft$1(pipe(rightChunk, drop$1(rightIndex + 1)));
+          state = PullLeft(pipe(rightChunk, drop$1(rightIndex + 1)));
           loop = false;
         } else {
-          state = PullBoth$1;
+          state = PullBoth;
           loop = false;
         }
       } else if (compare < 0) {
@@ -3023,7 +2652,7 @@ const zipAllSortedByKeyWith = /*#__PURE__*/dual(2, (self, options) => {
             rightTuple = pipe(rightChunk, unsafeGet$1(rightIndex));
             rightBuilder.push(rightTuple);
           }
-          state = PullLeft$1(unsafeFromArray(rightBuilder));
+          state = PullLeft(unsafeFromArray(rightBuilder));
           loop = false;
         }
       } else {
@@ -3041,14 +2670,14 @@ const zipAllSortedByKeyWith = /*#__PURE__*/dual(2, (self, options) => {
             leftTuple = pipe(leftChunk, unsafeGet$1(leftIndex));
             leftBuilder.push(leftTuple);
           }
-          state = PullRight$1(unsafeFromArray(leftBuilder));
+          state = PullRight(unsafeFromArray(leftBuilder));
           loop = false;
         }
       }
     }
     return [unsafeFromArray(builder), state];
   };
-  return combineChunks(self, options.other, PullBoth$1, pull);
+  return combineChunks(self, options.other, PullBoth, pull);
 });
 
 /** @internal */
@@ -3058,77 +2687,77 @@ const zipAllWith = /*#__PURE__*/dual(2, (self, options) => {
       case OP_DRAIN_LEFT:
         {
           return matchEffect(pullLeft, {
-            onFailure: error => succeed$1(fail$3(error)),
-            onSuccess: leftChunk => succeed$1(succeed$4([map$3(leftChunk, options.onSelf), DrainLeft]))
+            onFailure: error => succeed$1(fail$2(error)),
+            onSuccess: leftChunk => succeed$1(succeed$4([map$2(leftChunk, options.onSelf), DrainLeft]))
           });
         }
       case OP_DRAIN_RIGHT:
         {
           return matchEffect(pullRight, {
-            onFailure: error => succeed$1(fail$3(error)),
-            onSuccess: rightChunk => succeed$1(succeed$4([map$3(rightChunk, options.onOther), DrainRight]))
+            onFailure: error => succeed$1(fail$2(error)),
+            onSuccess: rightChunk => succeed$1(succeed$4([map$2(rightChunk, options.onOther), DrainRight]))
           });
         }
-      case OP_PULL_BOTH$1:
+      case OP_PULL_BOTH:
         {
           return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
             concurrent: true
           }), matchEffect({
-            onFailure: error => succeed$1(fail$3(some$1(error))),
+            onFailure: error => succeed$1(fail$2(some$1(error))),
             onSuccess: ([leftOption, rightOption]) => {
               if (isSome(leftOption) && isSome(rightOption)) {
                 if (isEmpty(leftOption.value) && isEmpty(rightOption.value)) {
-                  return pull(PullBoth$1, pullLeft, pullRight);
+                  return pull(PullBoth, pullLeft, pullRight);
                 }
                 if (isEmpty(leftOption.value)) {
-                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
+                  return pull(PullLeft(rightOption.value), pullLeft, pullRight);
                 }
                 if (isEmpty(rightOption.value)) {
-                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
+                  return pull(PullRight(leftOption.value), pullLeft, pullRight);
                 }
                 return succeed$1(succeed$4(zip(leftOption.value, rightOption.value, options.onBoth)));
               }
               if (isSome(leftOption) && isNone(rightOption)) {
-                return succeed$1(succeed$4([map$3(leftOption.value, options.onSelf), DrainLeft]));
+                return succeed$1(succeed$4([map$2(leftOption.value, options.onSelf), DrainLeft]));
               }
               if (isNone(leftOption) && isSome(rightOption)) {
-                return succeed$1(succeed$4([map$3(rightOption.value, options.onOther), DrainRight]));
+                return succeed$1(succeed$4([map$2(rightOption.value, options.onOther), DrainRight]));
               }
-              return succeed$1(fail$3(none()));
+              return succeed$1(fail$2(none()));
             }
           }));
         }
-      case OP_PULL_LEFT$1:
+      case OP_PULL_LEFT:
         {
           return matchEffect(pullLeft, {
             onFailure: match$2({
-              onNone: () => succeed$1(succeed$4([map$3(state.rightChunk, options.onOther), DrainRight])),
-              onSome: error => succeed$1(fail$3(some$1(error)))
+              onNone: () => succeed$1(succeed$4([map$2(state.rightChunk, options.onOther), DrainRight])),
+              onSome: error => succeed$1(fail$2(some$1(error)))
             }),
             onSuccess: leftChunk => {
               if (isEmpty(leftChunk)) {
-                return pull(PullLeft$1(state.rightChunk), pullLeft, pullRight);
+                return pull(PullLeft(state.rightChunk), pullLeft, pullRight);
               }
               if (isEmpty(state.rightChunk)) {
-                return pull(PullRight$1(leftChunk), pullLeft, pullRight);
+                return pull(PullRight(leftChunk), pullLeft, pullRight);
               }
               return succeed$1(succeed$4(zip(leftChunk, state.rightChunk, options.onBoth)));
             }
           });
         }
-      case OP_PULL_RIGHT$1:
+      case OP_PULL_RIGHT:
         {
           return matchEffect(pullRight, {
             onFailure: match$2({
-              onNone: () => succeed$1(succeed$4([map$3(state.leftChunk, options.onSelf), DrainLeft])),
-              onSome: error => succeed$1(fail$3(some$1(error)))
+              onNone: () => succeed$1(succeed$4([map$2(state.leftChunk, options.onSelf), DrainLeft])),
+              onSome: error => succeed$1(fail$2(some$1(error)))
             }),
             onSuccess: rightChunk => {
               if (isEmpty(rightChunk)) {
-                return pull(PullRight$1(state.leftChunk), pullLeft, pullRight);
+                return pull(PullRight(state.leftChunk), pullLeft, pullRight);
               }
               if (isEmpty(state.leftChunk)) {
-                return pull(PullLeft$1(rightChunk), pullLeft, pullRight);
+                return pull(PullLeft(rightChunk), pullLeft, pullRight);
               }
               return succeed$1(succeed$4(zip(state.leftChunk, rightChunk, options.onBoth)));
             }
@@ -3142,20 +2771,20 @@ const zipAllWith = /*#__PURE__*/dual(2, (self, options) => {
       case "Left":
         {
           if (isEmpty(either.left)) {
-            return [output, PullBoth$1];
+            return [output, PullBoth];
           }
-          return [output, PullRight$1(either.left)];
+          return [output, PullRight(either.left)];
         }
       case "Right":
         {
           if (isEmpty(either.right)) {
-            return [output, PullBoth$1];
+            return [output, PullBoth];
           }
-          return [output, PullLeft$1(either.right)];
+          return [output, PullLeft(either.right)];
         }
     }
   };
-  return combineChunks(self, options.other, PullBoth$1, pull);
+  return combineChunks(self, options.other, PullBoth, pull);
 });
 
 /** @internal */
@@ -3163,13 +2792,13 @@ const zipLatest = /*#__PURE__*/dual(2, (self, that) => pipe(self, zipLatestWith(
 
 /** @internal */
 const zipLatestWith = /*#__PURE__*/dual(3, (self, that, f) => {
-  const pullNonEmpty = pull => pipe(pull, flatMap$1(chunk => isEmpty(chunk) ? pullNonEmpty(pull) : succeed$1(chunk)));
-  return pipe(toPull(self), map$2(pullNonEmpty), zip$1(pipe(toPull(that), map$2(pullNonEmpty))), flatMap$1(([left, right]) => pipe(fromEffectOption(raceWith(left, right, {
+  const pullNonEmpty = pull => pipe(pull, flatMap$2(chunk => isEmpty(chunk) ? pullNonEmpty(pull) : succeed$1(chunk)));
+  return pipe(toPull(self), map$1(pullNonEmpty), zip$1(pipe(toPull(that), map$1(pullNonEmpty))), flatMap$2(([left, right]) => pipe(fromEffectOption(raceWith(left, right, {
     onSelfDone: (leftDone, rightFiber) => pipe(suspend$1(() => leftDone), zipWith$1(join(rightFiber), (l, r) => [l, r, true])),
     onOtherDone: (rightDone, leftFiber) => pipe(suspend$1(() => rightDone), zipWith$1(join(leftFiber), (l, r) => [r, l, false]))
-  })), flatMap(([l, r, leftFirst]) => pipe(fromEffect(make$3([unsafeLast(l), unsafeLast(r)])), flatMap(latest => pipe(fromChunk(leftFirst ? pipe(r, map$3(a2 => f(unsafeLast(l), a2))) : pipe(l, map$3(a => f(a, unsafeLast(r))))), concat(pipe(repeatEffectOption(left), mergeEither(repeatEffectOption(right)), mapEffectSequential(match({
-    onLeft: leftChunk => pipe(modify(latest, ([_, rightLatest]) => [pipe(leftChunk, map$3(a => f(a, rightLatest))), [unsafeLast(leftChunk), rightLatest]])),
-    onRight: rightChunk => pipe(modify(latest, ([leftLatest, _]) => [pipe(rightChunk, map$3(a2 => f(leftLatest, a2))), [leftLatest, unsafeLast(rightChunk)]]))
+  })), flatMap(([l, r, leftFirst]) => pipe(fromEffect(make$2([unsafeLast(l), unsafeLast(r)])), flatMap(latest => pipe(fromChunk(leftFirst ? pipe(r, map$2(a2 => f(unsafeLast(l), a2))) : pipe(l, map$2(a => f(a, unsafeLast(r))))), concat(pipe(repeatEffectOption(left), mergeEither(repeatEffectOption(right)), mapEffectSequential(match({
+    onLeft: leftChunk => pipe(modify(latest, ([_, rightLatest]) => [pipe(leftChunk, map$2(a => f(a, rightLatest))), [unsafeLast(leftChunk), rightLatest]])),
+    onRight: rightChunk => pipe(modify(latest, ([leftLatest, _]) => [pipe(rightChunk, map$2(a2 => f(leftLatest, a2))), [leftLatest, unsafeLast(rightChunk)]]))
   })), flatMap(fromChunk))))))), toPull)), fromPull);
 });
 
@@ -3196,54 +2825,54 @@ const zipWith = /*#__PURE__*/dual(3, (self, that, f) => pipe(self, zipWithChunks
 const zipWithChunks = /*#__PURE__*/dual(3, (self, that, f) => {
   const pull = (state, pullLeft, pullRight) => {
     switch (state._tag) {
-      case OP_PULL_BOTH:
+      case OP_PULL_BOTH$1:
         {
           return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
             concurrent: true
           }), matchEffect({
-            onFailure: error => succeed$1(fail$3(some$1(error))),
+            onFailure: error => succeed$1(fail$2(some$1(error))),
             onSuccess: ([leftOption, rightOption]) => {
               if (isSome(leftOption) && isSome(rightOption)) {
                 if (isEmpty(leftOption.value) && isEmpty(rightOption.value)) {
-                  return pull(PullBoth, pullLeft, pullRight);
+                  return pull(PullBoth$1, pullLeft, pullRight);
                 }
                 if (isEmpty(leftOption.value)) {
-                  return pull(PullLeft(rightOption.value), pullLeft, pullRight);
+                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
                 }
                 if (isEmpty(rightOption.value)) {
-                  return pull(PullRight(leftOption.value), pullLeft, pullRight);
+                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
                 }
                 return succeed$1(succeed$4(zip(leftOption.value, rightOption.value)));
               }
-              return succeed$1(fail$3(none()));
+              return succeed$1(fail$2(none()));
             }
           }));
         }
-      case OP_PULL_LEFT:
+      case OP_PULL_LEFT$1:
         {
           return matchEffect(pullLeft, {
-            onFailure: error => succeed$1(fail$3(error)),
+            onFailure: error => succeed$1(fail$2(error)),
             onSuccess: leftChunk => {
               if (isEmpty(leftChunk)) {
-                return pull(PullLeft(state.rightChunk), pullLeft, pullRight);
+                return pull(PullLeft$1(state.rightChunk), pullLeft, pullRight);
               }
               if (isEmpty(state.rightChunk)) {
-                return pull(PullRight(leftChunk), pullLeft, pullRight);
+                return pull(PullRight$1(leftChunk), pullLeft, pullRight);
               }
               return succeed$1(succeed$4(zip(leftChunk, state.rightChunk)));
             }
           });
         }
-      case OP_PULL_RIGHT:
+      case OP_PULL_RIGHT$1:
         {
           return matchEffect(pullRight, {
-            onFailure: error => succeed$1(fail$3(error)),
+            onFailure: error => succeed$1(fail$2(error)),
             onSuccess: rightChunk => {
               if (isEmpty(rightChunk)) {
-                return pull(PullRight(state.leftChunk), pullLeft, pullRight);
+                return pull(PullRight$1(state.leftChunk), pullLeft, pullRight);
               }
               if (isEmpty(state.leftChunk)) {
-                return pull(PullLeft(rightChunk), pullLeft, pullRight);
+                return pull(PullLeft$1(rightChunk), pullLeft, pullRight);
               }
               return succeed$1(succeed$4(zip(state.leftChunk, rightChunk)));
             }
@@ -3257,20 +2886,20 @@ const zipWithChunks = /*#__PURE__*/dual(3, (self, that, f) => {
       case "Left":
         {
           if (isEmpty(either.left)) {
-            return [output, PullBoth];
+            return [output, PullBoth$1];
           }
-          return [output, PullRight(either.left)];
+          return [output, PullRight$1(either.left)];
         }
       case "Right":
         {
           if (isEmpty(either.right)) {
-            return [output, PullBoth];
+            return [output, PullBoth$1];
           }
-          return [output, PullLeft(either.right)];
+          return [output, PullLeft$1(either.right)];
         }
     }
   };
-  return pipe(self, combineChunks(that, PullBoth, pull));
+  return pipe(self, combineChunks(that, PullBoth$1, pull));
 });
 
 /** @internal */
@@ -3282,9 +2911,9 @@ const zipWithNext = self => {
     onInput: input => {
       const [newLast, chunk] = mapAccum$1(input, last, (prev, curr) => [some$1(curr), pipe(prev, map$4(a => [a, curr]))]);
       const output = filterMap$1(chunk, option => isSome(option) ? some$1([option.value[0], some$1(option.value[1])]) : none());
-      return flatMap$2(write(output), () => process(newLast));
+      return flatMap$1(write(output), () => process(newLast));
     },
-    onFailure: failCause$3,
+    onFailure: failCause$1,
     onDone: () => match$2(last, {
       onNone: () => unit$1,
       onSome: value => zipRight$2(write(of([value, none()])), unit$1)
@@ -3352,4 +2981,4 @@ const encodeText = self => suspend(() => {
   return map(self, s => encoder.encode(s));
 });
 
-export { empty as $, chunksWith as A, combine as B, combineChunks as C, DefaultChunkSize as D, concat as E, concatAll as F, cross as G, crossLeft as H, crossRight as I, crossWith as J, debounce as K, die as L, dieSync as M, dieMessage as N, distributedWith as O, distributedWithDynamic as P, drain as Q, drainFork as R, StreamTypeId as S, drop as T, dropRight as U, dropUntil as V, dropUntilEffect as W, dropWhile as X, dropWhileEffect as Y, either as Z, _async as _, acquireRelease as a, mapAccum as a$, ensuring as a0, ensuringWith as a1, context as a2, contextWith as a3, contextWithEffect as a4, contextWithStream as a5, execute as a6, fail as a7, failSync as a8, failCause as a9, fromEffectOption as aA, fromHub as aB, fromIterable as aC, fromIterableEffect as aD, fromIteratorSucceed as aE, fromPull as aF, fromQueue as aG, fromReadableStream as aH, fromReadableStreamByob as aI, fromSchedule as aJ, groupAdjacentBy as aK, grouped as aL, groupedWithin as aM, haltAfter as aN, haltWhen as aO, haltWhenDeferred as aP, identityStream as aQ, interleave as aR, interleaveWith as aS, intersperse as aT, intersperseAffixes as aU, interruptAfter as aV, interruptWhen as aW, interruptWhenDeferred as aX, iterate as aY, make as aZ, map as a_, failCauseSync as aa, filter as ab, filterEffect as ac, filterMap as ad, filterMapEffect as ae, filterMapWhile as af, filterMapWhileEffect as ag, finalizer as ah, find as ai, findEffect as aj, flatMap as ak, flatten as al, flattenChunks as am, flattenEffect as an, flattenExitOption as ao, flattenIterables as ap, flattenTake as aq, forever as ar, fromAsyncIterable as as, fromChannel as at, toChannel as au, fromChunk as av, fromChunkHub as aw, fromChunkQueue as ax, fromChunks as ay, fromEffect as az, aggregate as b, run as b$, mapAccumEffect as b0, mapBoth as b1, mapChunks as b2, mapChunksEffect as b3, mapConcat as b4, mapConcatChunk as b5, mapConcatChunkEffect as b6, mapConcatEffect as b7, mapError as b8, mapErrorCause as b9, pipeThrough as bA, pipeThroughChannel as bB, pipeThroughChannelOrFail as bC, prepend as bD, provideContext as bE, provideLayer as bF, provideService as bG, provideServiceEffect as bH, provideServiceStream as bI, mapInputContext as bJ, provideSomeLayer as bK, range as bL, rechunk as bM, refineOrDie as bN, refineOrDieWith as bO, repeat as bP, repeatEffect as bQ, repeatEffectChunk as bR, repeatEffectChunkOption as bS, repeatEffectOption as bT, repeatEffectWithSchedule as bU, repeatEither as bV, repeatElements as bW, repeatElementsWith as bX, repeatValue as bY, repeatWith as bZ, retry as b_, merge as ba, mergeAll as bb, mergeWith as bc, mergeEither as bd, mergeLeft as be, mergeRight as bf, mkString as bg, never as bh, onError as bi, onDone as bj, orDie as bk, orDieWith as bl, orElse as bm, orElseEither as bn, orElseFail as bo, orElseIfEmpty as bp, orElseIfEmptyChunk as bq, orElseIfEmptyStream as br, orElseSucceed as bs, paginate as bt, paginateChunk as bu, paginateChunkEffect as bv, paginateEffect as bw, partition as bx, partitionEither as by, peel as bz, aggregateWithin as c, toQueue as c$, runCollect as c0, runCount as c1, runDrain as c2, runFold as c3, runFoldEffect as c4, runFoldScoped as c5, runFoldScopedEffect as c6, runFoldWhile as c7, runFoldWhileEffect as c8, runFoldWhileScoped as c9, someOrElse as cA, someOrFail as cB, split as cC, splitOnChunk as cD, splitLines as cE, succeed as cF, sync as cG, suspend as cH, take as cI, takeRight as cJ, takeUntil as cK, takeUntilEffect as cL, takeWhile as cM, tap as cN, tapBoth as cO, tapError as cP, tapErrorCause as cQ, tapSink as cR, throttle as cS, throttleEffect as cT, tick as cU, timeout as cV, timeoutFail as cW, timeoutFailCause as cX, timeoutTo as cY, toHub as cZ, toPull as c_, runFoldWhileScopedEffect as ca, runForEach as cb, runForEachChunk as cc, runForEachChunkScoped as cd, runForEachScoped as ce, runForEachWhile as cf, runForEachWhileScoped as cg, runHead as ch, runIntoHub as ci, runIntoHubScoped as cj, runIntoQueue as ck, runIntoQueueElementsScoped as cl, runIntoQueueScoped as cm, runLast as cn, runScoped as co, runSum as cp, scan as cq, scanEffect as cr, scanReduce as cs, scanReduceEffect as ct, schedule as cu, scheduleWith as cv, scoped as cw, sliding as cx, slidingSize as cy, some as cz, aggregateWithinEither as d, toQueueOfElements as d0, toReadableStream as d1, transduce as d2, unfold as d3, unfoldChunk as d4, unfoldChunkEffect as d5, unfoldEffect as d6, unit as d7, unwrap as d8, unwrapScoped as d9, zipWithIndex as dA, Do as dB, bind as dC, bindTo as dD, let_ as dE, decodeText as dF, encodeText as dG, mapEffectSequential as dH, distributedWithDynamicCallback as dI, matchConcurrency as dJ, mapEffectPar as dK, channelToStream as dL, updateService as da, when as db, whenCase as dc, whenCaseEffect as dd, whenEffect as de, withSpan as df, zip as dg, zipFlatten as dh, zipAll as di, zipAllLeft as dj, zipAllRight as dk, zipAllSortedByKey as dl, zipAllSortedByKeyLeft as dm, zipAllSortedByKeyRight as dn, zipAllSortedByKeyWith as dp, zipAllWith as dq, zipLatest as dr, zipLatestWith as ds, zipLeft as dt, zipRight as du, zipWith as dv, zipWithChunks as dw, zipWithNext as dx, zipWithPrevious as dy, zipWithPreviousAndNext as dz, as as e, asyncEffect as f, asyncInterrupt as g, asyncOption as h, asyncScoped as i, branchAfter as j, broadcast as k, broadcastDynamic as l, broadcastedQueues as m, broadcastedQueuesDynamic as n, buffer as o, bufferChunks as p, catchAll as q, catchAllCause as r, catchSome as s, catchTag as t, catchTags as u, catchSomeCause as v, changes as w, changesWith as x, changesWithEffect as y, chunks as z };
+export { DefaultChunkSize, Do, StreamImpl, StreamTypeId, _async, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, channelToStream, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, distributedWithDynamicCallback, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkHub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromHub, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identityStream, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, isStream, iterate, let_, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffectPar, mapEffectSequential, mapError, mapErrorCause, mapInputContext, matchConcurrency, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, repeatWithSchedule, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoHub, runIntoHubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toHub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };