effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/stream-84a13e23.cjs.dev.js

@@ -0,0 +1,3645 @@
+'use strict';
+
+var Cause_dist_effectCause = require('./Cause-96c29074.cjs.dev.js');
+var ChannelMergeDecision_dist_effectChannelMergeDecision = require('./ChannelMergeDecision-eeaf4779.cjs.dev.js');
+var Chunk_dist_effectChunk = require('./Chunk-bd290b8e.cjs.dev.js');
+var Clock_dist_effectClock = require('./Clock-bec722c1.cjs.dev.js');
+var Context_dist_effectContext = require('./Context-3c9e986b.cjs.dev.js');
+var Deferred_dist_effectDeferred = require('./Deferred-5d5c886c.cjs.dev.js');
+var Duration_dist_effectDuration = require('./Duration-604874d1.cjs.dev.js');
+var Effect_dist_effectEffect = require('./Effect-6e9780e6.cjs.dev.js');
+var Either_dist_effectEither = require('./Either-a806809d.cjs.dev.js');
+var Equal_dist_effectEqual = require('./Equal-281b6ca8.cjs.dev.js');
+var Exit_dist_effectExit = require('./Exit-a23874e1.cjs.dev.js');
+var Fiber_dist_effectFiber = require('./Fiber-6432d5f7.cjs.dev.js');
+var Function_dist_effectFunction = require('./Function-41ce433d.cjs.dev.js');
+var Hub_dist_effectHub = require('./Hub-74834668.cjs.dev.js');
+var Layer_dist_effectLayer = require('./Layer-c69f3fdc.cjs.dev.js');
+var Option_dist_effectOption = require('./Option-03997d77.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-4698db72.cjs.dev.js');
+var Queue_dist_effectQueue = require('./Queue-8d082fe4.cjs.dev.js');
+var Ref_dist_effectRef = require('./Ref-af783b72.cjs.dev.js');
+var Runtime_dist_effectRuntime = require('./Runtime-c4b887ff.cjs.dev.js');
+var Schedule_dist_effectSchedule = require('./Schedule-b6c7b49a.cjs.dev.js');
+var Scope_dist_effectScope = require('./Scope-6ba9ec6d.cjs.dev.js');
+var StreamHaltStrategy_dist_effectStreamHaltStrategy = require('./StreamHaltStrategy-66a53f66.cjs.dev.js');
+var sink = require('./sink-16a1a901.cjs.dev.js');
+var mergeStrategy = require('./mergeStrategy-b19dc19a.cjs.dev.js');
+var singleProducerAsyncInput = require('./singleProducerAsyncInput-552122e6.cjs.dev.js');
+var take$2 = require('./take-e1c6b82a.cjs.dev.js');
+
+/** @internal */
+class RingBuffer {
+  size = 0;
+  current = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.array = Array.from({
+      length: capacity
+    }, Function_dist_effectFunction.constUndefined);
+  }
+  head() {
+    return Option_dist_effectOption.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 Chunk_dist_effectChunk.fromIterable(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(Effect_dist_effectEffect.succeed(as));
+    },
+    die(defect) {
+      return this(Effect_dist_effectEffect.die(defect));
+    },
+    dieMessage(message) {
+      return this(Effect_dist_effectEffect.dieMessage(message));
+    },
+    done(exit) {
+      return this(Effect_dist_effectEffect.suspend(() => Exit_dist_effectExit.mapBoth(exit, {
+        onFailure: Option_dist_effectOption.some,
+        onSuccess: Chunk_dist_effectChunk.of
+      })));
+    },
+    end() {
+      return this(Effect_dist_effectEffect.fail(Option_dist_effectOption.none()));
+    },
+    fail(e) {
+      return this(Effect_dist_effectEffect.fail(Option_dist_effectOption.some(e)));
+    },
+    fromEffect(effect) {
+      return this(Effect_dist_effectEffect.mapBoth(effect, {
+        onFailure: Option_dist_effectOption.some,
+        onSuccess: Chunk_dist_effectChunk.of
+      }));
+    },
+    fromEffectChunk(effect) {
+      return this(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
+    },
+    halt(cause) {
+      return this(Effect_dist_effectEffect.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some))));
+    },
+    single(value) {
+      return this(Effect_dist_effectEffect.succeed(Chunk_dist_effectChunk.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 = () => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Ref_dist_effectRef.make(handoffStateEmpty(deferred))), Effect_dist_effectEffect.map(ref => ({
+  [HandoffTypeId]: handoffVariance,
+  ref
+})));
+
+/** @internal */
+const offer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => {
+  return Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred.make(), deferred => Effect_dist_effectEffect.flatten(Ref_dist_effectRef.modify(self.ref, state => Function_dist_effectFunction.pipe(state, handoffStateMatch(notifyConsumer => [Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred.succeed(notifyConsumer, void 0), Deferred_dist_effectDeferred._await(deferred)), handoffStateFull(value, deferred)], (_, notifyProducer) => [Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(notifyProducer), () => Function_dist_effectFunction.pipe(self, offer(value))), state])))));
+});
+
+/** @internal */
+const take$1 = self => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred.make(), deferred => Effect_dist_effectEffect.flatten(Ref_dist_effectRef.modify(self.ref, state => Function_dist_effectFunction.pipe(state, handoffStateMatch(notifyConsumer => [Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(notifyConsumer), () => take$1(self)), state], (value, notifyProducer) => [Effect_dist_effectEffect.as(Deferred_dist_effectDeferred.succeed(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 = () => Effect_dist_effectEffect.fail(Option_dist_effectOption.none());
+
+/** @internal */
+const failCause$1 = cause => Effect_dist_effectEffect.mapError(Effect_dist_effectEffect.failCause(cause), Option_dist_effectOption.some);
+
+/** @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
+});
+
+/** @internal */
+const StreamSymbolKey = "effect/Stream";
+
+/** @internal */
+const StreamTypeId = /*#__PURE__*/Symbol.for(StreamSymbolKey);
+
+/** @internal */
+const streamVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class StreamImpl {
+  [StreamTypeId] = streamVariance;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  pipe() {
+    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isStream = u => typeof u === "object" && u != null && StreamTypeId in u || Effect_dist_effectEffect.isEffect(u);
+
+/** @internal */
+const DefaultChunkSize = 4096;
+
+/** @internal */
+const acquireRelease = (acquire, release) => scoped(Effect_dist_effectEffect.acquireRelease(acquire, release));
+
+/** @internal */
+const aggregate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink) => aggregateWithin(self, sink, Schedule_dist_effectSchedule.forever));
+
+/** @internal */
+const aggregateWithin = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, sink, schedule) => filterMap(aggregateWithinEither(self, sink, schedule), _ => Either_dist_effectEither.match(_, {
+  onLeft: Option_dist_effectOption.none,
+  onRight: Option_dist_effectOption.some
+})));
+
+/** @internal */
+const aggregateWithinEither = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, sink$1, schedule) => {
+  const layer = Effect_dist_effectEffect.all([make$1(), Ref_dist_effectRef.make(ScheduleEnd), Ref_dist_effectRef.make(Chunk_dist_effectChunk.empty()), Schedule_dist_effectSchedule.driver(schedule), Ref_dist_effectRef.make(false), Ref_dist_effectRef.make(false)]);
+  return Function_dist_effectFunction.pipe(fromEffect(layer), flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
+    const handoffProducer = sink.readWithCause({
+      onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(emit(input)), Effect_dist_effectEffect.when(() => Chunk_dist_effectChunk.isNonEmpty(input)))), () => handoffProducer),
+      onFailure: cause => sink.fromEffect(offer(handoff, halt(cause))),
+      onDone: () => sink.fromEffect(offer(handoff, end$1(UpstreamEnd)))
+    });
+    const handoffConsumer = Function_dist_effectFunction.pipe(Ref_dist_effectRef.getAndSet(sinkLeftovers, Chunk_dist_effectChunk.empty()), Effect_dist_effectEffect.flatMap(leftovers => {
+      if (Chunk_dist_effectChunk.isNonEmpty(leftovers)) {
+        return Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(consumed, true), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(leftovers), sink.flatMap(() => handoffConsumer)))));
+      }
+      return Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
+        switch (signal._tag) {
+          case OP_EMIT:
+            {
+              return Function_dist_effectFunction.pipe(sink.fromEffect(Ref_dist_effectRef.set(consumed, true)), sink.zipRight(sink.write(signal.elements)), sink.zipRight(sink.fromEffect(Ref_dist_effectRef.get(endAfterEmit))), sink.flatMap(bool => bool ? sink.unit : handoffConsumer));
+            }
+          case OP_HALT:
+            {
+              return sink.failCause(signal.cause);
+            }
+          case OP_END:
+            {
+              if (signal.reason._tag === OP_SCHEDULE_END) {
+                return Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(consumed), Effect_dist_effectEffect.map(bool => bool ? sink.fromEffect(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, ScheduleEnd), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)))) : Function_dist_effectFunction.pipe(sink.fromEffect(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, ScheduleEnd), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)))), sink.flatMap(() => handoffConsumer))), sink.unwrap);
+              }
+              return Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, signal.reason), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)), sink.fromEffect);
+            }
+        }
+      }));
+    }), sink.unwrap);
+    const timeout = lastB => scheduleDriver.next(lastB);
+    const scheduledAggregator = (sinkFiber, scheduleFiber, scope) => {
+      const forkSink = Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(consumed, false), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, false)), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(handoffConsumer, sink.pipeToOrFail(sink.toChannel(sink$1)), sink.collectElements, sink.run, Effect_dist_effectEffect.forkIn(scope))));
+      const handleSide = (leftovers, b, c) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkLeftovers, Chunk_dist_effectChunk.flatten(leftovers)), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.map(Ref_dist_effectRef.get(sinkEndReason), reason => {
+        switch (reason._tag) {
+          case OP_SCHEDULE_END:
+            {
+              return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all([Ref_dist_effectRef.get(consumed), forkSink, Function_dist_effectFunction.pipe(timeout(Option_dist_effectOption.some(b)), Effect_dist_effectEffect.forkIn(scope))]), Effect_dist_effectEffect.map(([wasConsumed, sinkFiber, scheduleFiber]) => {
+                const toWrite = Function_dist_effectFunction.pipe(c, Option_dist_effectOption.match({
+                  onNone: () => Chunk_dist_effectChunk.of(Either_dist_effectEither.right(b)),
+                  onSome: c => Chunk_dist_effectChunk.make(Either_dist_effectEither.right(b), Either_dist_effectEither.left(c))
+                }));
+                if (wasConsumed) {
+                  return Function_dist_effectFunction.pipe(sink.write(toWrite), sink.flatMap(() => scheduledAggregator(sinkFiber, scheduleFiber, scope)));
+                }
+                return scheduledAggregator(sinkFiber, scheduleFiber, scope);
+              }), sink.unwrap);
+            }
+          case OP_UPSTREAM_END:
+            {
+              return Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(consumed), Effect_dist_effectEffect.map(wasConsumed => wasConsumed ? sink.write(Chunk_dist_effectChunk.of(Either_dist_effectEither.right(b))) : sink.unit), sink.unwrap);
+            }
+        }
+      })), sink.unwrap);
+      return sink.unwrap(Effect_dist_effectEffect.raceWith(Fiber_dist_effectFiber.join(sinkFiber), Fiber_dist_effectFiber.join(scheduleFiber), {
+        onSelfDone: (sinkExit, _) => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(scheduleFiber), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => sinkExit), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none()))))),
+        onOtherDone: (scheduleExit, _) => Effect_dist_effectEffect.matchCauseEffect(Effect_dist_effectEffect.suspend(() => scheduleExit), {
+          onFailure: cause => Either_dist_effectEither.match(Cause_dist_effectCause.failureOrCause(cause), {
+            onLeft: () => Function_dist_effectFunction.pipe(handoff, offer(end$1(ScheduleEnd)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none()))))),
+            onRight: cause => Function_dist_effectFunction.pipe(handoff, offer(halt(cause)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none())))))
+          }),
+          onSuccess: c => Function_dist_effectFunction.pipe(handoff, offer(end$1(ScheduleEnd)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.some(c))))))
+        })
+      }));
+    };
+    return unwrapScoped(Function_dist_effectFunction.pipe(self, toChannel, sink.pipeTo(handoffProducer), sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(handoffConsumer, sink.pipeToOrFail(sink.toChannel(sink$1)), sink.collectElements, sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.flatMap(sinkFiber => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forkScoped(timeout(Option_dist_effectOption.none())), Effect_dist_effectEffect.flatMap(scheduleFiber => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.scope, Effect_dist_effectEffect.map(scope => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))))));
+  }));
+});
+
+/** @internal */
+const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => map(self, () => value));
+
+/** @internal */
+const _async = (register, outputBuffer = 16) => asyncOption(cb => {
+  register(cb);
+  return Option_dist_effectOption.none();
+}, outputBuffer);
+
+/** @internal */
+const asyncEffect = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
+  if (Exit_dist_effectExit.isFailure(exit)) {
+    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
+      throw Cause_dist_effectCause.squash(exit.cause);
+    }
+  }
+}))), Effect_dist_effectEffect.map(() => {
+  const loop = Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.match({
+    onFailure: maybeError => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.shutdown(output)), sink.zipRight(Option_dist_effectOption.match(maybeError, {
+      onNone: () => sink.unit,
+      onSome: sink.fail
+    }))),
+    onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => loop))
+  }), sink.unwrap);
+  return loop;
+}))))), sink.unwrapScoped, fromChannel);
+
+/** @internal */
+const asyncInterrupt = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
+  if (Exit_dist_effectExit.isFailure(exit)) {
+    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
+      throw Cause_dist_effectCause.squash(exit.cause);
+    }
+  }
+})))), Effect_dist_effectEffect.map(Either_dist_effectEither.match({
+  onLeft: canceler => {
+    const loop = Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.match({
+      onFailure: maybeError => sink.zipRight(sink.fromEffect(Queue_dist_effectQueue.shutdown(output)), Option_dist_effectOption.match(maybeError, {
+        onNone: () => sink.unit,
+        onSome: sink.fail
+      })),
+      onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => loop))
+    }), sink.unwrap);
+    return Function_dist_effectFunction.pipe(fromChannel(loop), ensuring(canceler));
+  },
+  onRight: stream => unwrap(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(output), Effect_dist_effectEffect.as(stream)))
+})))))), unwrapScoped);
+
+/** @internal */
+const asyncOption = (register, outputBuffer = 16) => asyncInterrupt(emit => Option_dist_effectOption.match(register(emit), {
+  onNone: () => Either_dist_effectEither.left(Effect_dist_effectEffect.unit),
+  onSome: Either_dist_effectEither.right
+}), outputBuffer);
+
+/** @internal */
+const asyncScoped = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
+  if (Exit_dist_effectExit.isFailure(exit)) {
+    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
+      throw Cause_dist_effectCause.squash(exit.cause);
+    }
+  }
+}))), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.make(false)), Effect_dist_effectEffect.flatMap(ref => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.map(isDone => isDone ? end() : Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.onError(() => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(ref, true), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
+
+/** @internal */
+const branchAfter = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, f) => suspend(() => {
+  const buffering = acc => sink.readWith({
+    onInput: input => {
+      const nextSize = acc.length + input.length;
+      if (nextSize >= n) {
+        const [b1, b2] = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.splitAt(n - acc.length));
+        return running(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(b1)), b2);
+      }
+      return buffering(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(input)));
+    },
+    onFailure: sink.fail,
+    onDone: () => running(acc, Chunk_dist_effectChunk.empty())
+  });
+  const running = (prefix, leftover) => sink.pipeTo(sink.zipRight(sink.write(leftover), sink.identityChannel()), toChannel(f(prefix)));
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(buffering(Chunk_dist_effectChunk.empty()))));
+}));
+
+/** @internal */
+const broadcast = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, maximumLag) => Function_dist_effectFunction.pipe(self, broadcastedQueues(n, maximumLag), Effect_dist_effectEffect.map(tuple => tuple.map(queue => flattenTake(fromQueue(queue, {
+  shutdown: true
+}))))));
+
+/** @internal */
+const broadcastDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, maximumLag) => Function_dist_effectFunction.pipe(self, broadcastedQueuesDynamic(maximumLag), Effect_dist_effectEffect.map(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
+
+/** @internal */
+const broadcastedQueues = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, maximumLag) => Effect_dist_effectEffect.flatMap(Hub_dist_effectHub.bounded(maximumLag), hub => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all(Array.from({
+  length: n
+}, () => Hub_dist_effectHub.subscribe(hub))), Effect_dist_effectEffect.tap(() => Effect_dist_effectEffect.forkScoped(runIntoHubScoped(self, hub))))));
+
+/** @internal */
+const broadcastedQueuesDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, maximumLag) => Effect_dist_effectEffect.map(toHub(self, maximumLag), Hub_dist_effectHub.subscribe));
+
+/** @internal */
+const buffer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
+  if (options.capacity === "unbounded") {
+    return bufferUnbounded(self);
+  } else if (options.strategy === "dropping") {
+    return bufferDropping(self, options.capacity);
+  } else if (options.strategy === "sliding") {
+    return bufferSliding(self, options.capacity);
+  }
+  const queue = toQueueOfElements(self, options);
+  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
+    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(Exit_dist_effectExit.match({
+      onFailure: cause => Function_dist_effectFunction.pipe(Cause_dist_effectCause.flipCauseOption(cause), Option_dist_effectOption.match({
+        onNone: () => sink.unit,
+        onSome: sink.failCause
+      })),
+      onSuccess: value => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(value)), () => process)
+    })));
+    return process;
+  })));
+});
+
+/** @internal */
+const bufferChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
+  if (options.strategy === "dropping") {
+    return bufferChunksDropping(self, options.capacity);
+  } else if (options.strategy === "sliding") {
+    return bufferChunksSliding(self, options.capacity);
+  }
+  const queue = toQueue(self, options);
+  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
+    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(take$2.match({
+      onEnd: () => sink.unit,
+      onFailure: sink.failCause,
+      onSuccess: value => Function_dist_effectFunction.pipe(sink.write(value), sink.flatMap(() => process))
+    })));
+    return process;
+  })));
+});
+const bufferChunksDropping = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
+  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.dropping(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
+  return new StreamImpl(bufferSignal(queue, toChannel(self)));
+});
+const bufferChunksSliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
+  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.sliding(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
+  return new StreamImpl(bufferSignal(queue, toChannel(self)));
+});
+const bufferDropping = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
+  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.dropping(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
+  return new StreamImpl(bufferSignal(queue, toChannel(rechunk(1)(self))));
+});
+const bufferSliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
+  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.sliding(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
+  return new StreamImpl(bufferSignal(queue, toChannel(Function_dist_effectFunction.pipe(self, rechunk(1)))));
+});
+const bufferUnbounded = self => {
+  const queue = toQueue(self, {
+    strategy: "unbounded"
+  });
+  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
+    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(take$2.match({
+      onEnd: () => sink.unit,
+      onFailure: sink.failCause,
+      onSuccess: value => sink.flatMap(sink.write(value), () => process)
+    })));
+    return process;
+  })));
+};
+
+/** @internal */
+const bufferSignal = (scoped, bufferChannel) => {
+  const producer = (queue, ref) => {
+    const terminate = take => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.tap(Deferred_dist_effectDeferred._await), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred.make()), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, [take, deferred]), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(ref, deferred)), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred._await(deferred)))), Effect_dist_effectEffect.asUnit, sink.fromEffect);
+    return sink.readWithCause({
+      onInput: input => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, [take$2.chunk(input), deferred]), Effect_dist_effectEffect.flatMap(added => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(ref, deferred), Effect_dist_effectEffect.when(() => added))))), Effect_dist_effectEffect.asUnit, sink.fromEffect, sink.flatMap(() => producer(queue, ref))),
+      onFailure: error => terminate(take$2.failCause(error)),
+      onDone: () => terminate(take$2.end)
+    });
+  };
+  const consumer = queue => {
+    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(([take, deferred]) => sink.zipRight(sink.fromEffect(Deferred_dist_effectDeferred.succeed(deferred, void 0)), take$2.match(take, {
+      onEnd: () => sink.unit,
+      onFailure: sink.failCause,
+      onSuccess: value => Function_dist_effectFunction.pipe(sink.write(value), sink.flatMap(() => process))
+    }))));
+    return process;
+  };
+  return sink.unwrapScoped(Function_dist_effectFunction.pipe(scoped, Effect_dist_effectEffect.flatMap(queue => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.tap(start => Deferred_dist_effectDeferred.succeed(start, void 0)), Effect_dist_effectEffect.flatMap(start => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(start), Effect_dist_effectEffect.flatMap(ref => Function_dist_effectFunction.pipe(bufferChannel, sink.pipeTo(producer(queue, ref)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.as(consumer(queue))))))));
+};
+
+/** @internal */
+const catchAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAllCause(self, cause => Either_dist_effectEither.match(Cause_dist_effectCause.failureOrCause(cause), {
+  onLeft: f,
+  onRight: failCause
+})));
+
+/** @internal */
+const catchAllCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.catchAllCause(cause => toChannel(f(cause))))));
+
+/** @internal */
+const catchSome = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, catchAll(error => Function_dist_effectFunction.pipe(pf(error), Option_dist_effectOption.getOrElse(() => fail(error))))));
+
+/** @internal */
+const catchSomeCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, catchAllCause(cause => Function_dist_effectFunction.pipe(pf(cause), Option_dist_effectOption.getOrElse(() => failCause(cause))))));
+
+/* @internal */
+const catchTag = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, k, f) => catchAll(self, e => {
+  if ("_tag" in e && e["_tag"] === k) {
+    return f(e);
+  }
+  return fail(e);
+}));
+
+/** @internal */
+const catchTags = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cases) => catchAll(self, e => {
+  const keys = Object.keys(cases);
+  if ("_tag" in e && keys.includes(e["_tag"])) {
+    return cases[e["_tag"]](e);
+  }
+  return fail(e);
+}));
+
+/** @internal */
+const changes = self => Function_dist_effectFunction.pipe(self, changesWith((x, y) => Equal_dist_effectEqual.equals(y)(x)));
+
+/** @internal */
+const changesWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const writer = last => sink.readWithCause({
+    onInput: input => {
+      const [newLast, newChunk] = Chunk_dist_effectChunk.reduce(input, [last, Chunk_dist_effectChunk.empty()], ([option, outputs], output) => {
+        if (Option_dist_effectOption.isSome(option) && f(option.value, output)) {
+          return [Option_dist_effectOption.some(output), outputs];
+        }
+        return [Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))];
+      });
+      return sink.flatMap(sink.write(newChunk), () => writer(newLast));
+    },
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(Option_dist_effectOption.none()))));
+});
+
+/** @internal */
+const changesWithEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const writer = last => sink.readWithCause({
+    onInput: input => Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.reduce([last, Chunk_dist_effectChunk.empty()], ([option, outputs], output) => {
+      if (Option_dist_effectOption.isSome(option)) {
+        return Function_dist_effectFunction.pipe(f(option.value, output), Effect_dist_effectEffect.map(bool => bool ? [Option_dist_effectOption.some(output), outputs] : [Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))]));
+      }
+      return Effect_dist_effectEffect.succeed([Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))]);
+    }), sink.fromEffect, sink.flatMap(([newLast, newChunk]) => Function_dist_effectFunction.pipe(sink.write(newChunk), sink.flatMap(() => writer(newLast))))),
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(Option_dist_effectOption.none()))));
+});
+
+/** @internal */
+const chunks = self => Function_dist_effectFunction.pipe(self, mapChunks(Chunk_dist_effectChunk.of));
+
+/** @internal */
+const chunksWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flattenChunks(f(chunks(self))));
+const unsome = effect => Effect_dist_effectEffect.catchAll(Effect_dist_effectEffect.asSome(effect), o => o._tag === "None" ? Effect_dist_effectEffect.succeedNone : Effect_dist_effectEffect.fail(o.value));
+
+/** @internal */
+const combine = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, that, s, f) => {
+  const producer = (handoff, latch) => Function_dist_effectFunction.pipe(sink.fromEffect(take$1(latch)), sink.zipRight(sink.readWithCause({
+    onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(Exit_dist_effectExit.succeed(input)))), () => producer(handoff, latch)),
+    onFailure: cause => sink.fromEffect(offer(handoff, Exit_dist_effectExit.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some))))),
+    onDone: () => sink.flatMap(sink.fromEffect(offer(handoff, Exit_dist_effectExit.fail(Option_dist_effectOption.none()))), () => producer(handoff, latch))
+  })));
+  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.gen(function* ($) {
+    const left = yield* $(make$1());
+    const right = yield* $(make$1());
+    const latchL = yield* $(make$1());
+    const latchR = yield* $(make$1());
+    yield* $(toChannel(self), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(left, latchL)), sink.runScoped, Effect_dist_effectEffect.forkScoped);
+    yield* $(toChannel(that), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(right, latchR)), sink.runScoped, Effect_dist_effectEffect.forkScoped);
+    const pullLeft = Function_dist_effectFunction.pipe(latchL, offer(void 0),
+    // TODO: remove
+    Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(left), Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)))));
+    const pullRight = Function_dist_effectFunction.pipe(latchR, offer(void 0),
+    // TODO: remove
+    Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(right), Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)))));
+    return toChannel(unfoldEffect(s, s => Effect_dist_effectEffect.flatMap(f(s, pullLeft, pullRight), unsome)));
+  })));
+});
+
+/** @internal */
+const combineChunks = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, that, s, f) => {
+  const producer = (handoff, latch) => sink.zipRight(sink.fromEffect(take$1(latch)), sink.readWithCause({
+    onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(take$2.chunk(input)))), () => producer(handoff, latch)),
+    onFailure: cause => sink.fromEffect(offer(handoff, take$2.failCause(cause))),
+    onDone: () => sink.fromEffect(offer(handoff, take$2.end))
+  }));
+  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all([make$1(), make$1(), make$1(), make$1()]), Effect_dist_effectEffect.tap(([left, _, latchL]) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(producer(left, latchL)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.tap(([_, right, __, latchR]) => Function_dist_effectFunction.pipe(toChannel(that), sink.pipeTo(producer(right, latchR)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.map(([left, right, latchL, latchR]) => {
+    const pullLeft = Function_dist_effectFunction.pipe(latchL, offer(void 0), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(left), Effect_dist_effectEffect.flatMap(take$2.done))));
+    const pullRight = Function_dist_effectFunction.pipe(latchR, offer(void 0), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(right), Effect_dist_effectEffect.flatMap(take$2.done))));
+    return toChannel(unfoldChunkEffect(s, s => Effect_dist_effectEffect.flatMap(f(s, pullLeft, pullRight), unsome)));
+  }), sink.unwrapScoped));
+});
+
+/** @internal */
+const concat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.zipRight(toChannel(that)))));
+
+/** @internal */
+const concatAll = streams => suspend(() => Function_dist_effectFunction.pipe(streams, Chunk_dist_effectChunk.reduce(empty, (x, y) => concat(y)(x))));
+
+/** @internal */
+const cross = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, crossWith(that, (a, a2) => [a, a2])));
+
+/** @internal */
+const crossLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, crossWith(that, (a, _) => a)));
+
+/** @internal */
+const crossRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => flatMap(self, () => that));
+
+/** @internal */
+const crossWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => Function_dist_effectFunction.pipe(self, flatMap(a => Function_dist_effectFunction.pipe(that, map(b => f(a, b))))));
+
+/** @internal */
+const debounce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(singleProducerAsyncInput.make(), Effect_dist_effectEffect.flatMap(input => Effect_dist_effectEffect.transplant(grafter => Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.map(handoff => {
+  const enqueue = last => Function_dist_effectFunction.pipe(Clock_dist_effectClock.sleep(duration), Effect_dist_effectEffect.as(last), Effect_dist_effectEffect.fork, grafter, Effect_dist_effectEffect.map(fiber => consumer(previous(fiber))));
+  const producer = sink.readWithCause({
+    onInput: input => Option_dist_effectOption.match(Chunk_dist_effectChunk.last(input), {
+      onNone: () => producer,
+      onSome: last => sink.flatMap(sink.fromEffect(offer(handoff, emit(Chunk_dist_effectChunk.of(last)))), () => producer)
+    }),
+    onFailure: cause => sink.fromEffect(offer(handoff, halt(cause))),
+    onDone: () => sink.fromEffect(offer(handoff, end$1(UpstreamEnd)))
+  });
+  const consumer = state => {
+    switch (state._tag) {
+      case OP_NOT_STARTED:
+        {
+          return Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
+            switch (signal._tag) {
+              case OP_EMIT:
+                {
+                  return sink.unwrap(enqueue(signal.elements));
+                }
+              case OP_HALT:
+                {
+                  return sink.failCause(signal.cause);
+                }
+              case OP_END:
+                {
+                  return sink.unit;
+                }
+            }
+          }), sink.unwrap);
+        }
+      case OP_PREVIOUS:
+        {
+          return sink.unwrap(Effect_dist_effectEffect.raceWith(Fiber_dist_effectFiber.join(state.fiber), take$1(handoff), {
+            onSelfDone: (leftExit, current$1) => Exit_dist_effectExit.match(leftExit, {
+              onFailure: cause => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(current$1), Effect_dist_effectEffect.as(sink.failCause(cause))),
+              onSuccess: chunk => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => consumer(current(current$1)))))
+            }),
+            onOtherDone: (rightExit, previous) => Exit_dist_effectExit.match(rightExit, {
+              onFailure: cause => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.as(sink.failCause(cause))),
+              onSuccess: signal => {
+                switch (signal._tag) {
+                  case OP_EMIT:
+                    {
+                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.zipRight(enqueue(signal.elements)));
+                    }
+                  case OP_HALT:
+                    {
+                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.as(sink.failCause(signal.cause)));
+                    }
+                  case OP_END:
+                    {
+                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(previous), Effect_dist_effectEffect.map(chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.zipRight(sink.unit))));
+                    }
+                }
+              }
+            })
+          }));
+        }
+      case OP_CURRENT:
+        {
+          return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(state.fiber), Effect_dist_effectEffect.map(signal => {
+            switch (signal._tag) {
+              case OP_EMIT:
+                {
+                  return sink.unwrap(enqueue(signal.elements));
+                }
+              case OP_HALT:
+                {
+                  return sink.failCause(signal.cause);
+                }
+              case OP_END:
+                {
+                  return sink.unit;
+                }
+            }
+          }), sink.unwrap);
+        }
+    }
+  };
+  const debounceChannel = Function_dist_effectFunction.pipe(sink.fromInput(input), sink.pipeTo(producer), sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.as(Function_dist_effectFunction.pipe(consumer(notStarted), sink.embedInput(input))), sink.unwrapScoped);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(debounceChannel)));
+})))), unwrap));
+
+/** @internal */
+const die = defect => fromEffect(Effect_dist_effectEffect.die(defect));
+
+/** @internal */
+const dieSync = evaluate => fromEffect(Effect_dist_effectEffect.dieSync(evaluate));
+
+/** @internal */
+const dieMessage = message => fromEffect(Effect_dist_effectEffect.dieMessage(message));
+
+/** @internal */
+const distributedWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(self, distributedWithDynamic({
+  maximumLag: options.maximumLag,
+  decide: a => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(deferred), f => f(a))
+}), Effect_dist_effectEffect.flatMap(next => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all(Chunk_dist_effectChunk.map(Chunk_dist_effectChunk.range(0, options.size - 1), id => Effect_dist_effectEffect.map(next, ([key, queue]) => [[key, id], queue]))), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.flatMap(entries => {
+  const [mappings, queues] = Chunk_dist_effectChunk.reduceRight(entries, [new Map(), Chunk_dist_effectChunk.empty()], ([mappings, queues], [mapping, queue]) => [mappings.set(mapping[0], mapping[1]), Function_dist_effectFunction.pipe(queues, Chunk_dist_effectChunk.prepend(queue))]);
+  return Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.succeed(deferred, a => Effect_dist_effectEffect.map(options.decide(a), f => key => Function_dist_effectFunction.pipe(f(mappings.get(key))))), Effect_dist_effectEffect.as(Array.from(queues)));
+})))))));
+
+/** @internal */
+const distributedWithDynamicId = {
+  ref: 0
+};
+const newDistributedWithDynamicId = () => {
+  const current = distributedWithDynamicId.ref;
+  distributedWithDynamicId.ref = current + 1;
+  return current;
+};
+
+/** @internal */
+const distributedWithDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => Effect_dist_effectEffect.unit));
+const distributedWithDynamicCallback = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, maximumLag, decide, done) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Ref_dist_effectRef.make(new Map()), (ref, _) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.flatMap(queues => Function_dist_effectFunction.pipe(queues.values(), Effect_dist_effectEffect.forEach(Queue_dist_effectQueue.shutdown))))), Effect_dist_effectEffect.flatMap(queuesRef => Effect_dist_effectEffect.gen(function* ($) {
+  const offer = a => Function_dist_effectFunction.pipe(decide(a), Effect_dist_effectEffect.flatMap(shouldProcess => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(queuesRef), Effect_dist_effectEffect.flatMap(queues => Function_dist_effectFunction.pipe(queues.entries(), Effect_dist_effectEffect.reduce(Chunk_dist_effectChunk.empty(), (acc, [id, queue]) => {
+    if (shouldProcess(id)) {
+      return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.succeed(a)), Effect_dist_effectEffect.matchCauseEffect({
+        onFailure: cause =>
+        // Ignore all downstream queues that were shut
+        // down and remove them later
+        Cause_dist_effectCause.isInterrupted(cause) ? Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.prepend(id))) : Effect_dist_effectEffect.failCause(cause),
+        onSuccess: () => Effect_dist_effectEffect.succeed(acc)
+      }));
+    }
+    return Effect_dist_effectEffect.succeed(acc);
+  }), Effect_dist_effectEffect.flatMap(ids => {
+    if (Chunk_dist_effectChunk.isNonEmpty(ids)) {
+      return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => {
+        for (const id of ids) {
+          map.delete(id);
+        }
+        return map;
+      }));
+    }
+    return Effect_dist_effectEffect.unit;
+  }))))), Effect_dist_effectEffect.asUnit);
+  const queuesLock = yield* $(Effect_dist_effectEffect.makeSemaphore(1));
+  const newQueue = yield* $(Ref_dist_effectRef.make(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.bounded(maximumLag), Effect_dist_effectEffect.flatMap(queue => {
+    const id = newDistributedWithDynamicId();
+    return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => map.set(id, queue)), Effect_dist_effectEffect.as([id, queue]));
+  }))));
+  const finalize = endTake =>
+  // Make sure that no queues are currently being added
+  queuesLock.withPermits(1)(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(newQueue, Function_dist_effectFunction.pipe(
+  // All newly created queues should end immediately
+  Queue_dist_effectQueue.bounded(1), Effect_dist_effectEffect.tap(queue => Queue_dist_effectQueue.offer(queue, endTake)), Effect_dist_effectEffect.flatMap(queue => {
+    const id = newDistributedWithDynamicId();
+    return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => map.set(id, queue)), Effect_dist_effectEffect.as([id, queue]));
+  }))), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(queuesRef), Effect_dist_effectEffect.flatMap(map => Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.fromIterable(map.values()), Effect_dist_effectEffect.forEach(queue => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, endTake), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterrupted(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none()))))))), Effect_dist_effectEffect.zipRight(done(endTake)), Effect_dist_effectEffect.asUnit));
+  yield* $(self, runForEachScoped(offer), Effect_dist_effectEffect.matchCauseEffect({
+    onFailure: cause => finalize(Exit_dist_effectExit.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some)))),
+    onSuccess: () => finalize(Exit_dist_effectExit.fail(Option_dist_effectOption.none()))
+  }), Effect_dist_effectEffect.forkScoped);
+  return queuesLock.withPermits(1)(Effect_dist_effectEffect.flatten(Ref_dist_effectRef.get(newQueue)));
+}))));
+
+/** @internal */
+const drain = self => new StreamImpl(sink.drain(toChannel(self)));
+
+/** @internal */
+const drainFork = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(fromEffect(Deferred_dist_effectDeferred.make()), flatMap(backgroundDied => Function_dist_effectFunction.pipe(scoped(Function_dist_effectFunction.pipe(that, runForEachScoped(() => Effect_dist_effectEffect.unit), Effect_dist_effectEffect.catchAllCause(cause => Deferred_dist_effectDeferred.failCause(backgroundDied, cause)), Effect_dist_effectEffect.forkScoped)), crossRight(Function_dist_effectFunction.pipe(self, interruptWhenDeferred(backgroundDied)))))));
+
+/** @internal */
+const drop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  const loop = r => sink.readWith({
+    onInput: input => {
+      const dropped = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(r));
+      const leftover = Math.max(0, r - input.length);
+      const more = Chunk_dist_effectChunk.isEmpty(input) || leftover > 0;
+      if (more) {
+        return loop(leftover);
+      }
+      return Function_dist_effectFunction.pipe(sink.write(dropped), sink.zipRight(sink.identityChannel()));
+    },
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop(n))));
+});
+
+/** @internal */
+const dropRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  if (n <= 0) {
+    return identityStream();
+  }
+  return suspend(() => {
+    const queue = new RingBuffer(n);
+    const reader = sink.readWith({
+      onInput: input => {
+        const outputs = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.filterMap(elem => {
+          const head = queue.head();
+          queue.put(elem);
+          return head;
+        }));
+        return Function_dist_effectFunction.pipe(sink.write(outputs), sink.flatMap(() => reader));
+      },
+      onFailure: sink.fail,
+      onDone: () => sink.unit
+    });
+    return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(reader)));
+  });
+});
+
+/** @internal */
+const dropUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => drop(dropWhile(self, a => !predicate(a)), 1));
+
+/** @internal */
+const dropUntilEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.dropUntil(input, predicate), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.map(leftover => {
+      const more = Chunk_dist_effectChunk.isEmpty(leftover);
+      if (more) {
+        return sink.suspend(() => loop);
+      }
+      return Function_dist_effectFunction.pipe(sink.write(leftover), sink.zipRight(sink.identityChannel()));
+    }), sink.unwrap),
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
+});
+
+/** @internal */
+const dropWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => {
+      const output = Chunk_dist_effectChunk.dropWhile(input, predicate);
+      if (Chunk_dist_effectChunk.isEmpty(output)) {
+        return sink.suspend(() => loop);
+      }
+      return sink.zipRight(sink.write(output), sink.identityChannel());
+    },
+    onFailure: sink.fail,
+    onDone: sink.succeedNow
+  });
+  return new StreamImpl(sink.pipeToOrFail(toChannel(self), loop));
+});
+
+/** @internal */
+const dropWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.dropWhile(input, predicate), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.map(leftover => {
+      const more = Chunk_dist_effectChunk.isEmpty(leftover);
+      if (more) {
+        return sink.suspend(() => loop);
+      }
+      return sink.zipRight(sink.write(leftover), sink.identityChannel());
+    }), sink.unwrap),
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(sink.pipeToOrFail(toChannel(self), loop));
+});
+
+/** @internal */
+const either = self => Function_dist_effectFunction.pipe(self, map(Either_dist_effectEither.right), catchAll(error => make(Either_dist_effectEither.left(error))));
+
+/** @internal */
+const empty = /*#__PURE__*/new StreamImpl( /*#__PURE__*/sink.write( /*#__PURE__*/Chunk_dist_effectChunk.empty()));
+
+/** @internal */
+const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.ensuring(finalizer))));
+
+/** @internal */
+const ensuringWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new StreamImpl(sink.ensuringWith(toChannel(self), finalizer)));
+
+/** @internal */
+const context = () => fromEffect(Effect_dist_effectEffect.context());
+
+/** @internal */
+const contextWith = f => Function_dist_effectFunction.pipe(context(), map(f));
+
+/** @internal */
+const contextWithEffect = f => Function_dist_effectFunction.pipe(context(), mapEffectSequential(f));
+
+/** @internal */
+const contextWithStream = f => Function_dist_effectFunction.pipe(context(), flatMap(f));
+
+/** @internal */
+const execute = effect => drain(fromEffect(effect));
+
+/** @internal */
+const fail = error => fromEffectOption(Effect_dist_effectEffect.fail(Option_dist_effectOption.some(error)));
+
+/** @internal */
+const failSync = evaluate => fromEffectOption(Effect_dist_effectEffect.failSync(() => Option_dist_effectOption.some(evaluate())));
+
+/** @internal */
+const failCause = cause => fromEffect(Effect_dist_effectEffect.failCause(cause));
+
+/** @internal */
+const failCauseSync = evaluate => fromEffect(Effect_dist_effectEffect.failCauseSync(evaluate));
+
+/** @internal */
+const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => mapChunks(self, Chunk_dist_effectChunk.filter(predicate)));
+
+/** @internal */
+const filterEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: input => loop(input[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeed
+      });
+    } else {
+      return Function_dist_effectFunction.pipe(f(next.value), Effect_dist_effectEffect.map(bool => bool ? Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator))) : loop(iterator)), sink.unwrap);
+    }
+  };
+  return new StreamImpl(sink.suspend(() => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]())))));
+});
+
+/** @internal */
+const filterMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => mapChunks(self, Chunk_dist_effectChunk.filterMap(pf)));
+
+/** @internal */
+const filterMapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => suspend(() => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: input => loop(input[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeed
+      });
+    } else {
+      return Function_dist_effectFunction.pipe(pf(next.value), Option_dist_effectOption.match({
+        onNone: () => Effect_dist_effectEffect.sync(() => loop(iterator)),
+        onSome: Effect_dist_effectEffect.map(a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator)))
+      }), sink.unwrap);
+    }
+  };
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
+}));
+
+/** @internal */
+const filterMapWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => {
+  const loop = sink.readWith({
+    onInput: input => {
+      const mapped = Chunk_dist_effectChunk.filterMapWhile(input, pf);
+      if (mapped.length === input.length) {
+        return Function_dist_effectFunction.pipe(sink.write(mapped), sink.flatMap(() => loop));
+      }
+      return sink.write(mapped);
+    },
+    onFailure: sink.fail,
+    onDone: sink.succeed
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
+});
+
+/** @internal */
+const filterMapWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => suspend(() => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: input => loop(input[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeed
+      });
+    } else {
+      return sink.unwrap(Option_dist_effectOption.match(pf(next.value), {
+        onNone: () => Effect_dist_effectEffect.succeed(sink.unit),
+        onSome: Effect_dist_effectEffect.map(a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator)))
+      }));
+    }
+  };
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
+}));
+
+/** @internal */
+const finalizer = finalizer => acquireRelease(Effect_dist_effectEffect.unit, () => finalizer);
+
+/** @internal */
+const find = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => Option_dist_effectOption.match(Chunk_dist_effectChunk.findFirst(input, predicate), {
+      onNone: () => loop,
+      onSome: n => sink.write(Chunk_dist_effectChunk.of(n))
+    }),
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
+});
+
+/** @internal */
+const findEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.findFirst(input, predicate), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
+      onNone: () => loop,
+      onSome: n => sink.write(Chunk_dist_effectChunk.of(n))
+    })), sink.unwrap),
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
+});
+
+/** @internal */
+const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
+  const bufferSize = options?.bufferSize ?? 16;
+  if (options?.switch) {
+    return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
+  }
+  return matchConcurrency(options?.concurrency, () => new StreamImpl(sink.concatMap(toChannel(self), as => Function_dist_effectFunction.pipe(as, Chunk_dist_effectChunk.map(a => toChannel(f(a))), Chunk_dist_effectChunk.reduce(sink.unit, (left, right) => Function_dist_effectFunction.pipe(left, sink.zipRight(right)))))), n => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mergeMap(out => toChannel(f(out)), {
+    concurrency: n,
+    bufferSize
+  }))));
+});
+
+/** @internal */
+const matchConcurrency = (concurrency, sequential, bounded) => {
+  switch (concurrency) {
+    case undefined:
+      return sequential();
+    case "unbounded":
+      return bounded(Number.POSITIVE_INFINITY);
+    default:
+      return concurrency > 1 ? bounded(concurrency) : sequential();
+  }
+};
+const flatMapParSwitchBuffer = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, n, bufferSize, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mergeMap(out => toChannel(f(out)), {
+  concurrency: n,
+  mergeStrategy: mergeStrategy.BufferSliding(),
+  bufferSize
+}))));
+
+/** @internal */
+const flatten = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => flatMap(self, Function_dist_effectFunction.identity, options));
+
+/** @internal */
+const flattenChunks = self => {
+  const flatten = sink.readWithCause({
+    onInput: chunks => sink.flatMap(sink.writeChunk(chunks), () => flatten),
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(flatten)));
+};
+
+/** @internal */
+const flattenEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => options?.unordered ? flatMap(self, a => fromEffect(a), {
+  concurrency: options.concurrency
+}) : matchConcurrency(options?.concurrency, () => mapEffectSequential(self, Function_dist_effectFunction.identity), n => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mapOutEffectPar(Function_dist_effectFunction.identity, n), sink.mapOut(Chunk_dist_effectChunk.of)))));
+
+/** @internal */
+const flattenExitOption = self => {
+  const processChunk = (chunk, cont) => {
+    const [toEmit, rest] = Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.splitWhere(exit => !Exit_dist_effectExit.isSuccess(exit)));
+    const next = Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.head(rest), Option_dist_effectOption.match({
+      onNone: () => cont,
+      onSome: Exit_dist_effectExit.match({
+        onFailure: cause => Option_dist_effectOption.match(Cause_dist_effectCause.flipCauseOption(cause), {
+          onNone: () => sink.unit,
+          onSome: sink.failCause
+        }),
+        onSuccess: () => sink.unit
+      })
+    }));
+    return Function_dist_effectFunction.pipe(sink.write(Function_dist_effectFunction.pipe(toEmit, Chunk_dist_effectChunk.filterMap(exit => Exit_dist_effectExit.isSuccess(exit) ? Option_dist_effectOption.some(exit.value) : Option_dist_effectOption.none()))), sink.flatMap(() => next));
+  };
+  const process = sink.readWithCause({
+    onInput: chunk => processChunk(chunk, process),
+    onFailure: cause => sink.failCause(cause),
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(process)));
+};
+
+/** @internal */
+const flattenIterables = self => Function_dist_effectFunction.pipe(self, map(Chunk_dist_effectChunk.fromIterable), flattenChunks);
+
+/** @internal */
+const flattenTake = self => flattenChunks(flattenExitOption(Function_dist_effectFunction.pipe(self, map(take => take.exit))));
+
+/** @internal */
+const forever = self => new StreamImpl(sink.repeated(toChannel(self)));
+
+/** @internal */
+const fromAsyncIterable = (iterable, onError) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? Effect_dist_effectEffect.promise(async () => iterator.return()) : Effect_dist_effectEffect.unit), Effect_dist_effectEffect.map(iterator => repeatEffectOption(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.tryPromise({
+  try: async () => iterator.next(),
+  catch: reason => Option_dist_effectOption.some(onError(reason))
+}), Effect_dist_effectEffect.flatMap(result => result.done ? Effect_dist_effectEffect.fail(Option_dist_effectOption.none()) : Effect_dist_effectEffect.succeed(result.value))))), unwrapScoped);
+
+/** @internal */
+const fromChannel = channel => new StreamImpl(channel);
+
+/** @internal */
+const toChannel = stream => {
+  if (Effect_dist_effectEffect.isEffect(stream)) {
+    return toChannel(fromEffect(stream));
+  }
+  return stream.channel;
+};
+
+/** @internal */
+const fromChunk = chunk => new StreamImpl(Chunk_dist_effectChunk.isEmpty(chunk) ? sink.unit : sink.write(chunk));
+
+/** @internal */
+const fromChunkHub = (hub, options) => {
+  if (options?.scoped) {
+    const effect = Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), fromChunkQueue);
+    return options.shutdown ? Effect_dist_effectEffect.map(effect, ensuring(Hub_dist_effectHub.shutdown(hub))) : effect;
+  }
+  const stream = flatMap(scoped(Hub_dist_effectHub.subscribe(hub)), fromChunkQueue);
+  return options?.shutdown ? ensuring(stream, Hub_dist_effectHub.shutdown(hub)) : stream;
+};
+
+/** @internal */
+const fromChunkQueue = (queue, options) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(queue), Effect_dist_effectEffect.catchAllCause(cause => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.isShutdown(queue), Effect_dist_effectEffect.flatMap(isShutdown => isShutdown && Cause_dist_effectCause.isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(Queue_dist_effectQueue.shutdown(queue)) : Function_dist_effectFunction.identity);
+
+/** @internal */
+const fromChunks = (...chunks) => Function_dist_effectFunction.pipe(fromIterable(chunks), flatMap(fromChunk));
+
+/** @internal */
+const fromEffect = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some), fromEffectOption);
+
+/** @internal */
+const fromEffectOption = effect => new StreamImpl(sink.unwrap(Effect_dist_effectEffect.match(effect, {
+  onFailure: Option_dist_effectOption.match({
+    onNone: () => sink.unit,
+    onSome: sink.fail
+  }),
+  onSuccess: a => sink.write(Chunk_dist_effectChunk.of(a))
+})));
+
+/** @internal */
+const fromHub = (hub, options) => {
+  const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
+  if (options?.scoped) {
+    const effect = Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), queue => fromQueue(queue, {
+      maxChunkSize,
+      shutdown: true
+    }));
+    return options.shutdown ? Effect_dist_effectEffect.map(effect, ensuring(Hub_dist_effectHub.shutdown(hub))) : effect;
+  }
+  const stream = flatMap(scoped(Hub_dist_effectHub.subscribe(hub)), queue => fromQueue(queue, {
+    maxChunkSize
+  }));
+  return options?.shutdown ? ensuring(stream, Hub_dist_effectHub.shutdown(hub)) : stream;
+};
+
+/** @internal */
+const fromIterable = iterable => suspend(() => Chunk_dist_effectChunk.isChunk(iterable) ? fromChunk(iterable) : fromIteratorSucceed(iterable[Symbol.iterator]()));
+
+/** @internal */
+const fromIterableEffect = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(fromIterable), unwrap);
+
+/** @internal */
+const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
+  return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
+    let builder = [];
+    const loop = iterator => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
+      let next = iterator.next();
+      if (maxChunkSize === 1) {
+        if (next.done) {
+          return sink.unit;
+        }
+        return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator)));
+      }
+      builder = [];
+      let count = 0;
+      while (count < maxChunkSize && !next.done) {
+        builder.push(next.value);
+        next = iterator.next();
+        count = count + 1;
+      }
+      if (count > 0) {
+        return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.unsafeFromArray(builder)), sink.flatMap(() => loop(iterator)));
+      }
+      return sink.unit;
+    }), sink.unwrap);
+    return new StreamImpl(loop(iterator));
+  }), unwrap);
+};
+
+/** @internal */
+const fromPull = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(repeatEffectChunkOption), unwrapScoped);
+
+/** @internal */
+const fromQueue = (queue, options) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), Effect_dist_effectEffect.catchAllCause(cause => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.isShutdown(queue), Effect_dist_effectEffect.flatMap(isShutdown => isShutdown && Cause_dist_effectCause.isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(Queue_dist_effectQueue.shutdown(queue)) : Function_dist_effectFunction.identity);
+
+/** @internal */
+const fromSchedule = schedule => Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => repeatEffectOption(driver.next(void 0))), unwrap);
+
+/** @internal */
+const fromReadableStream = (evaluate, onError) => unwrapScoped(Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => evaluate().getReader()), reader => Effect_dist_effectEffect.promise(() => reader.cancel())), reader => repeatEffectOption(Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.tryPromise({
+  try: () => reader.read(),
+  catch: reason => Option_dist_effectOption.some(onError(reason))
+}), ({
+  done,
+  value
+}) => done ? Effect_dist_effectEffect.fail(Option_dist_effectOption.none()) : Effect_dist_effectEffect.succeed(value)))));
+
+/** @internal */
+const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => evaluate().getReader({
+  mode: "byob"
+})), reader => Effect_dist_effectEffect.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 => Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.tryPromise({
+    try: () => reader.read(new Uint8Array(buffer, offset, buffer.byteLength - offset)),
+    catch: reason => onError(reason)
+  }), ({
+    done,
+    value
+  }) => {
+    if (done) {
+      return Effect_dist_effectEffect.fail({
+        _tag: "EOF"
+      });
+    }
+    const newOffset = offset + value.byteLength;
+    return Effect_dist_effectEffect.succeed([value, newOffset >= buffer.byteLength ? Option_dist_effectOption.none() : Option_dist_effectOption.some(newOffset)]);
+  }));
+};
+
+/** @internal */
+const groupAdjacentBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const groupAdjacentByChunk = (state, chunk) => {
+    if (Chunk_dist_effectChunk.isEmpty(chunk)) {
+      return [state, Chunk_dist_effectChunk.empty()];
+    }
+    const builder = [];
+    let from = 0;
+    let until = 0;
+    let key = undefined;
+    let previousChunk = Chunk_dist_effectChunk.empty();
+    switch (state._tag) {
+      case "Some":
+        {
+          const tuple = state.value;
+          key = tuple[0];
+          let loop = true;
+          while (loop && until < chunk.length) {
+            const input = Chunk_dist_effectChunk.unsafeGet(chunk, until);
+            const updatedKey = f(input);
+            if (!Equal_dist_effectEqual.equals(key, updatedKey)) {
+              builder.push([key, Chunk_dist_effectChunk.unsafeFromArray(Array.from(tuple[1]).slice(from, until))]);
+              key = updatedKey;
+              from = until;
+              loop = false;
+            }
+            until = until + 1;
+          }
+          if (loop) {
+            previousChunk = tuple[1];
+          }
+          break;
+        }
+      case "None":
+        {
+          key = f(Chunk_dist_effectChunk.unsafeGet(chunk, until));
+          until = until + 1;
+          break;
+        }
+    }
+    while (until < chunk.length) {
+      const input = Chunk_dist_effectChunk.unsafeGet(chunk, until);
+      const updatedKey = f(input);
+      if (!Equal_dist_effectEqual.equals(key, updatedKey)) {
+        builder.push([key, Chunk_dist_effectChunk.unsafeFromArray(Array.from(chunk).slice(from, until))]);
+        key = updatedKey;
+        from = until;
+      }
+      until = until + 1;
+    }
+    const nonEmptyChunk = Chunk_dist_effectChunk.appendAll(previousChunk, Chunk_dist_effectChunk.unsafeFromArray(Array.from(chunk).slice(from, until)));
+    const output = Chunk_dist_effectChunk.unsafeFromArray(builder);
+    return [Option_dist_effectOption.some([key, nonEmptyChunk]), output];
+  };
+  const groupAdjacent = state => sink.readWithCause({
+    onInput: input => {
+      const [updatedState, output] = groupAdjacentByChunk(state, input);
+      return Chunk_dist_effectChunk.isEmpty(output) ? groupAdjacent(updatedState) : sink.flatMap(sink.write(output), () => groupAdjacent(updatedState));
+    },
+    onFailure: cause => Option_dist_effectOption.match(state, {
+      onNone: () => sink.failCause(cause),
+      onSome: output => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(output)), () => sink.failCause(cause))
+    }),
+    onDone: done => Option_dist_effectOption.match(state, {
+      onNone: () => sink.succeedNow(done),
+      onSome: output => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(output)), () => sink.succeedNow(done))
+    })
+  });
+  return new StreamImpl(sink.pipeToOrFail(toChannel(self), groupAdjacent(Option_dist_effectOption.none())));
+});
+
+/** @internal */
+const grouped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunkSize) => Function_dist_effectFunction.pipe(self, rechunk(chunkSize), chunks));
+
+/** @internal */
+const groupedWithin = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, chunkSize, duration) => aggregateWithin(self, sink.collectAllN(chunkSize), Schedule_dist_effectSchedule.spaced(duration)));
+
+/** @internal */
+const haltWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => {
+  const writer = fiber => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.poll(fiber), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
+    onNone: () => sink.readWith({
+      onInput: input => sink.flatMap(sink.write(input), () => writer(fiber)),
+      onFailure: sink.fail,
+      onDone: () => sink.unit
+    }),
+    onSome: Exit_dist_effectExit.match({
+      onFailure: sink.failCause,
+      onSuccess: () => sink.unit
+    })
+  })), sink.unwrap);
+  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forkScoped(effect), Effect_dist_effectEffect.map(fiber => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(fiber)))), sink.unwrapScoped));
+});
+
+/** @internal */
+const haltAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(self, haltWhen(Clock_dist_effectClock.sleep(duration))));
+
+/** @internal */
+const haltWhenDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => {
+  const writer = Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.poll(deferred), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
+    onNone: () => sink.readWith({
+      onInput: input => Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => writer)),
+      onFailure: sink.fail,
+      onDone: () => sink.unit
+    }),
+    onSome: effect => sink.unwrap(Effect_dist_effectEffect.match(effect, {
+      onFailure: sink.fail,
+      onSuccess: () => sink.unit
+    }))
+  })), sink.unwrap);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer)));
+});
+
+/** @internal */
+const identityStream = () => new StreamImpl(sink.identityChannel());
+
+/** @internal */
+const interleave = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, interleaveWith(that, forever(make(true, false)))));
+
+/** @internal */
+const interleaveWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, decider) => {
+  const producer = handoff => sink.readWithCause({
+    onInput: value => sink.flatMap(sink.fromEffect(offer(handoff, take$2.of(value))), () => producer(handoff)),
+    onFailure: cause => sink.fromEffect(offer(handoff, take$2.failCause(cause))),
+    onDone: () => sink.fromEffect(offer(handoff, take$2.end))
+  });
+  return new StreamImpl(sink.unwrapScoped(Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.zip(make$1()), Effect_dist_effectEffect.tap(([left]) => Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(left)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.tap(([_, right]) => Function_dist_effectFunction.pipe(toChannel(that), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(right)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.map(([left, right]) => {
+    const process = (leftDone, rightDone) => sink.readWithCause({
+      onInput: bool => {
+        if (bool && !leftDone) {
+          return Function_dist_effectFunction.pipe(sink.fromEffect(take$1(left)), sink.flatMap(take$2.match({
+            onEnd: () => rightDone ? sink.unit : process(true, rightDone),
+            onFailure: sink.failCause,
+            onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => process(leftDone, rightDone)))
+          })));
+        }
+        if (!bool && !rightDone) {
+          return Function_dist_effectFunction.pipe(sink.fromEffect(take$1(right)), sink.flatMap(take$2.match({
+            onEnd: () => leftDone ? sink.unit : process(leftDone, true),
+            onFailure: sink.failCause,
+            onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => process(leftDone, rightDone)))
+          })));
+        }
+        return process(leftDone, rightDone);
+      },
+      onFailure: sink.failCause,
+      onDone: () => sink.unit
+    });
+    return Function_dist_effectFunction.pipe(toChannel(decider), sink.concatMap(sink.writeChunk), sink.pipeTo(process(false, false)));
+  }))));
+});
+
+/** @internal */
+const intersperse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, element) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.suspend(() => {
+  const writer = isFirst => sink.readWithCause({
+    onInput: chunk => {
+      const builder = [];
+      let flagResult = isFirst;
+      for (const output of chunk) {
+        if (flagResult) {
+          flagResult = false;
+          builder.push(output);
+        } else {
+          builder.push(element);
+          builder.push(output);
+        }
+      }
+      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.unsafeFromArray(builder)), sink.flatMap(() => writer(flagResult)));
+    },
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  return writer(true);
+})))));
+
+/** @internal */
+const intersperseAffixes = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  end,
+  middle,
+  start
+}) => Function_dist_effectFunction.pipe(make(start), concat(Function_dist_effectFunction.pipe(self, intersperse(middle))), concat(make(end))));
+
+/** @internal */
+const interruptAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(self, interruptWhen(Clock_dist_effectClock.sleep(duration))));
+
+/** @internal */
+const interruptWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.interruptWhen(effect))));
+
+/** @internal */
+const interruptWhenDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.interruptWhenDeferred(deferred))));
+
+/** @internal */
+const iterate = (value, next) => unfold(value, a => Option_dist_effectOption.some([a, next(a)]));
+
+/** @internal */
+const make = (...as) => fromIterable(as);
+
+/** @internal */
+const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOut(Chunk_dist_effectChunk.map(f)))));
+
+/** @internal */
+const mapAccum = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => {
+  const accumulator = s => sink.readWith({
+    onInput: input => {
+      const [nextS, chunk] = Chunk_dist_effectChunk.mapAccum(input, s, f);
+      return sink.flatMap(sink.write(chunk), () => accumulator(nextS));
+    },
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(accumulator(s))));
+});
+
+/** @internal */
+const mapAccumEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => suspend(() => {
+  const accumulator = s => sink.readWith({
+    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => {
+      const outputs = [];
+      const emit = output => Effect_dist_effectEffect.sync(() => {
+        outputs.push(output);
+      });
+      return Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.reduce(s, (s, a) => Function_dist_effectFunction.pipe(f(s, a), Effect_dist_effectEffect.flatMap(([s, a]) => Function_dist_effectFunction.pipe(emit(a), Effect_dist_effectEffect.as(s))))), Effect_dist_effectEffect.match({
+        onFailure: error => {
+          if (outputs.length !== 0) {
+            return sink.zipRight(sink.write(Chunk_dist_effectChunk.unsafeFromArray(outputs)), sink.fail(error));
+          }
+          return sink.fail(error);
+        },
+        onSuccess: s => sink.flatMap(sink.write(Chunk_dist_effectChunk.unsafeFromArray(outputs)), () => accumulator(s))
+      }));
+    }), sink.unwrap),
+    onFailure: sink.fail,
+    onDone: () => sink.unit
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(accumulator(s))));
+}));
+
+/** @internal */
+const mapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => Function_dist_effectFunction.pipe(self, mapError(options.onFailure), map(options.onSuccess)));
+
+/** @internal */
+const mapChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOut(f))));
+
+/** @internal */
+const mapChunksEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOutEffect(f))));
+
+/** @internal */
+const mapConcat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapConcatChunk(a => Chunk_dist_effectChunk.fromIterable(f(a)))));
+
+/** @internal */
+const mapConcatChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapChunks(Chunk_dist_effectChunk.flatMap(f))));
+
+/** @internal */
+const mapConcatChunkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapEffectSequential(f), mapConcatChunk(Function_dist_effectFunction.identity)));
+
+/** @internal */
+const mapConcatEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapEffectSequential(a => Function_dist_effectFunction.pipe(f(a), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.fromIterable))), mapConcatChunk(Function_dist_effectFunction.identity)));
+
+/** @internal */
+const mapEffectSequential = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: elem => loop(elem[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeed
+      });
+    } else {
+      const value = next.value;
+      return sink.unwrap(Effect_dist_effectEffect.map(f(value), a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator))));
+    }
+  };
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(sink.suspend(() => loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]())))));
+});
+
+/** @internal */
+const mapEffectPar = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mapOutEffectPar(f, n), sink.mapOut(Chunk_dist_effectChunk.of))));
+
+/** @internal */
+const mapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapError(f))));
+
+/** @internal */
+const mapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapErrorCause(f))));
+
+/** @internal */
+const merge = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[1]), (self, that, options) => mergeWith(self, that, {
+  onSelf: Function_dist_effectFunction.identity,
+  onOther: Function_dist_effectFunction.identity,
+  haltStrategy: options?.haltStrategy
+}));
+
+/** @internal */
+const mergeAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Symbol.iterator in args[0], (streams, options) => flatten(fromIterable(streams), options));
+
+/** @internal */
+const mergeEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => mergeWith(self, that, {
+  onSelf: Either_dist_effectEither.left,
+  onOther: Either_dist_effectEither.right
+}));
+
+/** @internal */
+const mergeLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, merge(drain(that))));
+
+/** @internal */
+const mergeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(drain(self), merge(that)));
+
+/** @internal */
+const mergeWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, options) => {
+  const strategy = options.haltStrategy ? StreamHaltStrategy_dist_effectStreamHaltStrategy.fromInput(options.haltStrategy) : StreamHaltStrategy_dist_effectStreamHaltStrategy.Both;
+  const handler = terminate => exit => terminate || !Exit_dist_effectExit.isSuccess(exit) ?
+  // TODO: remove
+  ChannelMergeDecision_dist_effectChannelMergeDecision.Done(Effect_dist_effectEffect.suspend(() => exit)) : ChannelMergeDecision_dist_effectChannelMergeDecision.Await(exit => Effect_dist_effectEffect.suspend(() => exit));
+  return new StreamImpl(sink.mergeWith(toChannel(map(self, options.onSelf)), {
+    other: toChannel(map(other, options.onOther)),
+    onSelfDone: handler(strategy._tag === "Either" || strategy._tag === "Left"),
+    onOtherDone: handler(strategy._tag === "Either" || strategy._tag === "Right")
+  }));
+});
+
+/** @internal */
+const mkString = self => run(self, sink.mkString);
+
+/** @internal */
+const never = /*#__PURE__*/fromEffect(Effect_dist_effectEffect.never);
+
+/** @internal */
+const onError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cleanup) => Function_dist_effectFunction.pipe(self, catchAllCause(cause => fromEffect(Function_dist_effectFunction.pipe(cleanup(cause), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.failCause(cause)))))));
+
+/** @internal */
+const onDone = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cleanup) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.ensuringWith(exit => Exit_dist_effectExit.isSuccess(exit) ? cleanup() : Effect_dist_effectEffect.unit))));
+
+/** @internal */
+const orDie = self => Function_dist_effectFunction.pipe(self, orDieWith(Function_dist_effectFunction.identity));
+
+/** @internal */
+const orDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.orDieWith(f))));
+
+/** @internal */
+const orElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.orElse(() => toChannel(that())))));
+
+/** @internal */
+const orElseEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, map(Either_dist_effectEither.left), orElse(() => Function_dist_effectFunction.pipe(that(), map(Either_dist_effectEither.right)))));
+
+/** @internal */
+const orElseFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => Function_dist_effectFunction.pipe(self, orElse(() => failSync(error))));
+
+/** @internal */
+const orElseIfEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, element) => Function_dist_effectFunction.pipe(self, orElseIfEmptyChunk(() => Chunk_dist_effectChunk.of(element()))));
+
+/** @internal */
+const orElseIfEmptyChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunk) => Function_dist_effectFunction.pipe(self, orElseIfEmptyStream(() => new StreamImpl(sink.write(chunk())))));
+
+/** @internal */
+const orElseIfEmptyStream = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, stream) => {
+  const writer = sink.readWith({
+    onInput: input => {
+      if (Chunk_dist_effectChunk.isEmpty(input)) {
+        return sink.suspend(() => writer);
+      }
+      return Function_dist_effectFunction.pipe(sink.write(input), sink.zipRight(sink.identityChannel()));
+    },
+    onFailure: sink.fail,
+    onDone: () => sink.suspend(() => toChannel(stream()))
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer)));
+});
+
+/** @internal */
+const orElseSucceed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => Function_dist_effectFunction.pipe(self, orElse(() => sync(value))));
+
+/** @internal */
+const paginate = (s, f) => paginateChunk(s, s => {
+  const page = f(s);
+  return [Chunk_dist_effectChunk.of(page[0]), page[1]];
+});
+
+/** @internal */
+const paginateChunk = (s, f) => {
+  const loop = s => {
+    const page = f(s);
+    return Option_dist_effectOption.match(page[1], {
+      onNone: () => sink.zipRight(sink.write(page[0]), sink.unit),
+      onSome: s => sink.flatMap(sink.write(page[0]), () => loop(s))
+    });
+  };
+  return new StreamImpl(sink.suspend(() => loop(s)));
+};
+
+/** @internal */
+const paginateChunkEffect = (s, f) => {
+  const loop = s => sink.unwrap(Effect_dist_effectEffect.map(f(s), ([chunk, option]) => Option_dist_effectOption.match(option, {
+    onNone: () => sink.zipRight(sink.write(chunk), sink.unit),
+    onSome: s => sink.flatMap(sink.write(chunk), () => loop(s))
+  })));
+  return new StreamImpl(sink.suspend(() => loop(s)));
+};
+
+/** @internal */
+const paginateEffect = (s, f) => paginateChunkEffect(s, s => Function_dist_effectFunction.pipe(f(s), Effect_dist_effectEffect.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s])));
+
+/** @internal */
+const peel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => {
+  const OP_EMIT = "Emit";
+  const OP_HALT = "Halt";
+  const OP_END = "End";
+  return Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.map(handoff => {
+    const consumer = sink.foldSink(sink.collectLeftover(sink$1), {
+      onFailure: error => sink.zipRight$1(sink.fromEffect$1(Deferred_dist_effectDeferred.fail(deferred, error)), sink.fail$1(error)),
+      onSuccess: ([z, leftovers]) => {
+        const loop = sink.readWithCause({
+          onInput: elements => sink.flatMap(sink.fromEffect(offer(handoff, {
+            _tag: OP_EMIT,
+            elements
+          })), () => loop),
+          onFailure: cause => sink.zipRight(sink.fromEffect(offer(handoff, {
+            _tag: OP_HALT,
+            cause
+          })), sink.failCause(cause)),
+          onDone: _ => sink.zipRight(sink.fromEffect(offer(handoff, {
+            _tag: OP_END
+          })), sink.unit)
+        });
+        return sink.fromChannel(Function_dist_effectFunction.pipe(sink.fromEffect(Deferred_dist_effectDeferred.succeed(deferred, z)), sink.zipRight(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer({
+          _tag: OP_EMIT,
+          elements: leftovers
+        })))), sink.zipRight(loop)));
+      }
+    });
+    const producer = Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
+      switch (signal._tag) {
+        case OP_EMIT:
+          {
+            return Function_dist_effectFunction.pipe(sink.write(signal.elements), sink.flatMap(() => producer));
+          }
+        case OP_HALT:
+          {
+            return sink.failCause(signal.cause);
+          }
+        case OP_END:
+          {
+            return sink.unit;
+          }
+      }
+    }), sink.unwrap);
+    return Function_dist_effectFunction.pipe(self, tapErrorCause(cause => Deferred_dist_effectDeferred.failCause(deferred, cause)), run(consumer), Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred._await(deferred)), Effect_dist_effectEffect.map(z => [z, new StreamImpl(producer)]));
+  }))), Effect_dist_effectEffect.flatten);
+});
+
+/** @internal */
+const partition = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[1] === "function", (self, predicate, options) => partitionEither(self, a => Effect_dist_effectEffect.succeed(predicate(a) ? Either_dist_effectEither.left(a) : Either_dist_effectEither.right(a)), options));
+
+/** @internal */
+const partitionEither = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[1] === "function", (self, predicate, options) => Function_dist_effectFunction.pipe(mapEffectSequential(self, predicate), distributedWith({
+  size: 2,
+  maximumLag: options?.bufferSize ?? 16,
+  decide: Either_dist_effectEither.match({
+    onLeft: () => Effect_dist_effectEffect.succeed(n => n === 0),
+    onRight: () => Effect_dist_effectEffect.succeed(n => n === 1)
+  })
+}), Effect_dist_effectEffect.flatMap(([queue1, queue2]) => Effect_dist_effectEffect.succeed([filterMap(flattenExitOption(fromQueue(queue1, {
+  shutdown: true
+})), _ => Either_dist_effectEither.match(_, {
+  onLeft: Option_dist_effectOption.some,
+  onRight: Option_dist_effectOption.none
+})), filterMap(flattenExitOption(fromQueue(queue2, {
+  shutdown: true
+})), _ => Either_dist_effectEither.match(_, {
+  onLeft: Option_dist_effectOption.none,
+  onRight: Option_dist_effectOption.some
+}))]))));
+
+/** @internal */
+const pipeThrough = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)))));
+
+/** @internal */
+const pipeThroughChannel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, channel) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(channel))));
+
+/** @internal */
+const pipeThroughChannelOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chan) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(chan))));
+
+/** @internal */
+const prepend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, values) => new StreamImpl(sink.zipRight(sink.write(values), toChannel(self))));
+
+/** @internal */
+const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.provideContext(context))));
+
+/** @internal */
+const provideLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) => new StreamImpl(sink.unwrapScoped(Function_dist_effectFunction.pipe(Layer_dist_effectLayer.build(layer), Effect_dist_effectEffect.map(env => Function_dist_effectFunction.pipe(toChannel(self), sink.provideContext(env)))))));
+
+/** @internal */
+const provideService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, resource) => provideServiceEffect(self, tag, Effect_dist_effectEffect.succeed(resource)));
+
+/** @internal */
+const provideServiceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, effect) => provideServiceStream(self, tag, fromEffect(effect)));
+
+/** @internal */
+const provideServiceStream = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, stream) => contextWithStream(env => flatMap(stream, service => Function_dist_effectFunction.pipe(self, provideContext(Context_dist_effectContext.add(env, tag, service))))));
+
+/** @internal */
+const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => contextWithStream(env => Function_dist_effectFunction.pipe(self, provideContext(f(env)))));
+
+/** @internal */
+const provideSomeLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) =>
+// @ts-expect-error
+Function_dist_effectFunction.pipe(self, provideLayer(Function_dist_effectFunction.pipe(Layer_dist_effectLayer.context(), Layer_dist_effectLayer.merge(layer)))));
+
+/** @internal */
+const range = (min, max, chunkSize = DefaultChunkSize) => suspend(() => {
+  if (min > max) {
+    return empty;
+  }
+  const go = (min, max, chunkSize) => {
+    const remaining = max - min + 1;
+    if (remaining > chunkSize) {
+      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.range(min, min + chunkSize - 1)), sink.flatMap(() => go(min + chunkSize, max, chunkSize)));
+    }
+    return sink.write(Chunk_dist_effectChunk.range(min, min + remaining - 1));
+  };
+  return new StreamImpl(go(min, max, chunkSize));
+});
+
+/** @internal */
+const rechunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => suspend(() => {
+  const target = Math.max(n, 1);
+  const process = rechunkProcess(new StreamRechunker(target), target);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(process)));
+}));
+
+/** @internal */
+const rechunkProcess = (rechunker, target) => sink.readWithCause({
+  onInput: chunk => {
+    if (chunk.length === target && rechunker.isEmpty()) {
+      return sink.flatMap(sink.write(chunk), () => rechunkProcess(rechunker, target));
+    }
+    if (chunk.length > 0) {
+      const chunks = [];
+      let result = undefined;
+      let index = 0;
+      while (index < chunk.length) {
+        while (index < chunk.length && result === undefined) {
+          result = rechunker.write(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.unsafeGet(index)));
+          index = index + 1;
+        }
+        if (result !== undefined) {
+          chunks.push(result);
+          result = undefined;
+        }
+      }
+      return sink.flatMap(sink.writeAll(...chunks), () => rechunkProcess(rechunker, target));
+    }
+    return sink.suspend(() => rechunkProcess(rechunker, target));
+  },
+  onFailure: cause => sink.zipRight(rechunker.emitIfNotEmpty(), sink.failCause(cause)),
+  onDone: () => rechunker.emitIfNotEmpty()
+});
+
+/** @internal */
+class StreamRechunker {
+  builder = [];
+  pos = 0;
+  constructor(n) {
+    this.n = n;
+  }
+  isEmpty() {
+    return this.pos === 0;
+  }
+  write(elem) {
+    this.builder.push(elem);
+    this.pos += 1;
+    if (this.pos === this.n) {
+      const result = Chunk_dist_effectChunk.unsafeFromArray(this.builder);
+      this.builder = [];
+      this.pos = 0;
+      return result;
+    }
+    return undefined;
+  }
+  emitIfNotEmpty() {
+    if (this.pos !== 0) {
+      return sink.write(Chunk_dist_effectChunk.unsafeFromArray(this.builder));
+    }
+    return sink.unit;
+  }
+}
+
+/** @internal */
+const refineOrDie = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, refineOrDieWith(pf, Function_dist_effectFunction.identity)));
+
+/** @internal */
+const refineOrDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, pf, f) => new StreamImpl(sink.catchAll(toChannel(self), error => Option_dist_effectOption.match(pf(error), {
+  onNone: () => sink.failCause(Cause_dist_effectCause.die(f(error))),
+  onSome: sink.fail
+}))));
+
+/** @internal */
+const repeat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(repeatEither(self, schedule), _ => Either_dist_effectEither.match(_, {
+  onLeft: Option_dist_effectOption.none,
+  onRight: Option_dist_effectOption.some
+})));
+
+/** @internal */
+const repeatEffect = effect => repeatEffectOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
+
+/** @internal */
+const repeatEffectChunk = effect => repeatEffectChunkOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
+
+/** @internal */
+const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.map(effect, chunk => Option_dist_effectOption.some([chunk, effect])), Effect_dist_effectEffect.catchAll(Option_dist_effectOption.match({
+  onNone: () => Effect_dist_effectEffect.succeed(Option_dist_effectOption.none()),
+  onSome: Effect_dist_effectEffect.fail
+}))));
+
+/** @internal */
+const repeatEffectOption = effect => repeatEffectChunkOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(Chunk_dist_effectChunk.of)));
+
+/** @internal */
+const repeatEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatWith(self, schedule, {
+  onElement: a => Either_dist_effectEither.right(a),
+  onSchedule: Either_dist_effectEither.left
+}));
+
+/** @internal */
+const repeatElements = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(repeatElementsWith(self, schedule, {
+  onElement: a => Option_dist_effectOption.some(a),
+  onSchedule: Option_dist_effectOption.none
+}), Function_dist_effectFunction.identity));
+
+/** @internal */
+const repeatElementsWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
+  const driver = Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => {
+    const feed = input => Option_dist_effectOption.match(Chunk_dist_effectChunk.head(input), {
+      onNone: () => loop,
+      onSome: a => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(options.onElement(a))), step(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(1)), a))
+    });
+    const step = (input, a) => {
+      const advance = Function_dist_effectFunction.pipe(driver.next(a), Effect_dist_effectEffect.as(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onElement(a))), sink.flatMap(() => step(input, a)))));
+      const reset = Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.flatMap(b => Function_dist_effectFunction.pipe(driver.reset(), Effect_dist_effectEffect.map(() => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onSchedule(b))), sink.zipRight(feed(input)))))));
+      return Function_dist_effectFunction.pipe(advance, Effect_dist_effectEffect.orElse(() => reset), sink.unwrap);
+    };
+    const loop = sink.readWith({
+      onInput: feed,
+      onFailure: sink.fail,
+      onDone: () => sink.unit
+    });
+    return loop;
+  }), sink.unwrap);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(driver)));
+});
+
+/** @internal */
+const repeatValue = value => new StreamImpl(sink.repeated(sink.write(Chunk_dist_effectChunk.of(value))));
+
+/** @internal */
+const repeatWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
+  return Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => {
+    const scheduleOutput = Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.map(options.onSchedule));
+    const process = Function_dist_effectFunction.pipe(self, map(options.onElement), toChannel);
+    const loop = sink.unwrap(Effect_dist_effectEffect.match(driver.next(void 0), {
+      onFailure: () => sink.unit,
+      onSuccess: () => Function_dist_effectFunction.pipe(process, sink.zipRight(Function_dist_effectFunction.pipe(scheduleOutput, Effect_dist_effectEffect.map(c => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(c)), sink.flatMap(() => loop))), sink.unwrap)))
+    }));
+    return new StreamImpl(Function_dist_effectFunction.pipe(process, sink.zipRight(loop)));
+  }), unwrap);
+});
+
+/** @internal */
+const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(Effect_dist_effectEffect.succeed(value), schedule);
+
+/** @internal */
+const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(Effect_dist_effectEffect.zip(effect, Schedule_dist_effectSchedule.driver(schedule))), ([a, driver]) => concat(succeed(a), unfoldEffect(a, s => Effect_dist_effectEffect.matchEffect(driver.next(s), {
+  onFailure: Effect_dist_effectEffect.succeed,
+  onSuccess: () => Effect_dist_effectEffect.map(effect, nextA => Option_dist_effectOption.some([nextA, nextA]))
+}))));
+
+/** @internal */
+const retry = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => unwrap(Effect_dist_effectEffect.map(Schedule_dist_effectSchedule.driver(schedule), driver => {
+  const loop = catchAll(self, error => unwrap(Effect_dist_effectEffect.matchEffect(driver.next(error), {
+    onFailure: () => Effect_dist_effectEffect.fail(error),
+    onSuccess: () => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(loop, tap(() => driver.reset())))
+  })));
+  return loop;
+})));
+
+/** @internal */
+const run = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)), sink.runDrain));
+
+/** @internal */
+const runCollect = self => Function_dist_effectFunction.pipe(self, run(sink.collectAll()));
+
+/** @internal */
+const runCount = self => Function_dist_effectFunction.pipe(self, run(sink.count));
+
+/** @internal */
+const runDrain = self => Function_dist_effectFunction.pipe(self, run(sink.drain$1));
+
+/** @internal */
+const runFold = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, Function_dist_effectFunction.constTrue, f), Effect_dist_effectEffect.scoped));
+
+/** @internal */
+const runFoldEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, Function_dist_effectFunction.constTrue, f), Effect_dist_effectEffect.scoped));
+
+/** @internal */
+const runFoldScoped = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, Function_dist_effectFunction.constTrue, f)));
+
+/** @internal */
+const runFoldScopedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, Function_dist_effectFunction.constTrue, f)));
+
+/** @internal */
+const runFoldWhile = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, cont, f), Effect_dist_effectEffect.scoped));
+
+/** @internal */
+const runFoldWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, cont, f), Effect_dist_effectEffect.scoped));
+
+/** @internal */
+const runFoldWhileScoped = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.fold(s, cont, f))));
+
+/** @internal */
+const runFoldWhileScopedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.foldEffect(s, cont, f))));
+
+/** @internal */
+const runForEach = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEach(f))));
+
+/** @internal */
+const runForEachChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEachChunk(f))));
+
+/** @internal */
+const runForEachChunkScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEachChunk(f))));
+
+/** @internal */
+const runForEachScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEach(f))));
+
+/** @internal */
+const runForEachWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEachWhile(f))));
+
+/** @internal */
+const runForEachWhileScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEachWhile(f))));
+
+/** @internal */
+const runHead = self => Function_dist_effectFunction.pipe(self, run(sink.head()));
+
+/** @internal */
+const runIntoHub = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, hub) => Function_dist_effectFunction.pipe(self, runIntoQueue(hub)));
+
+/** @internal */
+const runIntoHubScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, hub) => Function_dist_effectFunction.pipe(self, runIntoQueueScoped(hub)));
+
+/** @internal */
+const runIntoQueue = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => Function_dist_effectFunction.pipe(self, runIntoQueueScoped(queue), Effect_dist_effectEffect.scoped));
+
+/** @internal */
+const runIntoQueueElementsScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => {
+  const writer = sink.readWithCause({
+    onInput: input => sink.flatMap(sink.fromEffect(Queue_dist_effectQueue.offerAll(queue, Chunk_dist_effectChunk.map(input, Exit_dist_effectExit.succeed))), () => writer),
+    onFailure: cause => sink.fromEffect(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.failCause(Cause_dist_effectCause.map(cause, Option_dist_effectOption.some)))),
+    onDone: () => sink.fromEffect(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.fail(Option_dist_effectOption.none())))
+  });
+  return Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), writer), sink.drain, sink.runScoped, Effect_dist_effectEffect.asUnit);
+});
+
+/** @internal */
+const runIntoQueueScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => {
+  const writer = sink.readWithCause({
+    onInput: input => sink.flatMap(sink.write(take$2.chunk(input)), () => writer),
+    onFailure: cause => sink.write(take$2.failCause(cause)),
+    onDone: () => sink.write(take$2.end)
+  });
+  return Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), writer), sink.mapOutEffect(take => Queue_dist_effectQueue.offer(queue, take)), sink.drain, sink.runScoped, Effect_dist_effectEffect.asUnit);
+});
+
+/** @internal */
+const runLast = self => Function_dist_effectFunction.pipe(self, run(sink.last()));
+
+/** @internal */
+const runScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)), sink.drain, sink.runScoped));
+
+/** @internal */
+const runSum = self => Function_dist_effectFunction.pipe(self, run(sink.sum));
+
+/** @internal */
+const scan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, scanEffect(s, (s, a) => Effect_dist_effectEffect.succeed(f(s, a)))));
+
+/** @internal */
+const scanReduce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, scanReduceEffect((a2, a) => Effect_dist_effectEffect.succeed(f(a2, a)))));
+
+/** @internal */
+const scanReduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapAccumEffect(Option_dist_effectOption.none(), (option, a) => {
+  switch (option._tag) {
+    case "None":
+      {
+        return Effect_dist_effectEffect.succeed([Option_dist_effectOption.some(a), a]);
+      }
+    case "Some":
+      {
+        return Function_dist_effectFunction.pipe(f(option.value, a), Effect_dist_effectEffect.map(b => [Option_dist_effectOption.some(b), b]));
+      }
+  }
+})));
+
+/** @internal */
+const schedule = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(scheduleWith(self, schedule, {
+  onElement: Option_dist_effectOption.some,
+  onSchedule: Option_dist_effectOption.none
+}), Function_dist_effectFunction.identity));
+
+/** @internal */
+const scheduleWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
+  const loop = (driver, iterator) => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: chunk => loop(driver, chunk[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeedNow
+      });
+    }
+    return sink.unwrap(Effect_dist_effectEffect.matchEffect(driver.next(next.value), {
+      onFailure: () => Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.map(b => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.make(options.onElement(next.value), options.onSchedule(b))), sink.flatMap(() => loop(driver, iterator)))), Effect_dist_effectEffect.zipLeft(driver.reset())),
+      onSuccess: () => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onElement(next.value))), sink.flatMap(() => loop(driver, iterator))))
+    }));
+  };
+  return new StreamImpl(Function_dist_effectFunction.pipe(sink.fromEffect(Schedule_dist_effectSchedule.driver(schedule)), sink.flatMap(driver => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(driver, Chunk_dist_effectChunk.empty()[Symbol.iterator]()))))));
+});
+
+/** @internal */
+const scanEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => new StreamImpl(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(s)), sink.flatMap(() => toChannel(Function_dist_effectFunction.pipe(self, mapAccumEffect(s, (s, a) => Function_dist_effectFunction.pipe(f(s, a), Effect_dist_effectEffect.map(s => [s, s])))))))));
+
+/** @internal */
+const scoped = effect => new StreamImpl(sink.ensuring(sink.scoped(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(Chunk_dist_effectChunk.of))), Effect_dist_effectEffect.unit));
+
+/** @internal */
+const some = self => Function_dist_effectFunction.pipe(self, mapError(Option_dist_effectOption.some), someOrFail(() => Option_dist_effectOption.none()));
+
+/** @internal */
+const someOrElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, fallback) => Function_dist_effectFunction.pipe(self, map(Option_dist_effectOption.getOrElse(fallback))));
+
+/** @internal */
+const someOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => mapEffectSequential(self, Option_dist_effectOption.match({
+  onNone: () => Effect_dist_effectEffect.failSync(error),
+  onSome: Effect_dist_effectEffect.succeed
+})));
+
+/** @internal */
+const sliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunkSize) => slidingSize(self, chunkSize, 1));
+
+/** @internal */
+const slidingSize = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, chunkSize, stepSize) => {
+  if (chunkSize <= 0 || stepSize <= 0) {
+    return die(Cause_dist_effectCause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero"));
+  }
+  return new StreamImpl(sink.suspend(() => {
+    const queue = new RingBuffer(chunkSize);
+    const emitOnStreamEnd = (queueSize, channelEnd) => {
+      if (queueSize < chunkSize) {
+        const items = queue.toChunk();
+        const result = Chunk_dist_effectChunk.isEmpty(items) ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.of(items);
+        return Function_dist_effectFunction.pipe(sink.write(result), sink.flatMap(() => channelEnd));
+      }
+      const lastEmitIndex = queueSize - (queueSize - chunkSize) % stepSize;
+      if (lastEmitIndex === queueSize) {
+        return channelEnd;
+      }
+      const leftovers = queueSize - (lastEmitIndex - chunkSize + stepSize);
+      const lastItems = Function_dist_effectFunction.pipe(queue.toChunk(), Chunk_dist_effectChunk.takeRight(leftovers));
+      const result = Chunk_dist_effectChunk.isEmpty(lastItems) ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.of(lastItems);
+      return Function_dist_effectFunction.pipe(sink.write(result), sink.flatMap(() => channelEnd));
+    };
+    const reader = queueSize => sink.readWithCause({
+      onInput: input => sink.flatMap(sink.write(Chunk_dist_effectChunk.filterMap(input, (element, index) => {
+        queue.put(element);
+        const currentIndex = queueSize + index + 1;
+        if (currentIndex < chunkSize || (currentIndex - chunkSize) % stepSize > 0) {
+          return Option_dist_effectOption.none();
+        }
+        return Option_dist_effectOption.some(queue.toChunk());
+      })), () => reader(queueSize + input.length)),
+      onFailure: cause => emitOnStreamEnd(queueSize, sink.failCause(cause)),
+      onDone: () => emitOnStreamEnd(queueSize, sink.unit)
+    });
+    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(reader(0)));
+  }));
+});
+
+/** @internal */
+const split = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const split = (leftovers, input) => {
+    const [chunk, remaining] = Function_dist_effectFunction.pipe(leftovers, Chunk_dist_effectChunk.appendAll(input), Chunk_dist_effectChunk.splitWhere(predicate));
+    if (Chunk_dist_effectChunk.isEmpty(chunk) || Chunk_dist_effectChunk.isEmpty(remaining)) {
+      return loop(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.appendAll(Function_dist_effectFunction.pipe(remaining, Chunk_dist_effectChunk.drop(1)))));
+    }
+    return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.flatMap(() => split(Chunk_dist_effectChunk.empty(), Function_dist_effectFunction.pipe(remaining, Chunk_dist_effectChunk.drop(1)))));
+  };
+  const loop = leftovers => sink.readWith({
+    onInput: input => split(leftovers, input),
+    onFailure: sink.fail,
+    onDone: () => {
+      if (Chunk_dist_effectChunk.isEmpty(leftovers)) {
+        return sink.unit;
+      }
+      if (Option_dist_effectOption.isNone(Function_dist_effectFunction.pipe(leftovers, Chunk_dist_effectChunk.findFirst(predicate)))) {
+        return sink.zipRight(sink.write(Chunk_dist_effectChunk.of(leftovers)), sink.unit);
+      }
+      return sink.zipRight(split(Chunk_dist_effectChunk.empty(), leftovers), sink.unit);
+    }
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()))));
+});
+
+/** @internal */
+const splitOnChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, delimiter) => {
+  const next = (leftover, delimiterIndex) => sink.readWithCause({
+    onInput: inputChunk => {
+      let buffer;
+      const [carry, delimiterCursor] = Function_dist_effectFunction.pipe(inputChunk, Chunk_dist_effectChunk.reduce([Function_dist_effectFunction.pipe(leftover, Option_dist_effectOption.getOrElse(() => Chunk_dist_effectChunk.empty())), delimiterIndex], ([carry, delimiterCursor], a) => {
+        const concatenated = Function_dist_effectFunction.pipe(carry, Chunk_dist_effectChunk.append(a));
+        if (delimiterCursor < delimiter.length && Equal_dist_effectEqual.equals(a, Function_dist_effectFunction.pipe(delimiter, Chunk_dist_effectChunk.unsafeGet(delimiterCursor)))) {
+          if (delimiterCursor + 1 === delimiter.length) {
+            if (buffer === undefined) {
+              buffer = [];
+            }
+            buffer.push(Function_dist_effectFunction.pipe(concatenated, Chunk_dist_effectChunk.take(concatenated.length - delimiter.length)));
+            return [Chunk_dist_effectChunk.empty(), 0];
+          }
+          return [concatenated, delimiterCursor + 1];
+        }
+        return [concatenated, Equal_dist_effectEqual.equals(a, Function_dist_effectFunction.pipe(delimiter, Chunk_dist_effectChunk.unsafeGet(0))) ? 1 : 0];
+      }));
+      const output = buffer === undefined ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.unsafeFromArray(buffer);
+      return sink.flatMap(sink.write(output), () => next(Chunk_dist_effectChunk.isNonEmpty(carry) ? Option_dist_effectOption.some(carry) : Option_dist_effectOption.none(), delimiterCursor));
+    },
+    onFailure: cause => Option_dist_effectOption.match(leftover, {
+      onNone: () => sink.failCause(cause),
+      onSome: chunk => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.failCause(cause))
+    }),
+    onDone: done => Option_dist_effectOption.match(leftover, {
+      onNone: () => sink.succeed(done),
+      onSome: chunk => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.succeed(done))
+    })
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(next(Option_dist_effectOption.none(), 0))));
+});
+
+/** @internal */
+const splitLines = self => suspend(() => {
+  let stringBuilder = "";
+  let midCRLF = false;
+  const splitLinesChunk = chunk => {
+    const chunkBuilder = [];
+    Chunk_dist_effectChunk.map(chunk, str => {
+      if (str.length !== 0) {
+        let from = 0;
+        let indexOfCR = str.indexOf("\r");
+        let indexOfLF = str.indexOf("\n");
+        if (midCRLF) {
+          if (indexOfLF === 0) {
+            chunkBuilder.push(stringBuilder);
+            stringBuilder = "";
+            from = 1;
+            indexOfLF = str.indexOf("\n", from);
+          } else {
+            stringBuilder = stringBuilder + "\r";
+          }
+          midCRLF = false;
+        }
+        while (indexOfCR !== -1 || indexOfLF !== -1) {
+          if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
+            if (stringBuilder.length === 0) {
+              chunkBuilder.push(str.substring(from, indexOfLF));
+            } else {
+              chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF));
+              stringBuilder = "";
+            }
+            from = indexOfLF + 1;
+            indexOfLF = str.indexOf("\n", from);
+          } else {
+            if (str.length === indexOfCR + 1) {
+              midCRLF = true;
+              indexOfCR = -1;
+            } else {
+              if (indexOfLF === indexOfCR + 1) {
+                if (stringBuilder.length === 0) {
+                  chunkBuilder.push(str.substring(from, indexOfCR));
+                } else {
+                  stringBuilder = stringBuilder + str.substring(from, indexOfCR);
+                  chunkBuilder.push(stringBuilder);
+                  stringBuilder = "";
+                }
+                from = indexOfCR + 2;
+                indexOfCR = str.indexOf("\r", from);
+                indexOfLF = str.indexOf("\n", from);
+              } else {
+                indexOfCR = str.indexOf("\r", indexOfCR + 1);
+              }
+            }
+          }
+        }
+        if (midCRLF) {
+          stringBuilder = stringBuilder + str.substring(from, str.length - 1);
+        } else {
+          stringBuilder = stringBuilder + str.substring(from, str.length);
+        }
+      }
+    });
+    return Chunk_dist_effectChunk.unsafeFromArray(chunkBuilder);
+  };
+  const loop = sink.readWithCause({
+    onInput: input => {
+      const out = splitLinesChunk(input);
+      return Chunk_dist_effectChunk.isEmpty(out) ? loop : sink.flatMap(sink.write(out), () => loop);
+    },
+    onFailure: cause => stringBuilder.length === 0 ? sink.failCause(cause) : sink.flatMap(sink.write(Chunk_dist_effectChunk.of(stringBuilder)), () => sink.failCause(cause)),
+    onDone: done => stringBuilder.length === 0 ? sink.succeed(done) : sink.flatMap(sink.write(Chunk_dist_effectChunk.of(stringBuilder)), () => sink.succeed(done))
+  });
+  return new StreamImpl(sink.pipeTo(toChannel(self), loop));
+});
+
+/** @internal */
+const succeed = value => fromChunk(Chunk_dist_effectChunk.of(value));
+
+/** @internal */
+const sync = evaluate => suspend(() => fromChunk(Chunk_dist_effectChunk.of(evaluate())));
+
+/** @internal */
+const suspend = stream => new StreamImpl(sink.suspend(() => toChannel(stream())));
+
+/** @internal */
+const take = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  if (!Number.isInteger(n)) {
+    return die(Cause_dist_effectCause.IllegalArgumentException(`${n} must be an integer`));
+  }
+  const loop = n => sink.readWith({
+    onInput: input => {
+      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.take(Math.min(n, Number.POSITIVE_INFINITY)));
+      const leftover = Math.max(0, n - taken.length);
+      const more = leftover > 0;
+      if (more) {
+        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop(leftover)));
+      }
+      return sink.write(taken);
+    },
+    onFailure: sink.fail,
+    onDone: sink.succeed
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(0 < n ? loop(n) : sink.unit)));
+});
+
+/** @internal */
+const takeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
+  if (n <= 0) {
+    return empty;
+  }
+  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(new RingBuffer(n)), Effect_dist_effectEffect.map(queue => {
+    const reader = sink.readWith({
+      onInput: input => {
+        for (const element of input) {
+          queue.put(element);
+        }
+        return reader;
+      },
+      onFailure: sink.fail,
+      onDone: () => Function_dist_effectFunction.pipe(sink.write(queue.toChunk()), sink.zipRight(sink.unit))
+    });
+    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(reader));
+  }), sink.unwrap));
+});
+
+/** @internal */
+const takeUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => {
+      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.takeWhile(a => !predicate(a)));
+      const last = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(taken.length), Chunk_dist_effectChunk.take(1));
+      if (Chunk_dist_effectChunk.isEmpty(last)) {
+        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop));
+      }
+      return sink.write(Function_dist_effectFunction.pipe(taken, Chunk_dist_effectChunk.appendAll(last)));
+    },
+    onFailure: sink.fail,
+    onDone: sink.succeed
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
+});
+
+/** @internal */
+const takeUntilEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = iterator => {
+    const next = iterator.next();
+    if (next.done) {
+      return sink.readWithCause({
+        onInput: elem => loop(elem[Symbol.iterator]()),
+        onFailure: sink.failCause,
+        onDone: sink.succeed
+      });
+    }
+    return Function_dist_effectFunction.pipe(predicate(next.value), Effect_dist_effectEffect.map(bool => bool ? sink.write(Chunk_dist_effectChunk.of(next.value)) : Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator)))), sink.unwrap);
+  };
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
+});
+
+/** @internal */
+const takeWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const loop = sink.readWith({
+    onInput: input => {
+      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.takeWhile(predicate));
+      const more = taken.length === input.length;
+      if (more) {
+        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop));
+      }
+      return sink.write(taken);
+    },
+    onFailure: sink.fail,
+    onDone: sink.succeed
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
+});
+
+/** @internal */
+const tap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapEffectSequential(self, a => Effect_dist_effectEffect.as(f(a), a)));
+
+/** @internal */
+const tapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => Function_dist_effectFunction.pipe(self, tapError(onFailure), tap(onSuccess)));
+
+/** @internal */
+const tapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAll(self, error => fromEffect(Effect_dist_effectEffect.zipRight(f(error), Effect_dist_effectEffect.fail(error)))));
+
+/** @internal */
+const tapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const loop = sink.readWithCause({
+    onInput: chunk => sink.flatMap(sink.write(chunk), () => loop),
+    onFailure: cause => sink.fromEffect(Effect_dist_effectEffect.zipRight(f(cause), Effect_dist_effectEffect.failCause(cause))),
+    onDone: sink.succeedNow
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
+});
+
+/** @internal */
+const tapSink = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(fromEffect(Effect_dist_effectEffect.all([Queue_dist_effectQueue.bounded(1), Deferred_dist_effectDeferred.make()])), flatMap(([queue, deferred]) => {
+  const right = flattenTake(fromQueue(queue, {
+    maxChunkSize: 1
+  }));
+  const loop = sink.readWithCause({
+    onInput: chunk => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.chunk(chunk))), sink.foldCauseChannel({
+      onFailure: () => sink.flatMap(sink.write(chunk), () => sink.identityChannel()),
+      onSuccess: () => sink.flatMap(sink.write(chunk), () => loop)
+    })),
+    onFailure: cause => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.failCause(cause))), sink.foldCauseChannel({
+      onFailure: () => sink.failCause(cause),
+      onSuccess: () => sink.failCause(cause)
+    })),
+    onDone: () => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.end)), sink.foldCauseChannel({
+      onFailure: () => sink.unit,
+      onSuccess: () => sink.unit
+    }))
+  });
+  return Function_dist_effectFunction.pipe(new StreamImpl(Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), loop), sink.ensuring(Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.forkDaemon(Queue_dist_effectQueue.offer(queue, take$2.end)), Deferred_dist_effectDeferred._await(deferred))))), merge(execute(Function_dist_effectFunction.pipe(run(right, sink$1), Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.shutdown(queue), Deferred_dist_effectDeferred.succeed(deferred, void 0)))))));
+})));
+
+/** @internal */
+const throttle = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => throttleEffect(self, {
+  ...options,
+  cost: chunk => Effect_dist_effectEffect.succeed(options.cost(chunk))
+}));
+
+/** @internal */
+const throttleEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
+  if (options.strategy === "enforce") {
+    return throttleEnforceEffect(self, options.cost, options.units, options.duration, options.burst ?? 0);
+  }
+  return throttleShapeEffect(self, options.cost, options.units, options.duration, options.burst ?? 0);
+});
+const throttleEnforceEffect = (self, cost, units, duration, burst) => {
+  const loop = (tokens, timestampMillis) => sink.readWithCause({
+    onInput: input => Function_dist_effectFunction.pipe(cost(input), Effect_dist_effectEffect.zip(Clock_dist_effectClock.currentTimeMillis), Effect_dist_effectEffect.map(([weight, currentTimeMillis]) => {
+      const elapsed = currentTimeMillis - timestampMillis;
+      const cycles = elapsed / Duration_dist_effectDuration.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 Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => loop(available - weight, currentTimeMillis)));
+      }
+      return loop(tokens, timestampMillis);
+    }), sink.unwrap),
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  const throttled = Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, Effect_dist_effectEffect.map(currentTimeMillis => loop(units, currentTimeMillis)), sink.unwrap);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(throttled)));
+};
+const throttleShapeEffect = (self, costFn, units, duration, burst) => {
+  const loop = (tokens, timestampMillis) => sink.readWithCause({
+    onInput: input => Function_dist_effectFunction.pipe(costFn(input), Effect_dist_effectEffect.zip(Clock_dist_effectClock.currentTimeMillis), Effect_dist_effectEffect.map(([weight, currentTimeMillis]) => {
+      const elapsed = currentTimeMillis - timestampMillis;
+      const cycles = elapsed / Duration_dist_effectDuration.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);
+      const remaining = available - weight;
+      const waitCycles = remaining >= 0 ? 0 : -remaining / units;
+      const delay = Duration_dist_effectDuration.millis(Math.max(0, waitCycles * Duration_dist_effectDuration.toMillis(duration)));
+      if (Duration_dist_effectDuration.greaterThan(delay, Duration_dist_effectDuration.zero)) {
+        return Function_dist_effectFunction.pipe(sink.fromEffect(Clock_dist_effectClock.sleep(delay)), sink.zipRight(sink.write(input)), sink.flatMap(() => loop(remaining, currentTimeMillis)));
+      }
+      return sink.flatMap(sink.write(input), () => loop(remaining, currentTimeMillis));
+    }), sink.unwrap),
+    onFailure: sink.failCause,
+    onDone: () => sink.unit
+  });
+  const throttled = Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, Effect_dist_effectEffect.map(currentTimeMillis => loop(units, currentTimeMillis)), sink.unwrap);
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(throttled)));
+};
+
+/** @internal */
+const tick = interval => repeatWithSchedule(void 0, Schedule_dist_effectSchedule.spaced(interval));
+
+/** @internal */
+const timeout = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(Effect_dist_effectEffect.timeoutFail({
+  onTimeout: () => Option_dist_effectOption.none(),
+  duration
+})), fromPull));
+
+/** @internal */
+const timeoutFail = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, error, duration) => Function_dist_effectFunction.pipe(self, timeoutTo(duration, failSync(error))));
+
+/** @internal */
+const timeoutFailCause = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, cause, duration) => Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(Effect_dist_effectEffect.timeoutFailCause({
+  onTimeout: () => Cause_dist_effectCause.map(cause(), Option_dist_effectOption.some),
+  duration
+})), fromPull));
+
+/** @internal */
+const timeoutTo = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, duration, that) => {
+  const StreamTimeout = Cause_dist_effectCause.RuntimeException("Stream Timeout");
+  return Function_dist_effectFunction.pipe(self, timeoutFailCause(() => Cause_dist_effectCause.die(StreamTimeout), duration), catchSomeCause(cause => Cause_dist_effectCause.isDieType(cause) && Cause_dist_effectCause.isRuntimeException(cause.defect) && cause.defect.message !== undefined && cause.defect.message === "Stream Timeout" ? Option_dist_effectOption.some(that) : Option_dist_effectOption.none()));
+});
+
+/** @internal */
+const toHub = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Hub_dist_effectHub.bounded(capacity), hub => Hub_dist_effectHub.shutdown(hub)), Effect_dist_effectEffect.tap(hub => Function_dist_effectFunction.pipe(self, runIntoHubScoped(hub), Effect_dist_effectEffect.forkScoped))));
+
+/** @internal */
+const toPull = self => Effect_dist_effectEffect.map(sink.toPull(toChannel(self)), pull => Function_dist_effectFunction.pipe(pull, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some), Effect_dist_effectEffect.flatMap(Either_dist_effectEither.match({
+  onLeft: () => Effect_dist_effectEffect.fail(Option_dist_effectOption.none()),
+  onRight: Effect_dist_effectEffect.succeed
+}))));
+
+/** @internal */
+const toQueue = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => Effect_dist_effectEffect.tap(Effect_dist_effectEffect.acquireRelease(options?.strategy === "unbounded" ? Queue_dist_effectQueue.unbounded() : options?.strategy === "dropping" ? Queue_dist_effectQueue.dropping(options.capacity ?? 2) : options?.strategy === "sliding" ? Queue_dist_effectQueue.sliding(options.capacity ?? 2) : Queue_dist_effectQueue.bounded(options?.capacity ?? 2), queue => Queue_dist_effectQueue.shutdown(queue)), queue => Effect_dist_effectEffect.forkScoped(runIntoQueueScoped(self, queue))));
+
+/** @internal */
+const toQueueOfElements = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => Effect_dist_effectEffect.tap(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(options?.capacity ?? 2), queue => Queue_dist_effectQueue.shutdown(queue)), queue => Effect_dist_effectEffect.forkScoped(runIntoQueueElementsScoped(self, queue))));
+
+/** @internal */
+const toReadableStream = source => {
+  let pull;
+  let scope;
+  return new ReadableStream({
+    start(controller) {
+      scope = Effect_dist_effectEffect.runSync(Scope_dist_effectScope.make());
+      pull = Function_dist_effectFunction.pipe(toPull(source), Scope_dist_effectScope.use(scope), Effect_dist_effectEffect.runSync, Effect_dist_effectEffect.tap(chunk => Effect_dist_effectEffect.sync(() => {
+        Chunk_dist_effectChunk.map(chunk, a => {
+          controller.enqueue(a);
+        });
+      })), Effect_dist_effectEffect.tapErrorCause(() => Scope_dist_effectScope.close(scope, Exit_dist_effectExit.unit)), Effect_dist_effectEffect.catchTags({
+        "None": () => Effect_dist_effectEffect.sync(() => {
+          controller.close();
+        }),
+        "Some": error => Effect_dist_effectEffect.sync(() => {
+          controller.error(error.value);
+        })
+      }), Effect_dist_effectEffect.asUnit);
+    },
+    pull() {
+      return Effect_dist_effectEffect.runPromise(pull);
+    },
+    cancel() {
+      return Effect_dist_effectEffect.runPromise(Scope_dist_effectScope.close(scope, Exit_dist_effectExit.unit));
+    }
+  });
+};
+
+/** @internal */
+const transduce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => {
+  const newChannel = sink.suspend(() => {
+    const leftovers = {
+      ref: Chunk_dist_effectChunk.empty()
+    };
+    const upstreamDone = {
+      ref: false
+    };
+    const buffer = sink.suspend(() => {
+      const leftover = leftovers.ref;
+      if (Chunk_dist_effectChunk.isEmpty(leftover)) {
+        return sink.readWith({
+          onInput: input => Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => buffer)),
+          onFailure: sink.fail,
+          onDone: sink.succeedNow
+        });
+      }
+      leftovers.ref = Chunk_dist_effectChunk.empty();
+      return Function_dist_effectFunction.pipe(sink.writeChunk(leftover), sink.flatMap(() => buffer));
+    });
+    const concatAndGet = chunk => {
+      const leftover = leftovers.ref;
+      const concatenated = Chunk_dist_effectChunk.appendAll(leftover, Chunk_dist_effectChunk.filter(chunk, chunk => chunk.length !== 0));
+      leftovers.ref = concatenated;
+      return concatenated;
+    };
+    const upstreamMarker = sink.readWith({
+      onInput: input => sink.flatMap(sink.write(input), () => upstreamMarker),
+      onFailure: sink.fail,
+      onDone: done => sink.zipRight(sink.sync(() => {
+        upstreamDone.ref = true;
+      }), sink.succeedNow(done))
+    });
+    const transducer = Function_dist_effectFunction.pipe(sink$1, sink.toChannel, sink.collectElements, sink.flatMap(([leftover, z]) => Function_dist_effectFunction.pipe(sink.succeed([upstreamDone.ref, concatAndGet(leftover)]), sink.flatMap(([done, newLeftovers]) => {
+      const nextChannel = done && Chunk_dist_effectChunk.isEmpty(newLeftovers) ? sink.unit : transducer;
+      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(z)), sink.flatMap(() => nextChannel));
+    }))));
+    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(upstreamMarker), sink.pipeTo(buffer), sink.pipeToOrFail(transducer));
+  });
+  return new StreamImpl(newChannel);
+});
+
+/** @internal */
+const unfold = (s, f) => unfoldChunk(s, s => Function_dist_effectFunction.pipe(f(s), Option_dist_effectOption.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s])));
+
+/** @internal */
+const unfoldChunk = (s, f) => {
+  const loop = s => Option_dist_effectOption.match(f(s), {
+    onNone: () => sink.unit,
+    onSome: ([chunk, s]) => sink.flatMap(sink.write(chunk), () => loop(s))
+  });
+  return new StreamImpl(sink.suspend(() => loop(s)));
+};
+
+/** @internal */
+const unfoldChunkEffect = (s, f) => suspend(() => {
+  const loop = s => sink.unwrap(Effect_dist_effectEffect.map(f(s), Option_dist_effectOption.match({
+    onNone: () => sink.unit,
+    onSome: ([chunk, s]) => sink.flatMap(sink.write(chunk), () => loop(s))
+  })));
+  return new StreamImpl(loop(s));
+});
+
+/** @internal */
+const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => Function_dist_effectFunction.pipe(f(s), Effect_dist_effectEffect.map(Option_dist_effectOption.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s]))));
+
+/** @internal */
+const unit = /*#__PURE__*/succeed(void 0);
+
+/** @internal */
+const unwrap = effect => flatten(fromEffect(effect));
+
+/** @internal */
+const unwrapScoped = effect => flatten(scoped(effect));
+
+/** @internal */
+const updateService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => Function_dist_effectFunction.pipe(self, mapInputContext(context => Function_dist_effectFunction.pipe(context, Context_dist_effectContext.add(tag, f(Function_dist_effectFunction.pipe(context, Context_dist_effectContext.unsafeGet(tag))))))));
+
+/** @internal */
+const when = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => Function_dist_effectFunction.pipe(self, whenEffect(Effect_dist_effectEffect.sync(predicate))));
+
+/** @internal */
+const whenCase = (evaluate, pf) => whenCaseEffect(pf)(Effect_dist_effectEffect.sync(evaluate));
+
+/** @internal */
+const whenCaseEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(fromEffect(self), flatMap(a => Function_dist_effectFunction.pipe(pf(a), Option_dist_effectOption.getOrElse(() => empty)))));
+
+/** @internal */
+const whenEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => Function_dist_effectFunction.pipe(fromEffect(effect), flatMap(bool => bool ? self : empty)));
+
+/** @internal */
+const withSpan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, name, options) => unwrapScoped(Effect_dist_effectEffect.as(Effect_dist_effectEffect.withSpanScoped(name, options), self)));
+
+/** @internal */
+const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWith(that, (a, a2) => [a, a2])));
+
+/** @internal */
+const zipFlatten = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWith(that, (a, a2) => [...a, a2])));
+
+/** @internal */
+const zipAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllWith(self, {
+  other: options.other,
+  onSelf: a => [a, options.defaultOther],
+  onOther: a2 => [options.defaultSelf, a2],
+  onBoth: (a, a2) => [a, a2]
+}));
+
+/** @internal */
+const zipAllLeft = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, defaultSelf) => zipAllWith(self, {
+  other,
+  onSelf: Function_dist_effectFunction.identity,
+  onOther: () => defaultSelf,
+  onBoth: a => a
+}));
+
+/** @internal */
+const zipAllRight = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, defaultRight) => zipAllWith(self, {
+  other,
+  onSelf: () => defaultRight,
+  onOther: Function_dist_effectFunction.identity,
+  onBoth: (_, a2) => a2
+}));
+
+/** @internal */
+const zipAllSortedByKey = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
+  other: options.other,
+  onSelf: a => [a, options.defaultOther],
+  onOther: a2 => [options.defaultSelf, a2],
+  onBoth: (a, a2) => [a, a2],
+  order: options.order
+}));
+
+/** @internal */
+const zipAllSortedByKeyLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
+  other: options.other,
+  onSelf: Function_dist_effectFunction.identity,
+  onOther: () => options.defaultSelf,
+  onBoth: a => a,
+  order: options.order
+}));
+
+/** @internal */
+const zipAllSortedByKeyRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
+  other: options.other,
+  onSelf: () => options.defaultOther,
+  onOther: Function_dist_effectFunction.identity,
+  onBoth: (_, a2) => a2,
+  order: options.order
+}));
+
+/** @internal */
+const zipAllSortedByKeyWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
+  const pull = (state, pullLeft, pullRight) => {
+    switch (state._tag) {
+      case OP_DRAIN_LEFT:
+        {
+          return Function_dist_effectFunction.pipe(pullLeft, Effect_dist_effectEffect.match({
+            onFailure: Exit_dist_effectExit.fail,
+            onSuccess: leftChunk => Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])
+          }));
+        }
+      case OP_DRAIN_RIGHT:
+        {
+          return Function_dist_effectFunction.pipe(pullRight, Effect_dist_effectEffect.match({
+            onFailure: Exit_dist_effectExit.fail,
+            onSuccess: rightChunk => Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightChunk, ([k, a2]) => [k, options.onOther(a2)]), DrainRight])
+          }));
+        }
+      case OP_PULL_BOTH$1:
+        {
+          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
+            concurrent: true
+          }), Effect_dist_effectEffect.matchEffect({
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
+            onSuccess: ([leftOption, rightOption]) => {
+              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullBoth$1, pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
+                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
+                }
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(leftOption.value, rightOption.value)));
+              }
+              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isNone(rightOption)) {
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
+                  return pull(DrainLeft, pullLeft, pullRight);
+                }
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(leftOption.value, Chunk_dist_effectChunk.map(([k, a]) => [k, options.onSelf(a)])), DrainLeft]));
+              }
+              if (Option_dist_effectOption.isNone(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
+                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(DrainRight, pullLeft, pullRight);
+                }
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(rightOption.value, Chunk_dist_effectChunk.map(([k, a2]) => [k, options.onOther(a2)])), DrainRight]));
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT$1:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullLeft, {
+            onFailure: Option_dist_effectOption.match({
+              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(state.rightChunk, Chunk_dist_effectChunk.map(([k, a2]) => [k, options.onOther(a2)])), DrainRight])),
+              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
+            }),
+            onSuccess: leftChunk => Chunk_dist_effectChunk.isEmpty(leftChunk) ? pull(PullLeft$1(state.rightChunk), pullLeft, pullRight) : Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(leftChunk, state.rightChunk)))
+          });
+        }
+      case OP_PULL_RIGHT$1:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullRight, {
+            onFailure: Option_dist_effectOption.match({
+              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])),
+              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
+            }),
+            onSuccess: rightChunk => Chunk_dist_effectChunk.isEmpty(rightChunk) ? pull(PullRight$1(state.leftChunk), pullLeft, pullRight) : Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(state.leftChunk, rightChunk)))
+          });
+        }
+    }
+  };
+  const merge = (leftChunk, rightChunk) => {
+    const hasNext = (chunk, index) => index < chunk.length - 1;
+    const builder = [];
+    let state = undefined;
+    let leftIndex = 0;
+    let rightIndex = 0;
+    let leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
+    let rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
+    let k1 = leftTuple[0];
+    let a = leftTuple[1];
+    let k2 = rightTuple[0];
+    let a2 = rightTuple[1];
+    let loop = true;
+    while (loop) {
+      const compare = options.order(k1, k2);
+      if (compare === 0) {
+        builder.push([k1, options.onBoth(a, a2)]);
+        if (hasNext(leftChunk, leftIndex) && hasNext(rightChunk, rightIndex)) {
+          leftIndex = leftIndex + 1;
+          rightIndex = rightIndex + 1;
+          leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
+          rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
+          k1 = leftTuple[0];
+          a = leftTuple[1];
+          k2 = rightTuple[0];
+          a2 = rightTuple[1];
+        } else if (hasNext(leftChunk, leftIndex)) {
+          state = PullRight$1(Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.drop(leftIndex + 1)));
+          loop = false;
+        } else if (hasNext(rightChunk, rightIndex)) {
+          state = PullLeft$1(Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.drop(rightIndex + 1)));
+          loop = false;
+        } else {
+          state = PullBoth$1;
+          loop = false;
+        }
+      } else if (compare < 0) {
+        builder.push([k1, options.onSelf(a)]);
+        if (hasNext(leftChunk, leftIndex)) {
+          leftIndex = leftIndex + 1;
+          leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
+          k1 = leftTuple[0];
+          a = leftTuple[1];
+        } else {
+          const rightBuilder = [];
+          rightBuilder.push(rightTuple);
+          while (hasNext(rightChunk, rightIndex)) {
+            rightIndex = rightIndex + 1;
+            rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
+            rightBuilder.push(rightTuple);
+          }
+          state = PullLeft$1(Chunk_dist_effectChunk.unsafeFromArray(rightBuilder));
+          loop = false;
+        }
+      } else {
+        builder.push([k2, options.onOther(a2)]);
+        if (hasNext(rightChunk, rightIndex)) {
+          rightIndex = rightIndex + 1;
+          rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
+          k2 = rightTuple[0];
+          a2 = rightTuple[1];
+        } else {
+          const leftBuilder = [];
+          leftBuilder.push(leftTuple);
+          while (hasNext(leftChunk, leftIndex)) {
+            leftIndex = leftIndex + 1;
+            leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
+            leftBuilder.push(leftTuple);
+          }
+          state = PullRight$1(Chunk_dist_effectChunk.unsafeFromArray(leftBuilder));
+          loop = false;
+        }
+      }
+    }
+    return [Chunk_dist_effectChunk.unsafeFromArray(builder), state];
+  };
+  return combineChunks(self, options.other, PullBoth$1, pull);
+});
+
+/** @internal */
+const zipAllWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
+  const pull = (state, pullLeft, pullRight) => {
+    switch (state._tag) {
+      case OP_DRAIN_LEFT:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullLeft, {
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
+            onSuccess: leftChunk => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftChunk, options.onSelf), DrainLeft]))
+          });
+        }
+      case OP_DRAIN_RIGHT:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullRight, {
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
+            onSuccess: rightChunk => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightChunk, options.onOther), DrainRight]))
+          });
+        }
+      case OP_PULL_BOTH$1:
+        {
+          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
+            concurrent: true
+          }), Effect_dist_effectEffect.matchEffect({
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
+            onSuccess: ([leftOption, rightOption]) => {
+              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullBoth$1, pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
+                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
+                }
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftOption.value, rightOption.value, options.onBoth)));
+              }
+              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isNone(rightOption)) {
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftOption.value, options.onSelf), DrainLeft]));
+              }
+              if (Option_dist_effectOption.isNone(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightOption.value, options.onOther), DrainRight]));
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT$1:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullLeft, {
+            onFailure: Option_dist_effectOption.match({
+              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.rightChunk, options.onOther), DrainRight])),
+              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
+            }),
+            onSuccess: leftChunk => {
+              if (Chunk_dist_effectChunk.isEmpty(leftChunk)) {
+                return pull(PullLeft$1(state.rightChunk), pullLeft, pullRight);
+              }
+              if (Chunk_dist_effectChunk.isEmpty(state.rightChunk)) {
+                return pull(PullRight$1(leftChunk), pullLeft, pullRight);
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftChunk, state.rightChunk, options.onBoth)));
+            }
+          });
+        }
+      case OP_PULL_RIGHT$1:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullRight, {
+            onFailure: Option_dist_effectOption.match({
+              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.leftChunk, options.onSelf), DrainLeft])),
+              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
+            }),
+            onSuccess: rightChunk => {
+              if (Chunk_dist_effectChunk.isEmpty(rightChunk)) {
+                return pull(PullRight$1(state.leftChunk), pullLeft, pullRight);
+              }
+              if (Chunk_dist_effectChunk.isEmpty(state.leftChunk)) {
+                return pull(PullLeft$1(rightChunk), pullLeft, pullRight);
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(state.leftChunk, rightChunk, options.onBoth)));
+            }
+          });
+        }
+    }
+  };
+  const zip = (leftChunk, rightChunk, f) => {
+    const [output, either] = zipChunks(leftChunk, rightChunk, f);
+    switch (either._tag) {
+      case "Left":
+        {
+          if (Chunk_dist_effectChunk.isEmpty(either.left)) {
+            return [output, PullBoth$1];
+          }
+          return [output, PullRight$1(either.left)];
+        }
+      case "Right":
+        {
+          if (Chunk_dist_effectChunk.isEmpty(either.right)) {
+            return [output, PullBoth$1];
+          }
+          return [output, PullLeft$1(either.right)];
+        }
+    }
+  };
+  return combineChunks(self, options.other, PullBoth$1, pull);
+});
+
+/** @internal */
+const zipLatest = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipLatestWith(that, (a, a2) => [a, a2])));
+
+/** @internal */
+const zipLatestWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
+  const pullNonEmpty = pull => Function_dist_effectFunction.pipe(pull, Effect_dist_effectEffect.flatMap(chunk => Chunk_dist_effectChunk.isEmpty(chunk) ? pullNonEmpty(pull) : Effect_dist_effectEffect.succeed(chunk)));
+  return Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(pullNonEmpty), Effect_dist_effectEffect.zip(Function_dist_effectFunction.pipe(toPull(that), Effect_dist_effectEffect.map(pullNonEmpty))), Effect_dist_effectEffect.flatMap(([left, right]) => Function_dist_effectFunction.pipe(fromEffectOption(Effect_dist_effectEffect.raceWith(left, right, {
+    onSelfDone: (leftDone, rightFiber) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => leftDone), Effect_dist_effectEffect.zipWith(Fiber_dist_effectFiber.join(rightFiber), (l, r) => [l, r, true])),
+    onOtherDone: (rightDone, leftFiber) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => rightDone), Effect_dist_effectEffect.zipWith(Fiber_dist_effectFiber.join(leftFiber), (l, r) => [r, l, false]))
+  })), flatMap(([l, r, leftFirst]) => Function_dist_effectFunction.pipe(fromEffect(Ref_dist_effectRef.make([Chunk_dist_effectChunk.unsafeLast(l), Chunk_dist_effectChunk.unsafeLast(r)])), flatMap(latest => Function_dist_effectFunction.pipe(fromChunk(leftFirst ? Function_dist_effectFunction.pipe(r, Chunk_dist_effectChunk.map(a2 => f(Chunk_dist_effectChunk.unsafeLast(l), a2))) : Function_dist_effectFunction.pipe(l, Chunk_dist_effectChunk.map(a => f(a, Chunk_dist_effectChunk.unsafeLast(r))))), concat(Function_dist_effectFunction.pipe(repeatEffectOption(left), mergeEither(repeatEffectOption(right)), mapEffectSequential(Either_dist_effectEither.match({
+    onLeft: leftChunk => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(latest, ([_, rightLatest]) => [Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.map(a => f(a, rightLatest))), [Chunk_dist_effectChunk.unsafeLast(leftChunk), rightLatest]])),
+    onRight: rightChunk => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(latest, ([leftLatest, _]) => [Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.map(a2 => f(leftLatest, a2))), [leftLatest, Chunk_dist_effectChunk.unsafeLast(rightChunk)]]))
+  })), flatMap(fromChunk))))))), toPull)), fromPull);
+});
+
+/** @internal */
+const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (left, right) => {
+  if (left.length > right.length) {
+    return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)), Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)))];
+  }
+  return [left, Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
+})));
+
+/** @internal */
+const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (left, right) => {
+  if (left.length > right.length) {
+    return [right, Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)))];
+  }
+  return [Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.take(left.length)), Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
+})));
+
+/** @internal */
+const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (leftChunk, rightChunk) => zipChunks(leftChunk, rightChunk, f))));
+
+/** @internal */
+const zipWithChunks = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
+  const pull = (state, pullLeft, pullRight) => {
+    switch (state._tag) {
+      case OP_PULL_BOTH:
+        {
+          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
+            concurrent: true
+          }), Effect_dist_effectEffect.matchEffect({
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
+            onSuccess: ([leftOption, rightOption]) => {
+              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullBoth, pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
+                  return pull(PullLeft(rightOption.value), pullLeft, pullRight);
+                }
+                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
+                  return pull(PullRight(leftOption.value), pullLeft, pullRight);
+                }
+                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftOption.value, rightOption.value)));
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullLeft, {
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
+            onSuccess: leftChunk => {
+              if (Chunk_dist_effectChunk.isEmpty(leftChunk)) {
+                return pull(PullLeft(state.rightChunk), pullLeft, pullRight);
+              }
+              if (Chunk_dist_effectChunk.isEmpty(state.rightChunk)) {
+                return pull(PullRight(leftChunk), pullLeft, pullRight);
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftChunk, state.rightChunk)));
+            }
+          });
+        }
+      case OP_PULL_RIGHT:
+        {
+          return Effect_dist_effectEffect.matchEffect(pullRight, {
+            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
+            onSuccess: rightChunk => {
+              if (Chunk_dist_effectChunk.isEmpty(rightChunk)) {
+                return pull(PullRight(state.leftChunk), pullLeft, pullRight);
+              }
+              if (Chunk_dist_effectChunk.isEmpty(state.leftChunk)) {
+                return pull(PullLeft(rightChunk), pullLeft, pullRight);
+              }
+              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(state.leftChunk, rightChunk)));
+            }
+          });
+        }
+    }
+  };
+  const zip = (leftChunk, rightChunk) => {
+    const [output, either] = f(leftChunk, rightChunk);
+    switch (either._tag) {
+      case "Left":
+        {
+          if (Chunk_dist_effectChunk.isEmpty(either.left)) {
+            return [output, PullBoth];
+          }
+          return [output, PullRight(either.left)];
+        }
+      case "Right":
+        {
+          if (Chunk_dist_effectChunk.isEmpty(either.right)) {
+            return [output, PullBoth];
+          }
+          return [output, PullLeft(either.right)];
+        }
+    }
+  };
+  return Function_dist_effectFunction.pipe(self, combineChunks(that, PullBoth, pull));
+});
+
+/** @internal */
+const zipWithIndex = self => Function_dist_effectFunction.pipe(self, mapAccum(0, (index, a) => [index + 1, [a, index]]));
+
+/** @internal */
+const zipWithNext = self => {
+  const process = last => sink.readWithCause({
+    onInput: input => {
+      const [newLast, chunk] = Chunk_dist_effectChunk.mapAccum(input, last, (prev, curr) => [Option_dist_effectOption.some(curr), Function_dist_effectFunction.pipe(prev, Option_dist_effectOption.map(a => [a, curr]))]);
+      const output = Chunk_dist_effectChunk.filterMap(chunk, option => Option_dist_effectOption.isSome(option) ? Option_dist_effectOption.some([option.value[0], Option_dist_effectOption.some(option.value[1])]) : Option_dist_effectOption.none());
+      return sink.flatMap(sink.write(output), () => process(newLast));
+    },
+    onFailure: sink.failCause,
+    onDone: () => Option_dist_effectOption.match(last, {
+      onNone: () => sink.unit,
+      onSome: value => sink.zipRight(sink.write(Chunk_dist_effectChunk.of([value, Option_dist_effectOption.none()])), sink.unit)
+    })
+  });
+  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(process(Option_dist_effectOption.none()))));
+};
+
+/** @internal */
+const zipWithPrevious = self => Function_dist_effectFunction.pipe(self, mapAccum(Option_dist_effectOption.none(), (prev, curr) => [Option_dist_effectOption.some(curr), [prev, curr]]));
+
+/** @internal */
+const zipWithPreviousAndNext = self => Function_dist_effectFunction.pipe(zipWithNext(zipWithPrevious(self)), map(([[prev, curr], next]) => [prev, curr, Function_dist_effectFunction.pipe(next, Option_dist_effectOption.map(tuple => tuple[1]))]));
+
+/** @internal */
+const zipChunks = (left, right, f) => {
+  if (left.length > right.length) {
+    return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length), Chunk_dist_effectChunk.zipWith(right, f)), Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.drop(right.length)))];
+  }
+  return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.zipWith(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.take(left.length)), f)), Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
+};
+
+// Do notation
+
+/** @internal */
+const Do = /*#__PURE__*/succeed({});
+
+/** @internal */
+const bind = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, tag, f, options) => flatMap(self, k => map(f(k), a => ({
+  ...k,
+  [tag]: a
+})), options));
+
+/* @internal */
+const bindTo = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, tag) => map(self, a => ({
+  [tag]: a
+})));
+
+/* @internal */
+const let_ = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => map(self, k => ({
+  ...k,
+  [tag]: f(k)
+})));
+
+// Circular with Channel
+
+/** @internal */
+const channelToStream = self => {
+  return new StreamImpl(self);
+};
+
+// =============================================================================
+// encoding
+// =============================================================================
+
+/** @internal */
+const decodeText = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, encoding = "utf-8") => suspend(() => {
+  const decoder = new TextDecoder(encoding);
+  return map(self, s => decoder.decode(s));
+}));
+
+/** @internal */
+const encodeText = self => suspend(() => {
+  const encoder = new TextEncoder();
+  return map(self, s => encoder.encode(s));
+});
+
+exports.DefaultChunkSize = DefaultChunkSize;
+exports.Do = Do;
+exports.StreamTypeId = StreamTypeId;
+exports._async = _async;
+exports.acquireRelease = acquireRelease;
+exports.aggregate = aggregate;
+exports.aggregateWithin = aggregateWithin;
+exports.aggregateWithinEither = aggregateWithinEither;
+exports.as = as;
+exports.asyncEffect = asyncEffect;
+exports.asyncInterrupt = asyncInterrupt;
+exports.asyncOption = asyncOption;
+exports.asyncScoped = asyncScoped;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.branchAfter = branchAfter;
+exports.broadcast = broadcast;
+exports.broadcastDynamic = broadcastDynamic;
+exports.broadcastedQueues = broadcastedQueues;
+exports.broadcastedQueuesDynamic = broadcastedQueuesDynamic;
+exports.buffer = buffer;
+exports.bufferChunks = bufferChunks;
+exports.catchAll = catchAll;
+exports.catchAllCause = catchAllCause;
+exports.catchSome = catchSome;
+exports.catchSomeCause = catchSomeCause;
+exports.catchTag = catchTag;
+exports.catchTags = catchTags;
+exports.changes = changes;
+exports.changesWith = changesWith;
+exports.changesWithEffect = changesWithEffect;
+exports.channelToStream = channelToStream;
+exports.chunks = chunks;
+exports.chunksWith = chunksWith;
+exports.combine = combine;
+exports.combineChunks = combineChunks;
+exports.concat = concat;
+exports.concatAll = concatAll;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithEffect = contextWithEffect;
+exports.contextWithStream = contextWithStream;
+exports.cross = cross;
+exports.crossLeft = crossLeft;
+exports.crossRight = crossRight;
+exports.crossWith = crossWith;
+exports.debounce = debounce;
+exports.decodeText = decodeText;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.distributedWith = distributedWith;
+exports.distributedWithDynamic = distributedWithDynamic;
+exports.distributedWithDynamicCallback = distributedWithDynamicCallback;
+exports.drain = drain;
+exports.drainFork = drainFork;
+exports.drop = drop;
+exports.dropRight = dropRight;
+exports.dropUntil = dropUntil;
+exports.dropUntilEffect = dropUntilEffect;
+exports.dropWhile = dropWhile;
+exports.dropWhileEffect = dropWhileEffect;
+exports.either = either;
+exports.empty = empty;
+exports.encodeText = encodeText;
+exports.ensuring = ensuring;
+exports.ensuringWith = ensuringWith;
+exports.execute = execute;
+exports.fail = fail;
+exports.failCause = failCause;
+exports.failCauseSync = failCauseSync;
+exports.failSync = failSync;
+exports.filter = filter;
+exports.filterEffect = filterEffect;
+exports.filterMap = filterMap;
+exports.filterMapEffect = filterMapEffect;
+exports.filterMapWhile = filterMapWhile;
+exports.filterMapWhileEffect = filterMapWhileEffect;
+exports.finalizer = finalizer;
+exports.find = find;
+exports.findEffect = findEffect;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flattenChunks = flattenChunks;
+exports.flattenEffect = flattenEffect;
+exports.flattenExitOption = flattenExitOption;
+exports.flattenIterables = flattenIterables;
+exports.flattenTake = flattenTake;
+exports.forever = forever;
+exports.fromAsyncIterable = fromAsyncIterable;
+exports.fromChannel = fromChannel;
+exports.fromChunk = fromChunk;
+exports.fromChunkHub = fromChunkHub;
+exports.fromChunkQueue = fromChunkQueue;
+exports.fromChunks = fromChunks;
+exports.fromEffect = fromEffect;
+exports.fromEffectOption = fromEffectOption;
+exports.fromHub = fromHub;
+exports.fromIterable = fromIterable;
+exports.fromIterableEffect = fromIterableEffect;
+exports.fromIteratorSucceed = fromIteratorSucceed;
+exports.fromPull = fromPull;
+exports.fromQueue = fromQueue;
+exports.fromReadableStream = fromReadableStream;
+exports.fromReadableStreamByob = fromReadableStreamByob;
+exports.fromSchedule = fromSchedule;
+exports.groupAdjacentBy = groupAdjacentBy;
+exports.grouped = grouped;
+exports.groupedWithin = groupedWithin;
+exports.haltAfter = haltAfter;
+exports.haltWhen = haltWhen;
+exports.haltWhenDeferred = haltWhenDeferred;
+exports.identityStream = identityStream;
+exports.interleave = interleave;
+exports.interleaveWith = interleaveWith;
+exports.interruptAfter = interruptAfter;
+exports.interruptWhen = interruptWhen;
+exports.interruptWhenDeferred = interruptWhenDeferred;
+exports.intersperse = intersperse;
+exports.intersperseAffixes = intersperseAffixes;
+exports.iterate = iterate;
+exports.let_ = let_;
+exports.make = make;
+exports.map = map;
+exports.mapAccum = mapAccum;
+exports.mapAccumEffect = mapAccumEffect;
+exports.mapBoth = mapBoth;
+exports.mapChunks = mapChunks;
+exports.mapChunksEffect = mapChunksEffect;
+exports.mapConcat = mapConcat;
+exports.mapConcatChunk = mapConcatChunk;
+exports.mapConcatChunkEffect = mapConcatChunkEffect;
+exports.mapConcatEffect = mapConcatEffect;
+exports.mapEffectPar = mapEffectPar;
+exports.mapEffectSequential = mapEffectSequential;
+exports.mapError = mapError;
+exports.mapErrorCause = mapErrorCause;
+exports.mapInputContext = mapInputContext;
+exports.matchConcurrency = matchConcurrency;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.mergeEither = mergeEither;
+exports.mergeLeft = mergeLeft;
+exports.mergeRight = mergeRight;
+exports.mergeWith = mergeWith;
+exports.mkString = mkString;
+exports.never = never;
+exports.onDone = onDone;
+exports.onError = onError;
+exports.orDie = orDie;
+exports.orDieWith = orDieWith;
+exports.orElse = orElse;
+exports.orElseEither = orElseEither;
+exports.orElseFail = orElseFail;
+exports.orElseIfEmpty = orElseIfEmpty;
+exports.orElseIfEmptyChunk = orElseIfEmptyChunk;
+exports.orElseIfEmptyStream = orElseIfEmptyStream;
+exports.orElseSucceed = orElseSucceed;
+exports.paginate = paginate;
+exports.paginateChunk = paginateChunk;
+exports.paginateChunkEffect = paginateChunkEffect;
+exports.paginateEffect = paginateEffect;
+exports.partition = partition;
+exports.partitionEither = partitionEither;
+exports.peel = peel;
+exports.pipeThrough = pipeThrough;
+exports.pipeThroughChannel = pipeThroughChannel;
+exports.pipeThroughChannelOrFail = pipeThroughChannelOrFail;
+exports.prepend = prepend;
+exports.provideContext = provideContext;
+exports.provideLayer = provideLayer;
+exports.provideService = provideService;
+exports.provideServiceEffect = provideServiceEffect;
+exports.provideServiceStream = provideServiceStream;
+exports.provideSomeLayer = provideSomeLayer;
+exports.range = range;
+exports.rechunk = rechunk;
+exports.refineOrDie = refineOrDie;
+exports.refineOrDieWith = refineOrDieWith;
+exports.repeat = repeat;
+exports.repeatEffect = repeatEffect;
+exports.repeatEffectChunk = repeatEffectChunk;
+exports.repeatEffectChunkOption = repeatEffectChunkOption;
+exports.repeatEffectOption = repeatEffectOption;
+exports.repeatEffectWithSchedule = repeatEffectWithSchedule;
+exports.repeatEither = repeatEither;
+exports.repeatElements = repeatElements;
+exports.repeatElementsWith = repeatElementsWith;
+exports.repeatValue = repeatValue;
+exports.repeatWith = repeatWith;
+exports.retry = retry;
+exports.run = run;
+exports.runCollect = runCollect;
+exports.runCount = runCount;
+exports.runDrain = runDrain;
+exports.runFold = runFold;
+exports.runFoldEffect = runFoldEffect;
+exports.runFoldScoped = runFoldScoped;
+exports.runFoldScopedEffect = runFoldScopedEffect;
+exports.runFoldWhile = runFoldWhile;
+exports.runFoldWhileEffect = runFoldWhileEffect;
+exports.runFoldWhileScoped = runFoldWhileScoped;
+exports.runFoldWhileScopedEffect = runFoldWhileScopedEffect;
+exports.runForEach = runForEach;
+exports.runForEachChunk = runForEachChunk;
+exports.runForEachChunkScoped = runForEachChunkScoped;
+exports.runForEachScoped = runForEachScoped;
+exports.runForEachWhile = runForEachWhile;
+exports.runForEachWhileScoped = runForEachWhileScoped;
+exports.runHead = runHead;
+exports.runIntoHub = runIntoHub;
+exports.runIntoHubScoped = runIntoHubScoped;
+exports.runIntoQueue = runIntoQueue;
+exports.runIntoQueueElementsScoped = runIntoQueueElementsScoped;
+exports.runIntoQueueScoped = runIntoQueueScoped;
+exports.runLast = runLast;
+exports.runScoped = runScoped;
+exports.runSum = runSum;
+exports.scan = scan;
+exports.scanEffect = scanEffect;
+exports.scanReduce = scanReduce;
+exports.scanReduceEffect = scanReduceEffect;
+exports.schedule = schedule;
+exports.scheduleWith = scheduleWith;
+exports.scoped = scoped;
+exports.sliding = sliding;
+exports.slidingSize = slidingSize;
+exports.some = some;
+exports.someOrElse = someOrElse;
+exports.someOrFail = someOrFail;
+exports.split = split;
+exports.splitLines = splitLines;
+exports.splitOnChunk = splitOnChunk;
+exports.succeed = succeed;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.take = take;
+exports.takeRight = takeRight;
+exports.takeUntil = takeUntil;
+exports.takeUntilEffect = takeUntilEffect;
+exports.takeWhile = takeWhile;
+exports.tap = tap;
+exports.tapBoth = tapBoth;
+exports.tapError = tapError;
+exports.tapErrorCause = tapErrorCause;
+exports.tapSink = tapSink;
+exports.throttle = throttle;
+exports.throttleEffect = throttleEffect;
+exports.tick = tick;
+exports.timeout = timeout;
+exports.timeoutFail = timeoutFail;
+exports.timeoutFailCause = timeoutFailCause;
+exports.timeoutTo = timeoutTo;
+exports.toChannel = toChannel;
+exports.toHub = toHub;
+exports.toPull = toPull;
+exports.toQueue = toQueue;
+exports.toQueueOfElements = toQueueOfElements;
+exports.toReadableStream = toReadableStream;
+exports.transduce = transduce;
+exports.unfold = unfold;
+exports.unfoldChunk = unfoldChunk;
+exports.unfoldChunkEffect = unfoldChunkEffect;
+exports.unfoldEffect = unfoldEffect;
+exports.unit = unit;
+exports.unwrap = unwrap;
+exports.unwrapScoped = unwrapScoped;
+exports.updateService = updateService;
+exports.when = when;
+exports.whenCase = whenCase;
+exports.whenCaseEffect = whenCaseEffect;
+exports.whenEffect = whenEffect;
+exports.withSpan = withSpan;
+exports.zip = zip;
+exports.zipAll = zipAll;
+exports.zipAllLeft = zipAllLeft;
+exports.zipAllRight = zipAllRight;
+exports.zipAllSortedByKey = zipAllSortedByKey;
+exports.zipAllSortedByKeyLeft = zipAllSortedByKeyLeft;
+exports.zipAllSortedByKeyRight = zipAllSortedByKeyRight;
+exports.zipAllSortedByKeyWith = zipAllSortedByKeyWith;
+exports.zipAllWith = zipAllWith;
+exports.zipFlatten = zipFlatten;
+exports.zipLatest = zipLatest;
+exports.zipLatestWith = zipLatestWith;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;
+exports.zipWithChunks = zipWithChunks;
+exports.zipWithIndex = zipWithIndex;
+exports.zipWithNext = zipWithNext;
+exports.zipWithPrevious = zipWithPrevious;
+exports.zipWithPreviousAndNext = zipWithPreviousAndNext;