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

package/dist/sink-05d54662.cjs.prod.js

@@ -1,3094 +0,0 @@
-'use strict';
-
-var Cause_dist_effectCause = require('./Cause-b769f517.cjs.prod.js');
-var Chunk_dist_effectChunk = require('./Chunk-f001938d.cjs.prod.js');
-var Clock_dist_effectClock = require('./Clock-27c1110d.cjs.prod.js');
-var Duration_dist_effectDuration = require('./Duration-205d0b80.cjs.prod.js');
-var Effect_dist_effectEffect = require('./Effect-6713972b.cjs.prod.js');
-var Either_dist_effectEither = require('./Either-d995ebb4.cjs.prod.js');
-var Exit_dist_effectExit = require('./Exit-eb04f98e.cjs.prod.js');
-var Function_dist_effectFunction = require('./Function-8336aeeb.cjs.prod.js');
-var HashMap_dist_effectHashMap = require('./HashMap-2604a8b0.cjs.prod.js');
-var HashSet_dist_effectHashSet = require('./HashSet-99f1529e.cjs.prod.js');
-var Hub_dist_effectHub = require('./Hub-4223bb07.cjs.prod.js');
-var Option_dist_effectOption = require('./Option-b07f2b1d.cjs.prod.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-856ddd7c.cjs.prod.js');
-var Queue_dist_effectQueue = require('./Queue-9f8579c0.cjs.prod.js');
-var ReadonlyArray_dist_effectReadonlyArray = require('./ReadonlyArray-6fbc78a1.cjs.prod.js');
-var Ref_dist_effectRef = require('./Ref-88c1d56d.cjs.prod.js');
-var Context_dist_effectContext = require('./Context-119d62eb.cjs.prod.js');
-var Deferred_dist_effectDeferred = require('./Deferred-77579e00.cjs.prod.js');
-var Equal_dist_effectEqual = require('./Equal-ed1e8c3c.cjs.prod.js');
-var Fiber_dist_effectFiber = require('./Fiber-a7306b77.cjs.prod.js');
-var Layer_dist_effectLayer = require('./Layer-79fa5f4a.cjs.prod.js');
-var Scope_dist_effectScope = require('./Scope-326194e2.cjs.prod.js');
-var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-080f0b2b.cjs.prod.js');
-var childExecutorDecision = require('./childExecutorDecision-744cd5fb.cjs.prod.js');
-var upstreamPullStrategy = require('./upstreamPullStrategy-08e7185f.cjs.prod.js');
-var upstreamPullRequest = require('./upstreamPullRequest-d2eaf7f5.cjs.prod.js');
-var mergeDecision = require('./mergeDecision-a1822db2.cjs.prod.js');
-var mergeState = require('./mergeState-2c24c562.cjs.prod.js');
-var mergeStrategy = require('./mergeStrategy-909bebb0.cjs.prod.js');
-var singleProducerAsyncInput = require('./singleProducerAsyncInput-d3225b4e.cjs.prod.js');
-
-/** @internal */
-const OP_CONTINUATION_K = "ContinuationK";
-
-/** @internal */
-
-/** @internal */
-const OP_CONTINUATION_FINALIZER = "ContinuationFinalizer";
-
-/** @internal */
-
-/** @internal */
-const ContinuationTypeId = /*#__PURE__*/Symbol.for("effect/ChannelContinuation");
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const continuationVariance = {
-  _Env: _ => _,
-  _InErr: _ => _,
-  _InElem: _ => _,
-  _InDone: _ => _,
-  _OutErr: _ => _,
-  _OutDone: _ => _,
-  _OutErr2: _ => _,
-  _OutElem: _ => _,
-  _OutDone2: _ => _
-};
-
-/** @internal */
-class ContinuationKImpl {
-  _tag = OP_CONTINUATION_K;
-  [ContinuationTypeId] = continuationVariance;
-  constructor(onSuccess, onHalt) {
-    this.onSuccess = onSuccess;
-    this.onHalt = onHalt;
-  }
-  onExit(exit) {
-    return Exit_dist_effectExit.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value);
-  }
-}
-
-/** @internal */
-class ContinuationFinalizerImpl {
-  _tag = OP_CONTINUATION_FINALIZER;
-  [ContinuationTypeId] = continuationVariance;
-  constructor(finalizer) {
-    this.finalizer = finalizer;
-  }
-}
-
-/** @internal */
-const OP_BRACKET_OUT = "BracketOut";
-
-/** @internal */
-
-/** @internal */
-const OP_BRIDGE = "Bridge";
-
-/** @internal */
-
-/** @internal */
-const OP_CONCAT_ALL = "ConcatAll";
-
-/** @internal */
-
-/** @internal */
-const OP_EMIT$2 = "Emit";
-
-/** @internal */
-
-/** @internal */
-const OP_ENSURING = "Ensuring";
-
-/** @internal */
-
-/** @internal */
-const OP_FAIL = "Fail";
-
-/** @internal */
-
-/** @internal */
-const OP_FOLD = "Fold";
-
-/** @internal */
-
-/** @internal */
-const OP_FROM_EFFECT$1 = "FromEffect";
-
-/** @internal */
-
-/** @internal */
-const OP_PIPE_TO = "PipeTo";
-
-/** @internal */
-
-/** @internal */
-const OP_PROVIDE = "Provide";
-
-/** @internal */
-
-/** @internal */
-const OP_READ$1 = "Read";
-
-/** @internal */
-
-/** @internal */
-const OP_SUCCEED = "Succeed";
-
-/** @internal */
-
-/** @internal */
-const OP_SUCCEED_NOW = "SucceedNow";
-
-/** @internal */
-
-/** @internal */
-const OP_SUSPEND = "Suspend";
-
-/** @internal */
-
-/** @internal */
-const ChannelSymbolKey = "effect/Channel";
-
-/** @internal */
-const ChannelTypeId = /*#__PURE__*/Symbol.for(ChannelSymbolKey);
-
-/** @internal */
-const channelVariance = {
-  _Env: _ => _,
-  _InErr: _ => _,
-  _InElem: _ => _,
-  _InDone: _ => _,
-  _OutErr: _ => _,
-  _OutElem: _ => _,
-  _OutDone: _ => _
-};
-
-/** @internal */
-const proto$1 = {
-  [ChannelTypeId]: channelVariance,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const isChannel = u => typeof u === "object" && u != null && ChannelTypeId in u || Effect_dist_effectEffect.isEffect(u);
-
-/** @internal */
-const acquireReleaseOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, release) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_BRACKET_OUT;
-  op.acquire = () => self;
-  op.finalizer = release;
-  return op;
-});
-
-/** @internal */
-const catchAllCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_FOLD;
-  op.channel = self;
-  op.k = new ContinuationKImpl(succeed$1, f);
-  return op;
-});
-
-/** @internal */
-const collectElements = self => {
-  return suspend$1(() => {
-    const builder = [];
-    return flatMap$1(pipeTo(self, collectElementsReader(builder)), value => sync$1(() => [Chunk_dist_effectChunk.fromIterable(builder), value]));
-  });
-};
-
-/** @internal */
-const collectElementsReader = builder => readWith({
-  onInput: outElem => flatMap$1(sync$1(() => {
-    builder.push(outElem);
-  }), () => collectElementsReader(builder)),
-  onFailure: fail$1,
-  onDone: succeedNow
-});
-
-/** @internal */
-const concatAll = channels => concatAllWith(channels, Function_dist_effectFunction.constVoid, Function_dist_effectFunction.constVoid);
-
-/** @internal */
-const concatAllWith = (channels, f, g) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_CONCAT_ALL;
-  op.combineInners = f;
-  op.combineAll = g;
-  op.onPull = () => upstreamPullStrategy.PullAfterNext(Option_dist_effectOption.none());
-  op.onEmit = () => childExecutorDecision.Continue;
-  op.value = () => channels;
-  op.k = Function_dist_effectFunction.identity;
-  return op;
-};
-
-/** @internal */
-const concatMapWith = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, f, g, h) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_CONCAT_ALL;
-  op.combineInners = g;
-  op.combineAll = h;
-  op.onPull = () => upstreamPullStrategy.PullAfterNext(Option_dist_effectOption.none());
-  op.onEmit = () => childExecutorDecision.Continue;
-  op.value = () => self;
-  op.k = f;
-  return op;
-});
-
-/** @internal */
-const concatMapWithCustom = /*#__PURE__*/Function_dist_effectFunction.dual(6, (self, f, g, h, onPull, onEmit) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_CONCAT_ALL;
-  op.combineInners = g;
-  op.combineAll = h;
-  op.onPull = onPull;
-  op.onEmit = onEmit;
-  op.value = () => self;
-  op.k = f;
-  return op;
-});
-
-/** @internal */
-const embedInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, input) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_BRIDGE;
-  op.input = input;
-  op.channel = self;
-  return op;
-});
-
-/** @internal */
-const ensuringWith$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_ENSURING;
-  op.channel = self;
-  op.finalizer = finalizer;
-  return op;
-});
-
-/** @internal */
-const fail$1 = error => failCause$1(Cause_dist_effectCause.fail(error));
-
-/** @internal */
-const failSync$1 = evaluate => failCauseSync$1(() => Cause_dist_effectCause.fail(evaluate()));
-
-/** @internal */
-const failCause$1 = cause => failCauseSync$1(() => cause);
-
-/** @internal */
-const failCauseSync$1 = evaluate => {
-  const op = Object.create(proto$1);
-  op._tag = OP_FAIL;
-  op.error = evaluate;
-  return op;
-};
-
-/** @internal */
-const flatMap$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_FOLD;
-  op.channel = self;
-  op.k = new ContinuationKImpl(f, failCause$1);
-  return op;
-});
-
-/** @internal */
-const foldCauseChannel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_FOLD;
-  op.channel = self;
-  op.k = new ContinuationKImpl(options.onSuccess, options.onFailure);
-  return op;
-});
-
-/** @internal */
-const fromEffect$1 = effect => {
-  const op = Object.create(proto$1);
-  op._tag = OP_FROM_EFFECT$1;
-  op.effect = () => effect;
-  return op;
-};
-
-/** @internal */
-const pipeTo = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_PIPE_TO;
-  op.left = () => self;
-  op.right = () => that;
-  return op;
-});
-
-/** @internal */
-const provideContext$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, env) => {
-  const op = Object.create(proto$1);
-  op._tag = OP_PROVIDE;
-  op.context = () => env;
-  op.inner = self;
-  return op;
-});
-
-/** @internal */
-const readOrFail = error => {
-  const op = Object.create(proto$1);
-  op._tag = OP_READ$1;
-  op.more = succeed$1;
-  op.done = new ContinuationKImpl(() => fail$1(error), () => fail$1(error));
-  return op;
-};
-
-/** @internal */
-const readWith = options => readWithCause({
-  onInput: options.onInput,
-  onFailure: cause => Either_dist_effectEither.match(Cause_dist_effectCause.failureOrCause(cause), {
-    onLeft: options.onFailure,
-    onRight: failCause$1
-  }),
-  onDone: options.onDone
-});
-
-/** @internal */
-const readWithCause = options => {
-  const op = Object.create(proto$1);
-  op._tag = OP_READ$1;
-  op.more = options.onInput;
-  op.done = new ContinuationKImpl(options.onDone, options.onFailure);
-  return op;
-};
-
-/** @internal */
-const succeed$1 = value => sync$1(() => value);
-
-/** @internal */
-const succeedNow = result => {
-  const op = Object.create(proto$1);
-  op._tag = OP_SUCCEED_NOW;
-  op.terminal = result;
-  return op;
-};
-
-/** @internal */
-const suspend$1 = evaluate => {
-  const op = Object.create(proto$1);
-  op._tag = OP_SUSPEND;
-  op.channel = evaluate;
-  return op;
-};
-const sync$1 = evaluate => {
-  const op = Object.create(proto$1);
-  op._tag = OP_SUCCEED;
-  op.evaluate = evaluate;
-  return op;
-};
-
-/** @internal */
-const unit = /*#__PURE__*/succeedNow(void 0);
-
-/** @internal */
-const write = out => {
-  const op = Object.create(proto$1);
-  op._tag = OP_EMIT$2;
-  op.out = out;
-  return op;
-};
-
-/** @internal */
-const OP_DONE = "Done";
-
-/** @internal */
-
-/** @internal */
-const OP_EMIT$1 = "Emit";
-
-/** @internal */
-
-/** @internal */
-const OP_FROM_EFFECT = "FromEffect";
-
-/** @internal */
-
-/** @internal */
-const OP_READ = "Read";
-
-/** @internal */
-
-/** @internal */
-const ChannelStateTypeId = /*#__PURE__*/Symbol.for("effect/ChannelState");
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const channelStateVariance = {
-  _R: _ => _,
-  _E: _ => _
-};
-
-/** @internal */
-const proto = {
-  [ChannelStateTypeId]: channelStateVariance
-};
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const Done = () => {
-  const op = Object.create(proto);
-  op._tag = OP_DONE;
-  return op;
-};
-
-/** @internal */
-const Emit$1 = () => {
-  const op = Object.create(proto);
-  op._tag = OP_EMIT$1;
-  return op;
-};
-
-/** @internal */
-const FromEffect = effect => {
-  const op = Object.create(proto);
-  op._tag = OP_FROM_EFFECT;
-  op.effect = effect;
-  return op;
-};
-
-/** @internal */
-const Read = (upstream, onEffect, onEmit, onDone) => {
-  const op = Object.create(proto);
-  op._tag = OP_READ;
-  op.upstream = upstream;
-  op.onEffect = onEffect;
-  op.onEmit = onEmit;
-  op.onDone = onDone;
-  return op;
-};
-
-/** @internal */
-const isFromEffect = self => self._tag === OP_FROM_EFFECT;
-
-/** @internal */
-const effect = self => isFromEffect(self) ? self.effect : Effect_dist_effectEffect.unit;
-
-/** @internal */
-const effectOrUndefinedIgnored = self => isFromEffect(self) ? Effect_dist_effectEffect.ignore(self.effect) : undefined;
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_FROM_CHILD = "PullFromChild";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_FROM_UPSTREAM = "PullFromUpstream";
-
-/** @internal */
-
-/** @internal */
-const OP_DRAIN_CHILD_EXECUTORS = "DrainChildExecutors";
-
-/** @internal */
-
-/** @internal */
-const OP_EMIT = "Emit";
-
-/** @internal */
-
-/**
- * Execute the `childExecutor` and on each emitted value, decide what to do by
- * `onEmit`.
- *
- * @internal
- */
-class PullFromChild {
-  _tag = OP_PULL_FROM_CHILD;
-  constructor(childExecutor, parentSubexecutor, onEmit) {
-    this.childExecutor = childExecutor;
-    this.parentSubexecutor = parentSubexecutor;
-    this.onEmit = onEmit;
-  }
-  close(exit) {
-    const fin1 = this.childExecutor.close(exit);
-    const fin2 = this.parentSubexecutor.close(exit);
-    if (fin1 !== undefined && fin2 !== undefined) {
-      return Effect_dist_effectEffect.zipWith(Effect_dist_effectEffect.exit(fin1), Effect_dist_effectEffect.exit(fin2), (exit1, exit2) => Function_dist_effectFunction.pipe(exit1, Exit_dist_effectExit.zipRight(exit2)));
-    } else if (fin1 !== undefined) {
-      return fin1;
-    } else if (fin2 !== undefined) {
-      return fin2;
-    } else {
-      return undefined;
-    }
-  }
-  enqueuePullFromChild(_child) {
-    return this;
-  }
-}
-
-/**
- * Execute `upstreamExecutor` and for each emitted element, spawn a child
- * channel and continue with processing it by `PullFromChild`.
- *
- * @internal
- */
-class PullFromUpstream {
-  _tag = OP_PULL_FROM_UPSTREAM;
-  constructor(upstreamExecutor, createChild, lastDone, activeChildExecutors, combineChildResults, combineWithChildResult, onPull, onEmit) {
-    this.upstreamExecutor = upstreamExecutor;
-    this.createChild = createChild;
-    this.lastDone = lastDone;
-    this.activeChildExecutors = activeChildExecutors;
-    this.combineChildResults = combineChildResults;
-    this.combineWithChildResult = combineWithChildResult;
-    this.onPull = onPull;
-    this.onEmit = onEmit;
-  }
-  close(exit) {
-    const fin1 = this.upstreamExecutor.close(exit);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return Effect_dist_effectEffect.zipWith(acc, Effect_dist_effectEffect.exit(next), (exit1, exit2) => Exit_dist_effectExit.zipRight(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return Effect_dist_effectEffect.exit(next);
-      } else {
-        return undefined;
-      }
-    }, undefined);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(child) {
-    return new PullFromUpstream(this.upstreamExecutor, this.createChild, this.lastDone, [...this.activeChildExecutors, child], this.combineChildResults, this.combineWithChildResult, this.onPull, this.onEmit);
-  }
-}
-
-/**
- * Transformed from `PullFromUpstream` when upstream has finished but there
- * are still active child executors.
- *
- * @internal
- */
-class DrainChildExecutors {
-  _tag = OP_DRAIN_CHILD_EXECUTORS;
-  constructor(upstreamExecutor, lastDone, activeChildExecutors, upstreamDone, combineChildResults, combineWithChildResult, onPull) {
-    this.upstreamExecutor = upstreamExecutor;
-    this.lastDone = lastDone;
-    this.activeChildExecutors = activeChildExecutors;
-    this.upstreamDone = upstreamDone;
-    this.combineChildResults = combineChildResults;
-    this.combineWithChildResult = combineWithChildResult;
-    this.onPull = onPull;
-  }
-  close(exit) {
-    const fin1 = this.upstreamExecutor.close(exit);
-    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit) : undefined), fin1];
-    const result = fins.reduce((acc, next) => {
-      if (acc !== undefined && next !== undefined) {
-        return Effect_dist_effectEffect.zipWith(acc, Effect_dist_effectEffect.exit(next), (exit1, exit2) => Exit_dist_effectExit.zipRight(exit1, exit2));
-      } else if (acc !== undefined) {
-        return acc;
-      } else if (next !== undefined) {
-        return Effect_dist_effectEffect.exit(next);
-      } else {
-        return undefined;
-      }
-    }, undefined);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(child) {
-    return new DrainChildExecutors(this.upstreamExecutor, this.lastDone, [...this.activeChildExecutors, child], this.upstreamDone, this.combineChildResults, this.combineWithChildResult, this.onPull);
-  }
-}
-
-/** @internal */
-class Emit {
-  _tag = OP_EMIT;
-  constructor(value, next) {
-    this.value = value;
-    this.next = next;
-  }
-  close(exit) {
-    const result = this.next.close(exit);
-    return result === undefined ? result : result;
-  }
-  enqueuePullFromChild(_child) {
-    return this;
-  }
-}
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-class ChannelExecutor {
-  _activeSubexecutor = undefined;
-  _cancelled = undefined;
-  _closeLastSubstream = undefined;
-  _done = undefined;
-  _doneStack = [];
-  _emitted = undefined;
-  _input = undefined;
-  _inProgressFinalizer = undefined;
-  constructor(initialChannel, providedEnv, executeCloseLastSubstream) {
-    this._currentChannel = initialChannel;
-    this._executeCloseLastSubstream = executeCloseLastSubstream;
-    this._providedEnv = providedEnv;
-  }
-  run() {
-    let result = undefined;
-    while (result === undefined) {
-      if (this._cancelled !== undefined) {
-        result = this.processCancellation();
-      } else if (this._activeSubexecutor !== undefined) {
-        result = this.runSubexecutor();
-      } else {
-        try {
-          if (this._currentChannel === undefined) {
-            result = Done();
-          } else {
-            if (Effect_dist_effectEffect.isEffect(this._currentChannel)) {
-              this._currentChannel = fromEffect$1(this._currentChannel);
-            } else {
-              switch (this._currentChannel._tag) {
-                case OP_BRACKET_OUT:
-                  {
-                    result = this.runBracketOut(this._currentChannel);
-                    break;
-                  }
-                case OP_BRIDGE:
-                  {
-                    const bridgeInput = this._currentChannel.input;
-
-                    // PipeTo(left, Bridge(queue, channel))
-                    // In a fiber: repeatedly run left and push its outputs to the queue
-                    // Add a finalizer to interrupt the fiber and close the executor
-                    this._currentChannel = this._currentChannel.channel;
-                    if (this._input !== undefined) {
-                      const inputExecutor = this._input;
-                      this._input = undefined;
-                      const drainer = () => Effect_dist_effectEffect.flatMap(bridgeInput.awaitRead(), () => Effect_dist_effectEffect.suspend(() => {
-                        const state = inputExecutor.run();
-                        switch (state._tag) {
-                          case OP_DONE:
-                            {
-                              return Exit_dist_effectExit.match(inputExecutor.getDone(), {
-                                onFailure: cause => bridgeInput.error(cause),
-                                onSuccess: value => bridgeInput.done(value)
-                              });
-                            }
-                          case OP_EMIT$1:
-                            {
-                              return Effect_dist_effectEffect.flatMap(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
-                            }
-                          case OP_FROM_EFFECT:
-                            {
-                              return Effect_dist_effectEffect.matchCauseEffect(state.effect, {
-                                onFailure: cause => bridgeInput.error(cause),
-                                onSuccess: () => drainer()
-                              });
-                            }
-                          case OP_READ:
-                            {
-                              return readUpstream(state, () => drainer(), cause => bridgeInput.error(cause));
-                            }
-                        }
-                      }));
-                      result = FromEffect(Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.forkDaemon(drainer()), fiber => Effect_dist_effectEffect.sync(() => this.addFinalizer(exit => Effect_dist_effectEffect.flatMap(Fiber_dist_effectFiber.interrupt(fiber), () => Effect_dist_effectEffect.suspend(() => {
-                        const effect = this.restorePipe(exit, inputExecutor);
-                        return effect !== undefined ? effect : Effect_dist_effectEffect.unit;
-                      }))))));
-                    }
-                    break;
-                  }
-                case OP_CONCAT_ALL:
-                  {
-                    const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => Effect_dist_effectEffect.sync(() => {
-                      const prevLastClose = this._closeLastSubstream === undefined ? Effect_dist_effectEffect.unit : this._closeLastSubstream;
-                      this._closeLastSubstream = Function_dist_effectFunction.pipe(prevLastClose, Effect_dist_effectEffect.zipRight(effect));
-                    }));
-                    executor._input = this._input;
-                    const channel = this._currentChannel;
-                    this._activeSubexecutor = new PullFromUpstream(executor, value => channel.k(value), undefined, [], (x, y) => channel.combineInners(x, y), (x, y) => channel.combineAll(x, y), request => channel.onPull(request), value => channel.onEmit(value));
-                    this._closeLastSubstream = undefined;
-                    this._currentChannel = undefined;
-                    break;
-                  }
-                case OP_EMIT$2:
-                  {
-                    this._emitted = this._currentChannel.out;
-                    this._currentChannel = this._activeSubexecutor !== undefined ? undefined : unit;
-                    result = Emit$1();
-                    break;
-                  }
-                case OP_ENSURING:
-                  {
-                    this.runEnsuring(this._currentChannel);
-                    break;
-                  }
-                case OP_FAIL:
-                  {
-                    result = this.doneHalt(this._currentChannel.error());
-                    break;
-                  }
-                case OP_FOLD:
-                  {
-                    this._doneStack.push(this._currentChannel.k);
-                    this._currentChannel = this._currentChannel.channel;
-                    break;
-                  }
-                case OP_FROM_EFFECT$1:
-                  {
-                    const effect = this._providedEnv === undefined ? this._currentChannel.effect() : Function_dist_effectFunction.pipe(this._currentChannel.effect(), Effect_dist_effectEffect.provide(this._providedEnv));
-                    result = FromEffect(Effect_dist_effectEffect.matchCauseEffect(effect, {
-                      onFailure: cause => {
-                        const state = this.doneHalt(cause);
-                        return state !== undefined && isFromEffect(state) ? state.effect : Effect_dist_effectEffect.unit;
-                      },
-                      onSuccess: value => {
-                        const state = this.doneSucceed(value);
-                        return state !== undefined && isFromEffect(state) ? state.effect : Effect_dist_effectEffect.unit;
-                      }
-                    }));
-                    break;
-                  }
-                case OP_PIPE_TO:
-                  {
-                    const previousInput = this._input;
-                    const leftExec = new ChannelExecutor(this._currentChannel.left(), this._providedEnv, effect => this._executeCloseLastSubstream(effect));
-                    leftExec._input = previousInput;
-                    this._input = leftExec;
-                    this.addFinalizer(exit => {
-                      const effect = this.restorePipe(exit, previousInput);
-                      return effect !== undefined ? effect : Effect_dist_effectEffect.unit;
-                    });
-                    this._currentChannel = this._currentChannel.right();
-                    break;
-                  }
-                case OP_PROVIDE:
-                  {
-                    const previousEnv = this._providedEnv;
-                    this._providedEnv = this._currentChannel.context();
-                    this._currentChannel = this._currentChannel.inner;
-                    this.addFinalizer(() => Effect_dist_effectEffect.sync(() => {
-                      this._providedEnv = previousEnv;
-                    }));
-                    break;
-                  }
-                case OP_READ$1:
-                  {
-                    const read = this._currentChannel;
-                    result = Read(this._input, Function_dist_effectFunction.identity, emitted => {
-                      try {
-                        this._currentChannel = read.more(emitted);
-                      } catch (error) {
-                        this._currentChannel = read.done.onExit(Exit_dist_effectExit.die(error));
-                      }
-                      return undefined;
-                    }, exit => {
-                      const onExit = exit => {
-                        return read.done.onExit(exit);
-                      };
-                      this._currentChannel = onExit(exit);
-                      return undefined;
-                    });
-                    break;
-                  }
-                case OP_SUCCEED:
-                  {
-                    result = this.doneSucceed(this._currentChannel.evaluate());
-                    break;
-                  }
-                case OP_SUCCEED_NOW:
-                  {
-                    result = this.doneSucceed(this._currentChannel.terminal);
-                    break;
-                  }
-                case OP_SUSPEND:
-                  {
-                    this._currentChannel = this._currentChannel.channel();
-                    break;
-                  }
-                default:
-                  {
-                    // @ts-expect-error
-                    this._currentChannel._tag;
-                  }
-              }
-            }
-          }
-        } catch (error) {
-          this._currentChannel = failCause$1(Cause_dist_effectCause.die(error));
-        }
-      }
-    }
-    return result;
-  }
-  getDone() {
-    return this._done;
-  }
-  getEmit() {
-    return this._emitted;
-  }
-  cancelWith(exit) {
-    this._cancelled = exit;
-  }
-  clearInProgressFinalizer() {
-    this._inProgressFinalizer = undefined;
-  }
-  storeInProgressFinalizer(finalizer) {
-    this._inProgressFinalizer = finalizer;
-  }
-  popAllFinalizers(exit) {
-    const finalizers = [];
-    let next = this._doneStack.pop();
-    while (next) {
-      if (next._tag === "ContinuationFinalizer") {
-        finalizers.push(next.finalizer);
-      }
-      next = this._doneStack.pop();
-    }
-    const effect = finalizers.length === 0 ? Effect_dist_effectEffect.unit : runFinalizers(finalizers, exit);
-    this.storeInProgressFinalizer(effect);
-    return effect;
-  }
-  popNextFinalizers() {
-    const builder = [];
-    while (this._doneStack.length !== 0) {
-      const cont = this._doneStack[this._doneStack.length - 1];
-      if (cont._tag === OP_CONTINUATION_K) {
-        return builder;
-      }
-      builder.push(cont);
-      this._doneStack.pop();
-    }
-    return builder;
-  }
-  restorePipe(exit, prev) {
-    const currInput = this._input;
-    this._input = prev;
-    if (currInput !== undefined) {
-      const effect = currInput.close(exit);
-      return effect;
-    }
-    return Effect_dist_effectEffect.unit;
-  }
-  close(exit) {
-    let runInProgressFinalizers = undefined;
-    const finalizer = this._inProgressFinalizer;
-    if (finalizer !== undefined) {
-      runInProgressFinalizers = Function_dist_effectFunction.pipe(finalizer, Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.sync(() => this.clearInProgressFinalizer())));
-    }
-    let closeSelf = undefined;
-    const selfFinalizers = this.popAllFinalizers(exit);
-    if (selfFinalizers !== undefined) {
-      closeSelf = Function_dist_effectFunction.pipe(selfFinalizers, Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.sync(() => this.clearInProgressFinalizer())));
-    }
-    const closeSubexecutors = this._activeSubexecutor === undefined ? undefined : this._activeSubexecutor.close(exit);
-    if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
-      return undefined;
-    }
-    return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.exit(ifNotNull(closeSubexecutors)), Effect_dist_effectEffect.zip(Effect_dist_effectEffect.exit(ifNotNull(runInProgressFinalizers))), Effect_dist_effectEffect.zip(Effect_dist_effectEffect.exit(ifNotNull(closeSelf))), Effect_dist_effectEffect.map(([[exit1, exit2], exit3]) => Function_dist_effectFunction.pipe(exit1, Exit_dist_effectExit.zipRight(exit2), Exit_dist_effectExit.zipRight(exit3))), Effect_dist_effectEffect.uninterruptible,
-    // TODO: remove
-    Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)));
-  }
-  doneSucceed(value) {
-    if (this._doneStack.length === 0) {
-      this._done = Exit_dist_effectExit.succeed(value);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const head = this._doneStack[this._doneStack.length - 1];
-    if (head._tag === OP_CONTINUATION_K) {
-      this._doneStack.pop();
-      this._currentChannel = head.onSuccess(value);
-      return undefined;
-    }
-    const finalizers = this.popNextFinalizers();
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse();
-      this._done = Exit_dist_effectExit.succeed(value);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Exit_dist_effectExit.succeed(value));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = Function_dist_effectFunction.pipe(finalizerEffect, Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.sync(() => this.clearInProgressFinalizer())), Effect_dist_effectEffect.uninterruptible, Effect_dist_effectEffect.flatMap(() => Effect_dist_effectEffect.sync(() => this.doneSucceed(value))));
-    return FromEffect(effect);
-  }
-  doneHalt(cause) {
-    if (this._doneStack.length === 0) {
-      this._done = Exit_dist_effectExit.failCause(cause);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const head = this._doneStack[this._doneStack.length - 1];
-    if (head._tag === OP_CONTINUATION_K) {
-      this._doneStack.pop();
-      this._currentChannel = head.onHalt(cause);
-      return undefined;
-    }
-    const finalizers = this.popNextFinalizers();
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse();
-      this._done = Exit_dist_effectExit.failCause(cause);
-      this._currentChannel = undefined;
-      return Done();
-    }
-    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), Exit_dist_effectExit.failCause(cause));
-    this.storeInProgressFinalizer(finalizerEffect);
-    const effect = Function_dist_effectFunction.pipe(finalizerEffect, Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.sync(() => this.clearInProgressFinalizer())), Effect_dist_effectEffect.uninterruptible, Effect_dist_effectEffect.flatMap(() => Effect_dist_effectEffect.sync(() => this.doneHalt(cause))));
-    return FromEffect(effect);
-  }
-  processCancellation() {
-    this._currentChannel = undefined;
-    this._done = this._cancelled;
-    this._cancelled = undefined;
-    return Done();
-  }
-  runBracketOut(bracketOut) {
-    const effect = Effect_dist_effectEffect.uninterruptible(Effect_dist_effectEffect.matchCauseEffect(this.provide(bracketOut.acquire()), {
-      onFailure: cause => Effect_dist_effectEffect.sync(() => {
-        this._currentChannel = failCause$1(cause);
-      }),
-      onSuccess: out => Effect_dist_effectEffect.sync(() => {
-        this.addFinalizer(exit => this.provide(bracketOut.finalizer(out, exit)));
-        this._currentChannel = write(out);
-      })
-    }));
-    return FromEffect(effect);
-  }
-  provide(effect) {
-    if (this._providedEnv === undefined) {
-      return effect;
-    }
-    return Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.provide(this._providedEnv));
-  }
-  runEnsuring(ensuring) {
-    this.addFinalizer(ensuring.finalizer);
-    this._currentChannel = ensuring.channel;
-  }
-  addFinalizer(f) {
-    this._doneStack.push(new ContinuationFinalizerImpl(f));
-  }
-  runSubexecutor() {
-    const subexecutor = this._activeSubexecutor;
-    switch (subexecutor._tag) {
-      case OP_PULL_FROM_CHILD:
-        {
-          return this.pullFromChild(subexecutor.childExecutor, subexecutor.parentSubexecutor, subexecutor.onEmit, subexecutor);
-        }
-      case OP_PULL_FROM_UPSTREAM:
-        {
-          return this.pullFromUpstream(subexecutor);
-        }
-      case OP_DRAIN_CHILD_EXECUTORS:
-        {
-          return this.drainChildExecutors(subexecutor);
-        }
-      case OP_EMIT:
-        {
-          this._emitted = subexecutor.value;
-          this._activeSubexecutor = subexecutor.next;
-          return Emit$1();
-        }
-    }
-  }
-  replaceSubexecutor(nextSubExec) {
-    this._currentChannel = undefined;
-    this._activeSubexecutor = nextSubExec;
-  }
-  finishWithExit(exit) {
-    const state = Exit_dist_effectExit.match(exit, {
-      onFailure: cause => this.doneHalt(cause),
-      onSuccess: value => this.doneSucceed(value)
-    });
-    this._activeSubexecutor = undefined;
-    return state === undefined ? Effect_dist_effectEffect.unit : effect(state);
-  }
-  finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
-    this.addFinalizer(() => Function_dist_effectFunction.pipe(closeFuncs, Effect_dist_effectEffect.forEach(closeFunc => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => closeFunc(subexecutorDone)), Effect_dist_effectEffect.flatMap(closeEffect => closeEffect !== undefined ? closeEffect : Effect_dist_effectEffect.unit)), {
-      discard: true
-    })));
-    const state = Function_dist_effectFunction.pipe(subexecutorDone, Exit_dist_effectExit.match({
-      onFailure: cause => this.doneHalt(cause),
-      onSuccess: value => this.doneSucceed(value)
-    }));
-    this._activeSubexecutor = undefined;
-    return state;
-  }
-  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
-    switch (strategy._tag) {
-      case upstreamPullStrategy.OP_PULL_AFTER_NEXT:
-        {
-          const shouldPrepend = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
-          return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue];
-        }
-      case upstreamPullStrategy.OP_PULL_AFTER_ALL_ENQUEUED:
-        {
-          const shouldEnqueue = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
-          return [strategy.emitSeparator, shouldEnqueue ? [...queue, undefined] : queue];
-        }
-    }
-  }
-  pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexecutor) {
-    return Read(childExecutor, Function_dist_effectFunction.identity, emitted => {
-      const childExecutorDecision$1 = onEmitted(emitted);
-      switch (childExecutorDecision$1._tag) {
-        case childExecutorDecision.OP_CONTINUE:
-          {
-            break;
-          }
-        case childExecutorDecision.OP_CLOSE:
-          {
-            this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision$1.value);
-            break;
-          }
-        case childExecutorDecision.OP_YIELD:
-          {
-            const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor);
-            this.replaceSubexecutor(modifiedParent);
-            break;
-          }
-      }
-      this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
-      return undefined;
-    }, Exit_dist_effectExit.match({
-      onFailure: cause => {
-        const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause);
-        return state === undefined ? undefined : effectOrUndefinedIgnored(state);
-      },
-      onSuccess: doneValue => {
-        this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue);
-        return undefined;
-      }
-    }));
-  }
-  finishWithDoneValue(childExecutor, parentSubexecutor, doneValue) {
-    const subexecutor = parentSubexecutor;
-    switch (subexecutor._tag) {
-      case OP_PULL_FROM_UPSTREAM:
-        {
-          const modifiedParent = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
-          this._closeLastSubstream = childExecutor.close(Exit_dist_effectExit.succeed(doneValue));
-          this.replaceSubexecutor(modifiedParent);
-          break;
-        }
-      case OP_DRAIN_CHILD_EXECUTORS:
-        {
-          const modifiedParent = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone !== undefined ? subexecutor.combineChildResults(subexecutor.lastDone, doneValue) : doneValue, subexecutor.activeChildExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-          this._closeLastSubstream = childExecutor.close(Exit_dist_effectExit.succeed(doneValue));
-          this.replaceSubexecutor(modifiedParent);
-          break;
-        }
-    }
-  }
-  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
-    return this.finishSubexecutorWithCloseEffect(Exit_dist_effectExit.failCause(cause), exit => parentSubexecutor.close(exit), exit => childExecutor.close(exit));
-  }
-  pullFromUpstream(subexecutor) {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      return this.performPullFromUpstream(subexecutor);
-    }
-    const activeChild = subexecutor.activeChildExecutors[0];
-    const parentSubexecutor = new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, subexecutor.activeChildExecutors.slice(1), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit);
-    if (activeChild === undefined) {
-      return this.performPullFromUpstream(parentSubexecutor);
-    }
-    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
-    return undefined;
-  }
-  performPullFromUpstream(subexecutor) {
-    return Read(subexecutor.upstreamExecutor, effect => {
-      const closeLastSubstream = this._closeLastSubstream === undefined ? Effect_dist_effectEffect.unit : this._closeLastSubstream;
-      this._closeLastSubstream = undefined;
-      return Function_dist_effectFunction.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect_dist_effectEffect.zipRight(effect));
-    }, emitted => {
-      if (this._closeLastSubstream !== undefined) {
-        const closeLastSubstream = this._closeLastSubstream;
-        this._closeLastSubstream = undefined;
-        return Function_dist_effectFunction.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect_dist_effectEffect.map(() => {
-          const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
-          childExecutor._input = this._input;
-          const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(upstreamPullRequest.Pulled(emitted)));
-          this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
-          if (Option_dist_effectOption.isSome(emitSeparator)) {
-            this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
-          }
-          return undefined;
-        }));
-      }
-      const childExecutor = new ChannelExecutor(subexecutor.createChild(emitted), this._providedEnv, this._executeCloseLastSubstream);
-      childExecutor._input = this._input;
-      const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexecutor.activeChildExecutors, subexecutor.onPull(upstreamPullRequest.Pulled(emitted)));
-      this._activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexecutor.upstreamExecutor, subexecutor.createChild, subexecutor.lastDone, updatedChildExecutors, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull, subexecutor.onEmit), subexecutor.onEmit);
-      if (Option_dist_effectOption.isSome(emitSeparator)) {
-        this._activeSubexecutor = new Emit(emitSeparator.value, this._activeSubexecutor);
-      }
-      return undefined;
-    }, exit => {
-      if (subexecutor.activeChildExecutors.some(subexecutor => subexecutor !== undefined)) {
-        const drain = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, [undefined, ...subexecutor.activeChildExecutors], subexecutor.upstreamExecutor.getDone(), subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-        if (this._closeLastSubstream !== undefined) {
-          const closeLastSubstream = this._closeLastSubstream;
-          this._closeLastSubstream = undefined;
-          return Function_dist_effectFunction.pipe(this._executeCloseLastSubstream(closeLastSubstream), Effect_dist_effectEffect.map(() => this.replaceSubexecutor(drain)));
-        }
-        this.replaceSubexecutor(drain);
-        return undefined;
-      }
-      const closeLastSubstream = this._closeLastSubstream;
-      const state = this.finishSubexecutorWithCloseEffect(Function_dist_effectFunction.pipe(exit, Exit_dist_effectExit.map(a => subexecutor.combineWithChildResult(subexecutor.lastDone, a))), () => closeLastSubstream, exit => subexecutor.upstreamExecutor.close(exit));
-      return state === undefined ? undefined :
-      // NOTE: assuming finalizers cannot fail
-      effectOrUndefinedIgnored(state);
-    });
-  }
-  drainChildExecutors(subexecutor) {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      const lastClose = this._closeLastSubstream;
-      if (lastClose !== undefined) {
-        this.addFinalizer(() => Effect_dist_effectEffect.succeed(lastClose));
-      }
-      return this.finishSubexecutorWithCloseEffect(subexecutor.upstreamDone, () => lastClose, exit => subexecutor.upstreamExecutor.close(exit));
-    }
-    const activeChild = subexecutor.activeChildExecutors[0];
-    const rest = subexecutor.activeChildExecutors.slice(1);
-    if (activeChild === undefined) {
-      const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(true, rest, subexecutor.onPull(upstreamPullRequest.NoUpstream(rest.reduce((n, curr) => curr !== undefined ? n + 1 : n, 0))));
-      this.replaceSubexecutor(new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, remainingExecutors, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull));
-      if (Option_dist_effectOption.isSome(emitSeparator)) {
-        this._emitted = emitSeparator.value;
-        return Emit$1();
-      }
-      return undefined;
-    }
-    const parentSubexecutor = new DrainChildExecutors(subexecutor.upstreamExecutor, subexecutor.lastDone, rest, subexecutor.upstreamDone, subexecutor.combineChildResults, subexecutor.combineWithChildResult, subexecutor.onPull);
-    this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, parentSubexecutor, activeChild.onEmit));
-    return undefined;
-  }
-}
-const ifNotNull = effect => effect !== undefined ? effect : Effect_dist_effectEffect.unit;
-const runFinalizers = (finalizers, exit) => {
-  return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forEach(finalizers, fin => Effect_dist_effectEffect.exit(fin(exit))), Effect_dist_effectEffect.map(exits => Function_dist_effectFunction.pipe(Exit_dist_effectExit.all(exits), Option_dist_effectOption.getOrElse(() => Exit_dist_effectExit.unit))), Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)));
-};
-
-/**
- * @internal
- */
-const readUpstream = (r, onSuccess, onFailure) => {
-  const readStack = [r];
-  const read = () => {
-    const current = readStack.pop();
-    if (current === undefined || current.upstream === undefined) {
-      return Effect_dist_effectEffect.dieMessage("Unexpected end of input for channel execution");
-    }
-    const state = current.upstream.run();
-    switch (state._tag) {
-      case OP_EMIT$1:
-        {
-          const emitEffect = current.onEmit(current.upstream.getEmit());
-          if (readStack.length === 0) {
-            if (emitEffect === undefined) {
-              return Effect_dist_effectEffect.suspend(onSuccess);
-            }
-            return Function_dist_effectFunction.pipe(emitEffect, Effect_dist_effectEffect.matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (emitEffect === undefined) {
-            return Effect_dist_effectEffect.suspend(() => read());
-          }
-          return Function_dist_effectFunction.pipe(emitEffect, Effect_dist_effectEffect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_DONE:
-        {
-          const doneEffect = current.onDone(current.upstream.getDone());
-          if (readStack.length === 0) {
-            if (doneEffect === undefined) {
-              return Effect_dist_effectEffect.suspend(onSuccess);
-            }
-            return Function_dist_effectFunction.pipe(doneEffect, Effect_dist_effectEffect.matchCauseEffect({
-              onFailure,
-              onSuccess
-            }));
-          }
-          if (doneEffect === undefined) {
-            return Effect_dist_effectEffect.suspend(() => read());
-          }
-          return Function_dist_effectFunction.pipe(doneEffect, Effect_dist_effectEffect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_FROM_EFFECT:
-        {
-          readStack.push(current);
-          return Function_dist_effectFunction.pipe(current.onEffect(state.effect), Effect_dist_effectEffect.catchAllCause(cause => Effect_dist_effectEffect.suspend(() => {
-            const doneEffect = current.onDone(Exit_dist_effectExit.failCause(cause));
-            return doneEffect === undefined ? Effect_dist_effectEffect.unit : doneEffect;
-          })), Effect_dist_effectEffect.matchCauseEffect({
-            onFailure,
-            onSuccess: () => read()
-          }));
-        }
-      case OP_READ:
-        {
-          readStack.push(current);
-          readStack.push(state);
-          return Effect_dist_effectEffect.suspend(() => read());
-        }
-    }
-  };
-  return read();
-};
-
-/** @internal */
-const run$1 = self => Function_dist_effectFunction.pipe(runScoped(self), Effect_dist_effectEffect.scoped);
-
-/** @internal */
-const runScoped = self => {
-  const run = (channelDeferred, scopeDeferred, scope) => Effect_dist_effectEffect.acquireUseRelease(Effect_dist_effectEffect.sync(() => new ChannelExecutor(self, void 0, Function_dist_effectFunction.identity)), exec => Effect_dist_effectEffect.suspend(() => Function_dist_effectFunction.pipe(runScopedInterpret(exec.run(), exec), Effect_dist_effectEffect.intoDeferred(channelDeferred), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred._await(channelDeferred)), Effect_dist_effectEffect.zipLeft(Deferred_dist_effectDeferred._await(scopeDeferred)))), (exec, exit) => {
-    const finalize = exec.close(exit);
-    if (finalize === undefined) {
-      return Effect_dist_effectEffect.unit;
-    }
-    return Effect_dist_effectEffect.tapErrorCause(finalize, cause => Scope_dist_effectScope.addFinalizer(scope, Effect_dist_effectEffect.failCause(cause)));
-  });
-  return Effect_dist_effectEffect.uninterruptibleMask(restore => Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.scope, parent => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all([Scope_dist_effectScope.fork(parent, ExecutionStrategy_dist_effectExecutionStrategy.sequential$1), Deferred_dist_effectDeferred.make(), Deferred_dist_effectDeferred.make()]), Effect_dist_effectEffect.flatMap(([child, channelDeferred, scopeDeferred]) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forkScoped(restore(run(channelDeferred, scopeDeferred, child))), Effect_dist_effectEffect.flatMap(fiber => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.addFinalizer(() => Deferred_dist_effectDeferred.succeed(scopeDeferred, void 0)), Effect_dist_effectEffect.zipRight(restore(Deferred_dist_effectDeferred._await(channelDeferred))), Effect_dist_effectEffect.zipLeft(Fiber_dist_effectFiber.inheritAll(fiber)))))))));
-};
-
-/** @internal */
-const runScopedInterpret = (channelState, exec) => {
-  const op = channelState;
-  switch (op._tag) {
-    case OP_FROM_EFFECT:
-      {
-        return Function_dist_effectFunction.pipe(op.effect, Effect_dist_effectEffect.flatMap(() => runScopedInterpret(exec.run(), exec)));
-      }
-    case OP_EMIT$1:
-      {
-        // Can't really happen because Out <:< Nothing. So just skip ahead.
-        return runScopedInterpret(exec.run(), exec);
-      }
-    case OP_DONE:
-      {
-        return Effect_dist_effectEffect.suspend(() => exec.getDone());
-      }
-    case OP_READ:
-      {
-        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), Effect_dist_effectEffect.failCause);
-      }
-  }
-};
-
-/** @internal */
-const acquireUseRelease = (acquire, use, release) => flatMap$1(fromEffect$1(Ref_dist_effectRef.make(() => Effect_dist_effectEffect.unit)), ref => Function_dist_effectFunction.pipe(fromEffect$1(Effect_dist_effectEffect.uninterruptible(Effect_dist_effectEffect.tap(acquire, a => Ref_dist_effectRef.set(ref, exit => release(a, exit))))), flatMap$1(use), ensuringWith$1(exit => Effect_dist_effectEffect.flatMap(Ref_dist_effectRef.get(ref), f => f(exit)))));
-
-/** @internal */
-const as$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => map$1(self, () => value));
-
-/** @internal */
-const asUnit = self => map$1(self, Function_dist_effectFunction.constVoid);
-
-/** @internal */
-const buffer = options => suspend$1(() => {
-  const doBuffer = (empty, isEmpty, ref) => unwrap$1(Ref_dist_effectRef.modify(ref, inElem => isEmpty(inElem) ? [readWith({
-    onInput: input => flatMap$1(write(input), () => doBuffer(empty, isEmpty, ref)),
-    onFailure: error => fail$1(error),
-    onDone: done => succeedNow(done)
-  }), inElem] : [flatMap$1(write(inElem), () => doBuffer(empty, isEmpty, ref)), empty]));
-  return doBuffer(options.empty, options.isEmpty, options.ref);
-});
-
-/** @internal */
-const bufferChunk = ref => buffer({
-  empty: Chunk_dist_effectChunk.empty(),
-  isEmpty: Chunk_dist_effectChunk.isEmpty,
-  ref
-});
-
-/** @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$1
-})));
-
-/** @internal */
-const concatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
-
-/** @internal */
-const collect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => {
-  const collector = readWith({
-    onInput: out => Option_dist_effectOption.match(pf(out), {
-      onNone: () => collector,
-      onSome: out2 => flatMap$1(write(out2), () => collector)
-    }),
-    onFailure: fail$1,
-    onDone: succeedNow
-  });
-  return pipeTo(self, collector);
-});
-
-/** @internal */
-const concatOut = self => concatAll(self);
-
-/** @internal */
-const mapInput$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(write(inElem), () => reader),
-    onFailure: fail$1,
-    onDone: done => succeedNow(f(done))
-  });
-  return pipeTo(reader, self);
-});
-
-/** @internal */
-const mapInputEffect$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(write(inElem), () => reader),
-    onFailure: fail$1,
-    onDone: done => fromEffect$1(f(done))
-  });
-  return pipeTo(reader, self);
-});
-
-/** @internal */
-const mapInputError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(write(inElem), () => reader),
-    onFailure: error => fail$1(f(error)),
-    onDone: succeedNow
-  });
-  return pipeTo(reader, self);
-});
-
-/** @internal */
-const mapInputErrorEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(write(inElem), () => reader),
-    onFailure: error => fromEffect$1(f(error)),
-    onDone: succeedNow
-  });
-  return pipeTo(reader, self);
-});
-
-/** @internal */
-const mapInputIn = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(write(f(inElem)), () => reader),
-    onFailure: fail$1,
-    onDone: succeedNow
-  });
-  return pipeTo(reader, self);
-});
-const mapInputInEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: inElem => flatMap$1(flatMap$1(fromEffect$1(f(inElem)), write), () => reader),
-    onFailure: fail$1,
-    onDone: succeedNow
-  });
-  return pipeTo(reader, self);
-});
-
-/** @internal */
-const doneCollect = self => suspend$1(() => {
-  const builder = [];
-  return Function_dist_effectFunction.pipe(pipeTo(self, doneCollectReader(builder)), flatMap$1(outDone => succeed$1([Chunk_dist_effectChunk.unsafeFromArray(builder), outDone])));
-});
-
-/** @internal */
-const doneCollectReader = builder => {
-  return readWith({
-    onInput: outElem => flatMap$1(sync$1(() => {
-      builder.push(outElem);
-    }), () => doneCollectReader(builder)),
-    onFailure: fail$1,
-    onDone: succeed$1
-  });
-};
-
-/** @internal */
-const drain$1 = self => {
-  const drainer = readWithCause({
-    onInput: () => drainer,
-    onFailure: failCause$1,
-    onDone: succeed$1
-  });
-  return pipeTo(self, drainer);
-};
-
-/** @internal */
-const emitCollect = self => flatMap$1(doneCollect(self), write);
-
-/** @internal */
-const ensuring$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => ensuringWith$1(self, () => finalizer));
-
-/** @internal */
-const context$1 = () => fromEffect$1(Effect_dist_effectEffect.context());
-
-/** @internal */
-const contextWith$1 = f => map$1(context$1(), f);
-
-/** @internal */
-const contextWithChannel = f => flatMap$1(context$1(), f);
-
-/** @internal */
-const contextWithEffect$1 = f => mapEffect$1(context$1(), f);
-
-/** @internal */
-const flatten = self => flatMap$1(self, Function_dist_effectFunction.identity);
-
-/** @internal */
-const foldChannel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => foldCauseChannel(self, {
-  onFailure: cause => {
-    const either = Cause_dist_effectCause.failureOrCause(cause);
-    switch (either._tag) {
-      case "Left":
-        {
-          return options.onFailure(either.left);
-        }
-      case "Right":
-        {
-          return failCause$1(either.right);
-        }
-    }
-  },
-  onSuccess: options.onSuccess
-}));
-
-/** @internal */
-const fromEither = either => suspend$1(() => Either_dist_effectEither.match(either, {
-  onLeft: fail$1,
-  onRight: succeed$1
-}));
-
-/** @internal */
-const fromInput = input => unwrap$1(input.takeWith(failCause$1, elem => flatMap$1(write(elem), () => fromInput(input)), succeed$1));
-
-/** @internal */
-const fromHub$1 = hub => unwrapScoped$1(Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), fromQueue$1));
-
-/** @internal */
-const fromHubScoped = hub => Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), fromQueue$1);
-
-/** @internal */
-const fromOption = option => suspend$1(() => Option_dist_effectOption.match(option, {
-  onNone: () => fail$1(Option_dist_effectOption.none()),
-  onSome: succeed$1
-}));
-
-/** @internal */
-const fromQueue$1 = queue => suspend$1(() => fromQueueInternal(queue));
-
-/** @internal */
-const fromQueueInternal = queue => Function_dist_effectFunction.pipe(fromEffect$1(Queue_dist_effectQueue.take(queue)), flatMap$1(Either_dist_effectEither.match({
-  onLeft: Exit_dist_effectExit.match({
-    onFailure: failCause$1,
-    onSuccess: succeedNow
-  }),
-  onRight: elem => flatMap$1(write(elem), () => fromQueueInternal(queue))
-})));
-
-/** @internal */
-const identityChannel = () => readWith({
-  onInput: input => flatMap$1(write(input), () => identityChannel()),
-  onFailure: fail$1,
-  onDone: succeedNow
-});
-
-/** @internal */
-const interruptWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => mergeWith(self, {
-  other: fromEffect$1(effect),
-  onSelfDone: selfDone => mergeDecision.Done(Effect_dist_effectEffect.suspend(() => selfDone)),
-  onOtherDone: effectDone => mergeDecision.Done(Effect_dist_effectEffect.suspend(() => effectDone))
-}));
-
-/** @internal */
-const interruptWhenDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => interruptWhen(self, Deferred_dist_effectDeferred._await(deferred)));
-
-/** @internal */
-const map$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap$1(self, a => sync$1(() => f(a))));
-
-/** @internal */
-const mapEffect$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flatMap$1(self, z => fromEffect$1(f(z))));
-
-/** @internal */
-const mapError$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapErrorCause(self, Cause_dist_effectCause.map(f)));
-
-/** @internal */
-const mapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAllCause(self, cause => failCause$1(f(cause))));
-
-/** @internal */
-const mapOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWith({
-    onInput: outElem => flatMap$1(write(f(outElem)), () => reader),
-    onFailure: fail$1,
-    onDone: succeedNow
-  });
-  return pipeTo(self, reader);
-});
-
-/** @internal */
-const mapOutEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const reader = readWithCause({
-    onInput: outElem => Function_dist_effectFunction.pipe(fromEffect$1(f(outElem)), flatMap$1(write), flatMap$1(() => reader)),
-    onFailure: failCause$1,
-    onDone: succeedNow
-  });
-  return pipeTo(self, reader);
-});
-
-/** @internal */
-const mapOutEffectPar = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, f, n) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.gen(function* ($) {
-  const queue = yield* $(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(n), queue => Queue_dist_effectQueue.shutdown(queue)));
-  const errorSignal = yield* $(Deferred_dist_effectDeferred.make());
-  const withPermits = n === Number.POSITIVE_INFINITY ? _ => Function_dist_effectFunction.identity : (yield* $(Effect_dist_effectEffect.makeSemaphore(n))).withPermits;
-  const pull = yield* $(toPull(self));
-  yield* $(Effect_dist_effectEffect.matchCauseEffect(pull, {
-    onFailure: cause => Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.failCause(cause)),
-    onSuccess: either => Either_dist_effectEither.match(either, {
-      onLeft: outDone => {
-        const lock = withPermits(n);
-        return Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.interruptible(lock(Effect_dist_effectEffect.unit)), Effect_dist_effectEffect.asUnit(Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.succeed(Either_dist_effectEither.left(outDone)))));
-      },
-      onRight: outElem => Effect_dist_effectEffect.gen(function* ($) {
-        const deferred = yield* $(Deferred_dist_effectDeferred.make());
-        const latch = yield* $(Deferred_dist_effectDeferred.make());
-        yield* $(Effect_dist_effectEffect.asUnit(Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.map(Deferred_dist_effectDeferred._await(deferred), Either_dist_effectEither.right))));
-        yield* $(Deferred_dist_effectDeferred.succeed(latch, void 0), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.uninterruptibleMask(restore => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.exit(restore(Deferred_dist_effectDeferred._await(errorSignal))), Effect_dist_effectEffect.raceFirst(Effect_dist_effectEffect.exit(restore(f(outElem)))),
-        // TODO: remove
-        Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)))), Effect_dist_effectEffect.tapErrorCause(cause => Deferred_dist_effectDeferred.failCause(errorSignal, cause)), Effect_dist_effectEffect.intoDeferred(deferred))), withPermits(1), Effect_dist_effectEffect.forkScoped);
-        yield* $(Deferred_dist_effectDeferred._await(latch));
-      })
-    })
-  }), Effect_dist_effectEffect.forever, Effect_dist_effectEffect.interruptible, Effect_dist_effectEffect.forkScoped);
-  return queue;
-}), Effect_dist_effectEffect.map(queue => {
-  const consumer = unwrap$1(Effect_dist_effectEffect.matchCause(Effect_dist_effectEffect.flatten(Queue_dist_effectQueue.take(queue)), {
-    onFailure: failCause$1,
-    onSuccess: Either_dist_effectEither.match({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }));
-  return consumer;
-}), unwrapScoped$1));
-
-/** @internal */
-const mergeAll = options => {
-  return channels => mergeAllWith(options)(channels, Function_dist_effectFunction.constVoid);
-};
-
-/** @internal */
-const mergeAllUnbounded = channels => mergeAllWith({
-  concurrency: "unbounded"
-})(channels, Function_dist_effectFunction.constVoid);
-
-/** @internal */
-const mergeAllUnboundedWith = (channels, f) => mergeAllWith({
-  concurrency: "unbounded"
-})(channels, f);
-
-/** @internal */
-const mergeAllWith = ({
-  bufferSize = 16,
-  concurrency,
-  mergeStrategy: mergeStrategy$1 = mergeStrategy.BackPressure()
-}) => (channels, f) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.gen(function* ($) {
-  const input = yield* $(singleProducerAsyncInput.make());
-  const queueReader = fromInput(input);
-  const queue = yield* $(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(bufferSize), queue => Queue_dist_effectQueue.shutdown(queue)));
-  const cancelers = yield* $(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.unbounded(), queue => Queue_dist_effectQueue.shutdown(queue)));
-  const lastDone = yield* $(Ref_dist_effectRef.make(Option_dist_effectOption.none()));
-  const errorSignal = yield* $(Deferred_dist_effectDeferred.make());
-  const withPermits = concurrency === "unbounded" ? _ => Function_dist_effectFunction.identity : (yield* $(Effect_dist_effectEffect.makeSemaphore(concurrency))).withPermits;
-  const pull = yield* $(toPull(channels));
-  const evaluatePull = pull => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.flatMap(pull, Either_dist_effectEither.match({
-    onLeft: done => Effect_dist_effectEffect.succeed(Option_dist_effectOption.some(done)),
-    onRight: outElem => Effect_dist_effectEffect.as(Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.succeed(Either_dist_effectEither.right(outElem))), Option_dist_effectOption.none())
-  })), Effect_dist_effectEffect.repeatUntil(Option_dist_effectOption.isSome), Effect_dist_effectEffect.flatMap(Option_dist_effectOption.match({
-    onNone: () => Effect_dist_effectEffect.unit,
-    onSome: outDone => Ref_dist_effectRef.update(lastDone, Option_dist_effectOption.match({
-      onNone: () => Option_dist_effectOption.some(outDone),
-      onSome: lastDone => Option_dist_effectOption.some(f(lastDone, outDone))
-    }))
-  })), Effect_dist_effectEffect.catchAllCause(cause => Cause_dist_effectCause.isInterrupted(cause) ? Effect_dist_effectEffect.failCause(cause) : Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.failCause(cause)), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred.succeed(errorSignal, void 0)), Effect_dist_effectEffect.asUnit)));
-  yield* $(Effect_dist_effectEffect.matchCauseEffect(pull, {
-    onFailure: cause => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.failCause(cause)), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.succeed(false))),
-    onSuccess: Either_dist_effectEither.match({
-      onLeft: outDone => Effect_dist_effectEffect.raceWith(Deferred_dist_effectDeferred._await(errorSignal), withPermits(concurrency)(Effect_dist_effectEffect.unit), {
-        onSelfDone: (_, permitAcquisition) => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(permitAcquisition), Effect_dist_effectEffect.as(false)),
-        onOtherDone: (_, failureAwait) => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(failureAwait), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(lastDone), Effect_dist_effectEffect.flatMap(Option_dist_effectOption.match({
-          onNone: () => Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.succeed(Either_dist_effectEither.left(outDone))),
-          onSome: lastDone => Queue_dist_effectQueue.offer(queue, Effect_dist_effectEffect.succeed(Either_dist_effectEither.left(f(lastDone, outDone))))
-        })), Effect_dist_effectEffect.as(false))))
-      }),
-      onRight: channel => Function_dist_effectFunction.pipe(mergeStrategy$1, mergeStrategy.match({
-        onBackPressure: () => Effect_dist_effectEffect.gen(function* ($) {
-          const latch = yield* $(Deferred_dist_effectDeferred.make());
-          const raceEffects = Function_dist_effectFunction.pipe(queueReader, pipeTo(channel), toPull, Effect_dist_effectEffect.flatMap(pull => Function_dist_effectFunction.pipe(evaluatePull(pull), Effect_dist_effectEffect.race(Deferred_dist_effectDeferred._await(errorSignal)))), Effect_dist_effectEffect.scoped);
-          yield* $(Deferred_dist_effectDeferred.succeed(latch, void 0), Effect_dist_effectEffect.zipRight(raceEffects), withPermits(1), Effect_dist_effectEffect.forkScoped);
-          yield* $(Deferred_dist_effectDeferred._await(latch));
-          const errored = yield* $(Deferred_dist_effectDeferred.isDone(errorSignal));
-          return !errored;
-        }),
-        onBufferSliding: () => Effect_dist_effectEffect.gen(function* ($) {
-          const canceler = yield* $(Deferred_dist_effectDeferred.make());
-          const latch = yield* $(Deferred_dist_effectDeferred.make());
-          const size = yield* $(Queue_dist_effectQueue.size(cancelers));
-          yield* $(Queue_dist_effectQueue.take(cancelers), Effect_dist_effectEffect.flatMap(_ => Deferred_dist_effectDeferred.succeed(_, void 0)), Effect_dist_effectEffect.when(() => concurrency === "unbounded" ? false : size >= concurrency));
-          yield* $(Queue_dist_effectQueue.offer(cancelers, canceler));
-          const raceEffects = Function_dist_effectFunction.pipe(queueReader, pipeTo(channel), toPull, Effect_dist_effectEffect.flatMap(pull => Function_dist_effectFunction.pipe(evaluatePull(pull), Effect_dist_effectEffect.race(Deferred_dist_effectDeferred._await(errorSignal)), Effect_dist_effectEffect.race(Deferred_dist_effectDeferred._await(canceler)))), Effect_dist_effectEffect.scoped);
-          yield* $(Deferred_dist_effectDeferred.succeed(latch, void 0), Effect_dist_effectEffect.zipRight(raceEffects), withPermits(1), Effect_dist_effectEffect.forkScoped);
-          yield* $(Deferred_dist_effectDeferred._await(latch));
-          const errored = yield* $(Deferred_dist_effectDeferred.isDone(errorSignal));
-          return !errored;
-        })
-      }))
-    })
-  }), Effect_dist_effectEffect.repeatWhile(Function_dist_effectFunction.identity), Effect_dist_effectEffect.forkScoped);
-  return [queue, input];
-}), Effect_dist_effectEffect.map(([queue, input]) => {
-  const consumer = Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(queue), Effect_dist_effectEffect.flatten, Effect_dist_effectEffect.matchCause({
-    onFailure: failCause$1,
-    onSuccess: Either_dist_effectEither.match({
-      onLeft: succeedNow,
-      onRight: outElem => flatMap$1(write(outElem), () => consumer)
-    })
-  }), unwrap$1);
-  return embedInput(consumer, input);
-}), unwrapScoped$1);
-
-/** @internal */
-const mergeMap = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
-
-/** @internal */
-const mergeOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => mergeAll({
-  concurrency: n
-})(mapOut(self, Function_dist_effectFunction.identity)));
-
-/** @internal */
-const mergeOutWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, f) => mergeAllWith({
-  concurrency: n
-})(mapOut(self, Function_dist_effectFunction.identity), f));
-
-/** @internal */
-const mergeWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => unwrapScoped$1(Effect_dist_effectEffect.flatMap(singleProducerAsyncInput.make(), input => {
-  const queueReader = fromInput(input);
-  return Effect_dist_effectEffect.map(Effect_dist_effectEffect.zip(toPull(pipeTo(queueReader, self)), toPull(pipeTo(queueReader, options.other))), ([pullL, pullR]) => {
-    const handleSide = (exit, fiber, pull) => (done, both, single) => {
-      const onDecision = decision => {
-        const op = decision;
-        if (op._tag === mergeDecision.OP_DONE) {
-          return Effect_dist_effectEffect.succeed(fromEffect$1(Effect_dist_effectEffect.zipRight(Fiber_dist_effectFiber.interrupt(fiber), op.effect)));
-        }
-        return Effect_dist_effectEffect.map(Fiber_dist_effectFiber._await(fiber), Exit_dist_effectExit.match({
-          onFailure: cause => fromEffect$1(op.f(Exit_dist_effectExit.failCause(cause))),
-          onSuccess: Either_dist_effectEither.match({
-            onLeft: done => fromEffect$1(op.f(Exit_dist_effectExit.succeed(done))),
-            onRight: elem => zipRight$1(write(elem), go(single(op.f)))
-          })
-        }));
-      };
-      return Exit_dist_effectExit.match(exit, {
-        onFailure: cause => onDecision(done(Exit_dist_effectExit.failCause(cause))),
-        onSuccess: Either_dist_effectEither.match({
-          onLeft: z => onDecision(done(Exit_dist_effectExit.succeed(z))),
-          onRight: elem => Effect_dist_effectEffect.succeed(flatMap$1(write(elem), () => flatMap$1(fromEffect$1(Effect_dist_effectEffect.forkDaemon(pull)), leftFiber => go(both(leftFiber, fiber)))))
-        })
-      });
-    };
-    const go = state => {
-      switch (state._tag) {
-        case mergeState.OP_BOTH_RUNNING:
-          {
-            const leftJoin = Effect_dist_effectEffect.interruptible(Fiber_dist_effectFiber.join(state.left));
-            const rightJoin = Effect_dist_effectEffect.interruptible(Fiber_dist_effectFiber.join(state.right));
-            return unwrap$1(Effect_dist_effectEffect.raceWith(leftJoin, rightJoin, {
-              onSelfDone: (leftExit, rf) => Effect_dist_effectEffect.zipRight(Fiber_dist_effectFiber.interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, mergeState.BothRunning, f => mergeState.LeftDone(f))),
-              onOtherDone: (rightExit, lf) => Effect_dist_effectEffect.zipRight(Fiber_dist_effectFiber.interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => mergeState.BothRunning(right, left), f => mergeState.RightDone(f)))
-            }));
-          }
-        case mergeState.OP_LEFT_DONE:
-          {
-            return unwrap$1(Effect_dist_effectEffect.map(Effect_dist_effectEffect.exit(pullR), Exit_dist_effectExit.match({
-              onFailure: cause => fromEffect$1(state.f(Exit_dist_effectExit.failCause(cause))),
-              onSuccess: Either_dist_effectEither.match({
-                onLeft: done => fromEffect$1(state.f(Exit_dist_effectExit.succeed(done))),
-                onRight: elem => flatMap$1(write(elem), () => go(mergeState.LeftDone(state.f)))
-              })
-            })));
-          }
-        case mergeState.OP_RIGHT_DONE:
-          {
-            return unwrap$1(Effect_dist_effectEffect.map(Effect_dist_effectEffect.exit(pullL), Exit_dist_effectExit.match({
-              onFailure: cause => fromEffect$1(state.f(Exit_dist_effectExit.failCause(cause))),
-              onSuccess: Either_dist_effectEither.match({
-                onLeft: done => fromEffect$1(state.f(Exit_dist_effectExit.succeed(done))),
-                onRight: elem => flatMap$1(write(elem), () => go(mergeState.RightDone(state.f)))
-              })
-            })));
-          }
-      }
-    };
-    return Function_dist_effectFunction.pipe(fromEffect$1(Effect_dist_effectEffect.zipWith(Effect_dist_effectEffect.forkDaemon(pullL), Effect_dist_effectEffect.forkDaemon(pullR), (left, right) => mergeState.BothRunning(left, right))), flatMap$1(go), embedInput(input));
-  });
-})));
-
-/** @internal */
-const never$1 = /*#__PURE__*/fromEffect$1(Effect_dist_effectEffect.never);
-
-/** @internal */
-const orDie = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => orDieWith(self, error));
-
-/** @internal */
-const orDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAll(self, e => {
-  throw f(e);
-}));
-
-/** @internal */
-const orElse$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => catchAll(self, that));
-
-/** @internal */
-const pipeToOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => suspend$1(() => {
-  let channelException = undefined;
-  const reader = readWith({
-    onInput: outElem => flatMap$1(write(outElem), () => reader),
-    onFailure: outErr => {
-      channelException = ChannelException(outErr);
-      return failCause$1(Cause_dist_effectCause.die(channelException));
-    },
-    onDone: succeedNow
-  });
-  const writer = readWithCause({
-    onInput: outElem => Function_dist_effectFunction.pipe(write(outElem), flatMap$1(() => writer)),
-    onFailure: cause => Cause_dist_effectCause.isDieType(cause) && isChannelException(cause.defect) && Equal_dist_effectEqual.equals(cause.defect, channelException) ? fail$1(cause.defect.error) : failCause$1(cause),
-    onDone: succeedNow
-  });
-  return pipeTo(pipeTo(pipeTo(self, reader), that), writer);
-}));
-
-/** @internal */
-const provideService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, service) => {
-  return flatMap$1(context$1(), context => provideContext$1(self, Context_dist_effectContext.add(context, tag, service)));
-});
-
-/** @internal */
-const provideLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) => unwrapScoped$1(Effect_dist_effectEffect.map(Layer_dist_effectLayer.build(layer), env => provideContext$1(self, env))));
-
-/** @internal */
-const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => contextWithChannel(context => provideContext$1(self, f(context))));
-
-/** @internal */
-const provideSomeLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) =>
-// @ts-expect-error
-provideLayer(self, Layer_dist_effectLayer.merge(Layer_dist_effectLayer.context(), layer)));
-
-/** @internal */
-const read = () => readOrFail(Option_dist_effectOption.none());
-
-/** @internal */
-const repeated = self => flatMap$1(self, () => repeated(self));
-
-/** @internal */
-const run = self => Effect_dist_effectEffect.scoped(runScoped(self));
-
-/** @internal */
-const runCollect = self => run$1(collectElements(self));
-
-/** @internal */
-const runDrain = self => run$1(drain$1(self));
-
-/** @internal */
-const scoped = effect => unwrap$1(Effect_dist_effectEffect.uninterruptibleMask(restore => Effect_dist_effectEffect.map(Scope_dist_effectScope.make(), scope => acquireReleaseOut(Effect_dist_effectEffect.tapErrorCause(restore(Scope_dist_effectScope.extend(scope)(effect)), cause => Scope_dist_effectScope.close(scope, Exit_dist_effectExit.failCause(cause))), (_, exit) => Scope_dist_effectScope.close(scope, exit)))));
-
-/** @internal */
-const toHub = hub => toQueue(hub);
-
-/** @internal */
-const toPull = self => Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => new ChannelExecutor(self, void 0, Function_dist_effectFunction.identity)), (exec, exit) => {
-  const finalize = exec.close(exit);
-  return finalize === undefined ? Effect_dist_effectEffect.unit : finalize;
-}), exec => Effect_dist_effectEffect.suspend(() => interpretToPull(exec.run(), exec)));
-
-/** @internal */
-const interpretToPull = (channelState, exec) => {
-  const state = channelState;
-  switch (state._tag) {
-    case OP_DONE:
-      {
-        return Exit_dist_effectExit.match(exec.getDone(), {
-          onFailure: Effect_dist_effectEffect.failCause,
-          onSuccess: done => Effect_dist_effectEffect.succeed(Either_dist_effectEither.left(done))
-        });
-      }
-    case OP_EMIT$1:
-      {
-        return Effect_dist_effectEffect.succeed(Either_dist_effectEither.right(exec.getEmit()));
-      }
-    case OP_FROM_EFFECT:
-      {
-        return Function_dist_effectFunction.pipe(state.effect, Effect_dist_effectEffect.flatMap(() => interpretToPull(exec.run(), exec)));
-      }
-    case OP_READ:
-      {
-        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => Effect_dist_effectEffect.failCause(cause));
-      }
-  }
-};
-
-/** @internal */
-const toQueue = queue => suspend$1(() => toQueueInternal(queue));
-
-/** @internal */
-const toQueueInternal = queue => {
-  return readWithCause({
-    onInput: elem => flatMap$1(fromEffect$1(Queue_dist_effectQueue.offer(queue, Either_dist_effectEither.right(elem))), () => toQueueInternal(queue)),
-    onFailure: cause => fromEffect$1(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Either_dist_effectEither.left(Exit_dist_effectExit.failCause(cause))))),
-    onDone: done => fromEffect$1(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Either_dist_effectEither.left(Exit_dist_effectExit.succeed(done)))))
-  });
-};
-
-/** @internal */
-const unwrap$1 = channel => flatten(fromEffect$1(channel));
-
-/** @internal */
-const unwrapScoped$1 = self => concatAllWith(scoped(self), (d, _) => d, (d, _) => d);
-
-/** @internal */
-const updateService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => mapInputContext(self, context => Context_dist_effectContext.merge(context, Context_dist_effectContext.make(tag, f(Context_dist_effectContext.unsafeGet(context, tag))))));
-
-/** @internal */
-const withSpan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, name, options) => unwrapScoped$1(Effect_dist_effectEffect.as(Effect_dist_effectEffect.withSpanScoped(name, options), self)));
-
-/** @internal */
-const writeAll = (...outs) => writeChunk(Chunk_dist_effectChunk.fromIterable(outs));
-
-/** @internal */
-const writeChunk = outs => writeChunkWriter(0, outs.length, outs);
-
-/** @internal */
-const writeChunkWriter = (idx, len, chunk) => {
-  return idx === len ? unit : Function_dist_effectFunction.pipe(write(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.unsafeGet(idx))), flatMap$1(() => writeChunkWriter(idx + 1, len, chunk)));
-};
-
-/** @internal */
-const zip$1 = /*#__PURE__*/Function_dist_effectFunction.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
-  other: that,
-  onSelfDone: exit1 => mergeDecision.Await(exit2 => Effect_dist_effectEffect.suspend(() => Exit_dist_effectExit.zip(exit1, exit2))),
-  onOtherDone: exit2 => mergeDecision.Await(exit1 => Effect_dist_effectEffect.suspend(() => Exit_dist_effectExit.zip(exit1, exit2)))
-}) : flatMap$1(self, a => map$1(that, b => [a, b])));
-
-/** @internal */
-const zipLeft$1 = /*#__PURE__*/Function_dist_effectFunction.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$1(zip$1(self, that, {
-  concurrent: true
-}), tuple => tuple[0]) : flatMap$1(self, z => as$1(that, z)));
-
-/** @internal */
-const zipRight$1 = /*#__PURE__*/Function_dist_effectFunction.dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? map$1(zip$1(self, that, {
-  concurrent: true
-}), tuple => tuple[1]) : flatMap$1(self, () => that));
-
-/** @internal */
-const ChannelExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Channel/ChannelException");
-
-/** @internal */
-const ChannelException = error => ({
-  _tag: "ChannelException",
-  [ChannelExceptionTypeId]: ChannelExceptionTypeId,
-  error
-});
-
-/** @internal */
-const isChannelException = u => typeof u === "object" && u != null && ChannelExceptionTypeId in u;
-
-/** @internal */
-const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
-
-/** @internal */
-const sinkVariance = {
-  _R: _ => _,
-  _E: _ => _,
-  _In: _ => _,
-  _L: _ => _,
-  _Z: _ => _
-};
-
-/** @internal */
-class SinkImpl {
-  [SinkTypeId] = sinkVariance;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const isSink = u => typeof u === "object" && u != null && SinkTypeId in u;
-
-/** @internal */
-const suspend = evaluate => new SinkImpl(suspend$1(() => toChannel(evaluate())));
-
-/** @internal */
-const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, z) => Function_dist_effectFunction.pipe(self, map(() => z)));
-
-/** @internal */
-const collectAll = () => new SinkImpl(collectAllLoop(Chunk_dist_effectChunk.empty()));
-
-/** @internal */
-const collectAllLoop = acc => readWithCause({
-  onInput: chunk => collectAllLoop(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(chunk))),
-  onFailure: failCause$1,
-  onDone: () => succeed$1(acc)
-});
-
-/** @internal */
-const collectAllN = n => suspend(() => fromChannel(collectAllNLoop(n, Chunk_dist_effectChunk.empty())));
-
-/** @internal */
-const collectAllNLoop = (n, acc) => readWithCause({
-  onInput: chunk => {
-    const [collected, leftovers] = Chunk_dist_effectChunk.splitAt(chunk, n);
-    if (collected.length < n) {
-      return collectAllNLoop(n - collected.length, Chunk_dist_effectChunk.appendAll(acc, collected));
-    }
-    if (Chunk_dist_effectChunk.isEmpty(leftovers)) {
-      return succeed$1(Chunk_dist_effectChunk.appendAll(acc, collected));
-    }
-    return flatMap$1(write(leftovers), () => succeed$1(Chunk_dist_effectChunk.appendAll(acc, collected)));
-  },
-  onFailure: failCause$1,
-  onDone: () => succeed$1(acc)
-});
-
-/** @internal */
-const collectAllFrom = self => collectAllWhileWith(self, {
-  initial: Chunk_dist_effectChunk.empty(),
-  while: Function_dist_effectFunction.constTrue,
-  body: (chunk, z) => Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.append(z))
-});
-
-/** @internal */
-const collectAllToMap = (key, merge) => {
-  return Function_dist_effectFunction.pipe(foldLeftChunks(HashMap_dist_effectHashMap.empty(), (map, chunk) => Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.reduce(map, (map, input) => {
-    const k = key(input);
-    const v = Function_dist_effectFunction.pipe(map, HashMap_dist_effectHashMap.has(k)) ? merge(Function_dist_effectFunction.pipe(map, HashMap_dist_effectHashMap.unsafeGet(k)), input) : input;
-    return Function_dist_effectFunction.pipe(map, HashMap_dist_effectHashMap.set(k, v));
-  }))));
-};
-
-/** @internal */
-const collectAllToMapN = (n, key, merge) => {
-  return foldWeighted({
-    initial: HashMap_dist_effectHashMap.empty(),
-    maxCost: n,
-    cost: (acc, input) => Function_dist_effectFunction.pipe(acc, HashMap_dist_effectHashMap.has(key(input))) ? 0 : 1,
-    body: (acc, input) => {
-      const k = key(input);
-      const v = Function_dist_effectFunction.pipe(acc, HashMap_dist_effectHashMap.has(k)) ? merge(Function_dist_effectFunction.pipe(acc, HashMap_dist_effectHashMap.unsafeGet(k)), input) : input;
-      return Function_dist_effectFunction.pipe(acc, HashMap_dist_effectHashMap.set(k, v));
-    }
-  });
-};
-
-/** @internal */
-const collectAllToSet = () => foldLeftChunks(HashSet_dist_effectHashSet.empty(), (acc, chunk) => Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.reduce(acc, (acc, input) => Function_dist_effectFunction.pipe(acc, HashSet_dist_effectHashSet.add(input)))));
-
-/** @internal */
-const collectAllToSetN = n => foldWeighted({
-  initial: HashSet_dist_effectHashSet.empty(),
-  maxCost: n,
-  cost: (acc, input) => HashSet_dist_effectHashSet.has(acc, input) ? 0 : 1,
-  body: (acc, input) => HashSet_dist_effectHashSet.add(acc, input)
-});
-
-/** @internal */
-const collectAllUntil = p => {
-  return Function_dist_effectFunction.pipe(fold([Chunk_dist_effectChunk.empty(), true], tuple => tuple[1], ([chunk, _], input) => [Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.append(input)), !p(input)]), map(tuple => tuple[0]));
-};
-
-/** @internal */
-const collectAllUntilEffect = p => {
-  return Function_dist_effectFunction.pipe(foldEffect([Chunk_dist_effectChunk.empty(), true], tuple => tuple[1], ([chunk, _], input) => Function_dist_effectFunction.pipe(p(input), Effect_dist_effectEffect.map(bool => [Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.append(input)), !bool]))), map(tuple => tuple[0]));
-};
-
-/** @internal */
-const collectAllWhile = predicate => fromChannel(collectAllWhileReader(predicate, Chunk_dist_effectChunk.empty()));
-
-/** @internal */
-const collectAllWhileReader = (predicate, done) => readWith({
-  onInput: input => {
-    const [collected, leftovers] = Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.toReadonlyArray(input), ReadonlyArray_dist_effectReadonlyArray.span(predicate));
-    if (leftovers.length === 0) {
-      return collectAllWhileReader(predicate, Function_dist_effectFunction.pipe(done, Chunk_dist_effectChunk.appendAll(Chunk_dist_effectChunk.unsafeFromArray(collected))));
-    }
-    return Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.unsafeFromArray(leftovers)), zipRight$1(succeed$1(Function_dist_effectFunction.pipe(done, Chunk_dist_effectChunk.appendAll(Chunk_dist_effectChunk.unsafeFromArray(collected))))));
-  },
-  onFailure: fail$1,
-  onDone: () => succeed$1(done)
-});
-
-/** @internal */
-const collectAllWhileEffect = predicate => fromChannel(collectAllWhileEffectReader(predicate, Chunk_dist_effectChunk.empty()));
-
-/** @internal */
-const collectAllWhileEffectReader = (predicate, done) => readWith({
-  onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.takeWhile(predicate), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray))), flatMap$1(collected => {
-    const leftovers = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(collected.length));
-    if (Chunk_dist_effectChunk.isEmpty(leftovers)) {
-      return collectAllWhileEffectReader(predicate, Function_dist_effectFunction.pipe(done, Chunk_dist_effectChunk.appendAll(collected)));
-    }
-    return Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(succeed$1(Function_dist_effectFunction.pipe(done, Chunk_dist_effectChunk.appendAll(collected)))));
-  })),
-  onFailure: fail$1,
-  onDone: () => succeed$1(done)
-});
-
-/** @internal */
-const collectAllWhileWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const refs = Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(Chunk_dist_effectChunk.empty()), Effect_dist_effectEffect.zip(Ref_dist_effectRef.make(false)));
-  const newChannel = Function_dist_effectFunction.pipe(fromEffect$1(refs), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
-    const upstreamMarker = readWith({
-      onInput: input => Function_dist_effectFunction.pipe(write(input), flatMap$1(() => upstreamMarker)),
-      onFailure: fail$1,
-      onDone: done => Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.set(upstreamDoneRef, true)), as$1(done))
-    });
-    return Function_dist_effectFunction.pipe(upstreamMarker, pipeTo(bufferChunk(leftoversRef)), pipeTo(collectAllWhileWithLoop(self, leftoversRef, upstreamDoneRef, options.initial, options.while, options.body)));
-  }));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const collectAllWhileWithLoop = (self, leftoversRef, upstreamDoneRef, currentResult, p, f) => {
-  return Function_dist_effectFunction.pipe(toChannel(self), doneCollect, foldChannel({
-    onFailure: fail$1,
-    onSuccess: ([leftovers, doneValue]) => p(doneValue) ? Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.set(leftoversRef, Chunk_dist_effectChunk.flatten(leftovers))), flatMap$1(() => Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.get(upstreamDoneRef)), flatMap$1(upstreamDone => {
-      const accumulatedResult = f(currentResult, doneValue);
-      return upstreamDone ? Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.flatten(leftovers)), as$1(accumulatedResult)) : collectAllWhileWithLoop(self, leftoversRef, upstreamDoneRef, accumulatedResult, p, f);
-    })))) : Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.flatten(leftovers)), as$1(currentResult))
-  }));
-};
-
-/** @internal */
-const collectLeftover = self => new SinkImpl(Function_dist_effectFunction.pipe(collectElements(toChannel(self)), map$1(([chunks, z]) => [z, Chunk_dist_effectChunk.flatten(chunks)])));
-
-/** @internal */
-const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapInputChunks(Chunk_dist_effectChunk.map(f))));
-
-/** @internal */
-const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapInputChunksEffect(self, chunk => Effect_dist_effectEffect.map(Effect_dist_effectEffect.forEach(chunk, v => f(v)), Chunk_dist_effectChunk.unsafeFromArray)));
-
-/** @internal */
-const mapInputChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const loop = readWith({
-    onInput: chunk => Function_dist_effectFunction.pipe(write(f(chunk)), flatMap$1(() => loop)),
-    onFailure: fail$1,
-    onDone: succeed$1
-  });
-  return new SinkImpl(Function_dist_effectFunction.pipe(loop, pipeTo(toChannel(self))));
-});
-
-/** @internal */
-const mapInputChunksEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const loop = readWith({
-    onInput: chunk => Function_dist_effectFunction.pipe(fromEffect$1(f(chunk)), flatMap$1(write), flatMap$1(() => loop)),
-    onFailure: fail$1,
-    onDone: succeed$1
-  });
-  return new SinkImpl(Function_dist_effectFunction.pipe(loop, pipeToOrFail(toChannel(self))));
-});
-
-/** @internal */
-const die = defect => failCause(Cause_dist_effectCause.die(defect));
-
-/** @internal */
-const dieMessage = message => failCause(Cause_dist_effectCause.die(Cause_dist_effectCause.RuntimeException(message)));
-
-/** @internal */
-const dieSync = evaluate => failCauseSync(() => Cause_dist_effectCause.die(evaluate()));
-
-/** @internal */
-const dimap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => map(mapInput(self, options.onInput), options.onDone));
-
-/** @internal */
-const dimapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => mapEffect(mapInputEffect(self, options.onInput), options.onDone));
-
-/** @internal */
-const dimapChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => map(mapInputChunks(self, options.onInput), options.onDone));
-
-/** @internal */
-const dimapChunksEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => mapEffect(mapInputChunksEffect(self, options.onInput), options.onDone));
-
-/** @internal */
-const drain = /*#__PURE__*/new SinkImpl( /*#__PURE__*/drain$1( /*#__PURE__*/identityChannel()));
-
-/** @internal */
-const drop = n => suspend(() => new SinkImpl(dropLoop(n)));
-
-/** @internal */
-const dropLoop = n => readWith({
-  onInput: input => {
-    const dropped = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(n));
-    const leftover = Math.max(n - input.length, 0);
-    const more = Chunk_dist_effectChunk.isEmpty(input) || leftover > 0;
-    if (more) {
-      return dropLoop(leftover);
-    }
-    return Function_dist_effectFunction.pipe(write(dropped), zipRight$1(identityChannel()));
-  },
-  onFailure: fail$1,
-  onDone: () => unit
-});
-
-/** @internal */
-const dropUntil = predicate => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(dropWhile(input => !predicate(input))), pipeToOrFail(toChannel(drop(1)))));
-
-/** @internal */
-const dropUntilEffect = predicate => suspend(() => new SinkImpl(dropUntilEffectReader(predicate)));
-
-/** @internal */
-const dropUntilEffectReader = predicate => readWith({
-  onInput: input => Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.dropUntil(predicate), Effect_dist_effectEffect.map(leftover => {
-    const more = leftover.length === 0;
-    return more ? dropUntilEffectReader(predicate) : Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.unsafeFromArray(leftover)), zipRight$1(identityChannel()));
-  }), unwrap$1),
-  onFailure: fail$1,
-  onDone: () => unit
-});
-
-/** @internal */
-const dropWhile = predicate => new SinkImpl(dropWhileReader(predicate));
-
-/** @internal */
-const dropWhileReader = predicate => readWith({
-  onInput: input => {
-    const out = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.dropWhile(predicate));
-    if (Chunk_dist_effectChunk.isEmpty(out)) {
-      return dropWhileReader(predicate);
-    }
-    return Function_dist_effectFunction.pipe(write(out), zipRight$1(identityChannel()));
-  },
-  onFailure: fail$1,
-  onDone: succeedNow
-});
-
-/** @internal */
-const dropWhileEffect = predicate => suspend(() => new SinkImpl(dropWhileEffectReader(predicate)));
-
-/** @internal */
-const dropWhileEffectReader = predicate => readWith({
-  onInput: input => Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.dropWhile(predicate), Effect_dist_effectEffect.map(leftover => {
-    const more = leftover.length === 0;
-    return more ? dropWhileEffectReader(predicate) : Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.unsafeFromArray(leftover)), zipRight$1(identityChannel()));
-  }), unwrap$1),
-  onFailure: fail$1,
-  onDone: () => unit
-});
-
-/** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new SinkImpl(Function_dist_effectFunction.pipe(self, toChannel, ensuring$1(finalizer))));
-
-/** @internal */
-const ensuringWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new SinkImpl(Function_dist_effectFunction.pipe(self, toChannel, ensuringWith$1(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(), mapEffect(f));
-
-/** @internal */
-const contextWithSink = f => new SinkImpl(unwrap$1(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.contextWith(context => toChannel(f(context))))));
-
-/** @internal */
-const every = predicate => fold(true, Function_dist_effectFunction.identity, (acc, input) => acc && predicate(input));
-
-/** @internal */
-const fail = e => new SinkImpl(fail$1(e));
-
-/** @internal */
-const failSync = evaluate => new SinkImpl(failSync$1(evaluate));
-
-/** @internal */
-const failCause = cause => new SinkImpl(failCause$1(cause));
-
-/** @internal */
-const failCauseSync = evaluate => new SinkImpl(failCauseSync$1(evaluate));
-
-/** @internal */
-const filterInput = f => {
-  return self => Function_dist_effectFunction.pipe(self, mapInputChunks(Chunk_dist_effectChunk.filter(f)));
-};
-
-/** @internal */
-const filterInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapInputChunksEffect(self, chunk => Effect_dist_effectEffect.map(Effect_dist_effectEffect.filter(chunk, f), Chunk_dist_effectChunk.unsafeFromArray)));
-
-/** @internal */
-const findEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const newChannel = Function_dist_effectFunction.pipe(fromEffect$1(Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(Chunk_dist_effectChunk.empty()), Effect_dist_effectEffect.zip(Ref_dist_effectRef.make(false)))), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
-    const upstreamMarker = readWith({
-      onInput: input => Function_dist_effectFunction.pipe(write(input), flatMap$1(() => upstreamMarker)),
-      onFailure: fail$1,
-      onDone: done => Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.set(upstreamDoneRef, true)), as$1(done))
-    });
-    const loop = foldChannel(collectElements(toChannel(self)), {
-      onFailure: fail$1,
-      onSuccess: ([leftovers, doneValue]) => Function_dist_effectFunction.pipe(fromEffect$1(f(doneValue)), flatMap$1(satisfied => Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.set(leftoversRef, Chunk_dist_effectChunk.flatten(leftovers))), zipRight$1(Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.get(upstreamDoneRef)), flatMap$1(upstreamDone => {
-        if (satisfied) {
-          return Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.flatten(leftovers)), as$1(Option_dist_effectOption.some(doneValue)));
-        }
-        if (upstreamDone) {
-          return Function_dist_effectFunction.pipe(write(Chunk_dist_effectChunk.flatten(leftovers)), as$1(Option_dist_effectOption.none()));
-        }
-        return loop;
-      }))))))
-    });
-    return Function_dist_effectFunction.pipe(upstreamMarker, pipeTo(bufferChunk(leftoversRef)), pipeTo(loop));
-  }));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const fold = (s, contFn, f) => suspend(() => new SinkImpl(foldReader(s, contFn, f)));
-
-/** @internal */
-const foldReader = (s, contFn, f) => {
-  if (!contFn(s)) {
-    return succeedNow(s);
-  }
-  return readWith({
-    onInput: input => {
-      const [nextS, leftovers] = foldChunkSplit(s, input, contFn, f, 0, input.length);
-      if (Chunk_dist_effectChunk.isNonEmpty(leftovers)) {
-        return Function_dist_effectFunction.pipe(write(leftovers), as$1(nextS));
-      }
-      return foldReader(nextS, contFn, f);
-    },
-    onFailure: fail$1,
-    onDone: () => succeedNow(s)
-  });
-};
-
-/** @internal */
-const foldChunkSplit = (s, chunk, contFn, f, index, length) => {
-  if (index === length) {
-    return [s, Chunk_dist_effectChunk.empty()];
-  }
-  const s1 = f(s, Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.unsafeGet(index)));
-  if (contFn(s1)) {
-    return foldChunkSplit(s1, chunk, contFn, f, index + 1, length);
-  }
-  return [s1, Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.drop(index + 1))];
-};
-
-/** @internal */
-const foldSink = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const newChannel = Function_dist_effectFunction.pipe(toChannel(self), collectElements, foldChannel({
-    onFailure: error => toChannel(options.onFailure(error)),
-    onSuccess: ([leftovers, z]) => suspend$1(() => {
-      const leftoversRef = {
-        ref: Function_dist_effectFunction.pipe(leftovers, Chunk_dist_effectChunk.filter(Chunk_dist_effectChunk.isNonEmpty))
-      };
-      const refReader = Function_dist_effectFunction.pipe(sync$1(() => {
-        const ref = leftoversRef.ref;
-        leftoversRef.ref = Chunk_dist_effectChunk.empty();
-        return ref;
-      }),
-      // This cast is safe because of the L1 >: L <: In1 bound. It follows that
-      // L <: In1 and therefore Chunk[L] can be safely cast to Chunk[In1].
-      flatMap$1(chunk => writeChunk(chunk)));
-      const passthrough = identityChannel();
-      const continuationSink = Function_dist_effectFunction.pipe(refReader, zipRight$1(passthrough), pipeTo(toChannel(options.onSuccess(z))));
-      return flatMap$1(collectElements(continuationSink), ([newLeftovers, z1]) => Function_dist_effectFunction.pipe(succeed$1(leftoversRef.ref), flatMap$1(writeChunk), zipRight$1(writeChunk(newLeftovers)), as$1(z1)));
-    })
-  }));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const foldChunks = (s, contFn, f) => suspend(() => new SinkImpl(foldChunksReader(s, contFn, f)));
-
-/** @internal */
-const foldChunksReader = (s, contFn, f) => {
-  if (!contFn(s)) {
-    return succeedNow(s);
-  }
-  return readWith({
-    onInput: input => foldChunksReader(f(s, input), contFn, f),
-    onFailure: fail$1,
-    onDone: () => succeedNow(s)
-  });
-};
-
-/** @internal */
-const foldChunksEffect = (s, contFn, f) => suspend(() => new SinkImpl(foldChunksEffectReader(s, contFn, f)));
-
-/** @internal */
-const foldChunksEffectReader = (s, contFn, f) => {
-  if (!contFn(s)) {
-    return succeedNow(s);
-  }
-  return readWith({
-    onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(f(s, input)), flatMap$1(s => foldChunksEffectReader(s, contFn, f))),
-    onFailure: fail$1,
-    onDone: () => succeedNow(s)
-  });
-};
-
-/** @internal */
-const foldEffect = (s, contFn, f) => suspend(() => new SinkImpl(foldEffectReader(s, contFn, f)));
-
-/** @internal */
-const foldEffectReader = (s, contFn, f) => {
-  if (!contFn(s)) {
-    return succeedNow(s);
-  }
-  return readWith({
-    onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(foldChunkSplitEffect(s, input, contFn, f)), flatMap$1(([nextS, leftovers]) => Function_dist_effectFunction.pipe(leftovers, Option_dist_effectOption.match({
-      onNone: () => foldEffectReader(nextS, contFn, f),
-      onSome: leftover => Function_dist_effectFunction.pipe(write(leftover), as$1(nextS))
-    })))),
-    onFailure: fail$1,
-    onDone: () => succeedNow(s)
-  });
-};
-
-/** @internal */
-const foldChunkSplitEffect = (s, chunk, contFn, f) => foldChunkSplitEffectInternal(s, chunk, 0, chunk.length, contFn, f);
-
-/** @internal */
-const foldChunkSplitEffectInternal = (s, chunk, index, length, contFn, f) => {
-  if (index === length) {
-    return Effect_dist_effectEffect.succeed([s, Option_dist_effectOption.none()]);
-  }
-  return Function_dist_effectFunction.pipe(f(s, Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.unsafeGet(index))), Effect_dist_effectEffect.flatMap(s1 => contFn(s1) ? foldChunkSplitEffectInternal(s1, chunk, index + 1, length, contFn, f) : Effect_dist_effectEffect.succeed([s1, Option_dist_effectOption.some(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.drop(index + 1)))])));
-};
-
-/** @internal */
-const foldLeft = (s, f) => ignoreLeftover(fold(s, Function_dist_effectFunction.constTrue, f));
-
-/** @internal */
-const foldLeftChunks = (s, f) => foldChunks(s, Function_dist_effectFunction.constTrue, f);
-
-/** @internal */
-const foldLeftChunksEffect = (s, f) => ignoreLeftover(foldChunksEffect(s, Function_dist_effectFunction.constTrue, f));
-
-/** @internal */
-const foldLeftEffect = (s, f) => foldEffect(s, Function_dist_effectFunction.constTrue, f);
-
-/** @internal */
-const foldUntil = (s, max, f) => Function_dist_effectFunction.pipe(fold([s, 0], tuple => tuple[1] < max, ([output, count], input) => [f(output, input), count + 1]), map(tuple => tuple[0]));
-
-/** @internal */
-const foldUntilEffect = (s, max, f) => Function_dist_effectFunction.pipe(foldEffect([s, 0], tuple => tuple[1] < max, ([output, count], input) => Function_dist_effectFunction.pipe(f(output, input), Effect_dist_effectEffect.map(s => [s, count + 1]))), map(tuple => tuple[0]));
-
-/** @internal */
-const foldWeighted = options => foldWeightedDecompose({
-  ...options,
-  decompose: Chunk_dist_effectChunk.of
-});
-
-/** @internal */
-const foldWeightedDecompose = options => suspend(() => new SinkImpl(foldWeightedDecomposeLoop(options.initial, 0, false, options.maxCost, options.cost, options.decompose, options.body)));
-
-/** @internal */
-const foldWeightedDecomposeLoop = (s, cost, dirty, max, costFn, decompose, f) => readWith({
-  onInput: input => {
-    const [nextS, nextCost, nextDirty, leftovers] = foldWeightedDecomposeFold(input, 0, s, cost, dirty, max, costFn, decompose, f);
-    if (Chunk_dist_effectChunk.isNonEmpty(leftovers)) {
-      return Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(succeedNow(nextS)));
-    }
-    if (cost > max) {
-      return succeedNow(nextS);
-    }
-    return foldWeightedDecomposeLoop(nextS, nextCost, nextDirty, max, costFn, decompose, f);
-  },
-  onFailure: fail$1,
-  onDone: () => succeedNow(s)
-});
-
-/** @internal */
-const foldWeightedDecomposeFold = (input, index, s, cost, dirty, max, costFn, decompose, f) => {
-  if (index === input.length) {
-    return [s, cost, dirty, Chunk_dist_effectChunk.empty()];
-  }
-  const elem = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.unsafeGet(index));
-  const total = cost + costFn(s, elem);
-  if (total <= max) {
-    return foldWeightedDecomposeFold(input, index + 1, f(s, elem), total, true, max, costFn, decompose, f);
-  }
-  const decomposed = decompose(elem);
-  if (decomposed.length <= 1 && !dirty) {
-    // If `elem` cannot be decomposed, we need to cross the `max` threshold. To
-    // minimize "injury", we only allow this when we haven't added anything else
-    // to the aggregate (dirty = false).
-    return [f(s, elem), total, true, Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index + 1))];
-  }
-  if (decomposed.length <= 1 && dirty) {
-    // If the state is dirty and `elem` cannot be decomposed, we stop folding
-    // and include `elem` in the leftovers.
-    return [s, cost, dirty, Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index))];
-  }
-  // `elem` got decomposed, so we will recurse with the decomposed elements pushed
-  // into the chunk we're processing and see if we can aggregate further.
-  const next = Function_dist_effectFunction.pipe(decomposed, Chunk_dist_effectChunk.appendAll(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index + 1))));
-  return foldWeightedDecomposeFold(next, 0, s, cost, dirty, max, costFn, decompose, f);
-};
-
-/** @internal */
-const foldWeightedDecomposeEffect = options => suspend(() => new SinkImpl(foldWeightedDecomposeEffectLoop(options.initial, options.maxCost, options.cost, options.decompose, options.body, 0, false)));
-
-/** @internal */
-const foldWeightedEffect = options => foldWeightedDecomposeEffect({
-  ...options,
-  decompose: input => Effect_dist_effectEffect.succeed(Chunk_dist_effectChunk.of(input))
-});
-
-/** @internal */
-const foldWeightedDecomposeEffectLoop = (s, max, costFn, decompose, f, cost, dirty) => readWith({
-  onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, dirty, cost, 0)), flatMap$1(([nextS, nextCost, nextDirty, leftovers]) => {
-    if (Chunk_dist_effectChunk.isNonEmpty(leftovers)) {
-      return Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(succeedNow(nextS)));
-    }
-    if (cost > max) {
-      return succeedNow(nextS);
-    }
-    return foldWeightedDecomposeEffectLoop(nextS, max, costFn, decompose, f, nextCost, nextDirty);
-  })),
-  onFailure: fail$1,
-  onDone: () => succeedNow(s)
-});
-
-/** @internal */
-const foldWeightedDecomposeEffectFold = (s, max, costFn, decompose, f, input, dirty, cost, index) => {
-  if (index === input.length) {
-    return Effect_dist_effectEffect.succeed([s, cost, dirty, Chunk_dist_effectChunk.empty()]);
-  }
-  const elem = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.unsafeGet(index));
-  return Function_dist_effectFunction.pipe(costFn(s, elem), Effect_dist_effectEffect.map(newCost => cost + newCost), Effect_dist_effectEffect.flatMap(total => {
-    if (total <= max) {
-      return Function_dist_effectFunction.pipe(f(s, elem), Effect_dist_effectEffect.flatMap(s => foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, true, total, index + 1)));
-    }
-    return Function_dist_effectFunction.pipe(decompose(elem), Effect_dist_effectEffect.flatMap(decomposed => {
-      if (decomposed.length <= 1 && !dirty) {
-        // If `elem` cannot be decomposed, we need to cross the `max` threshold. To
-        // minimize "injury", we only allow this when we haven't added anything else
-        // to the aggregate (dirty = false).
-        return Function_dist_effectFunction.pipe(f(s, elem), Effect_dist_effectEffect.map(s => [s, total, true, Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index + 1))]));
-      }
-      if (decomposed.length <= 1 && dirty) {
-        // If the state is dirty and `elem` cannot be decomposed, we stop folding
-        // and include `elem` in th leftovers.
-        return Effect_dist_effectEffect.succeed([s, cost, dirty, Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index))]);
-      }
-      // `elem` got decomposed, so we will recurse with the decomposed elements pushed
-      // into the chunk we're processing and see if we can aggregate further.
-      const next = Function_dist_effectFunction.pipe(decomposed, Chunk_dist_effectChunk.appendAll(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index + 1))));
-      return foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, next, dirty, cost, 0);
-    }));
-  }));
-};
-
-/** @internal */
-const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => foldSink(self, {
-  onFailure: fail,
-  onSuccess: f
-}));
-
-/** @internal */
-const forEach = f => {
-  const process = readWithCause({
-    onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(Effect_dist_effectEffect.forEach(input, v => f(v), {
-      discard: true
-    })), flatMap$1(() => process)),
-    onFailure: failCause$1,
-    onDone: () => unit
-  });
-  return new SinkImpl(process);
-};
-
-/** @internal */
-const forEachChunk = f => {
-  const process = readWithCause({
-    onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(f(input)), flatMap$1(() => process)),
-    onFailure: failCause$1,
-    onDone: () => unit
-  });
-  return new SinkImpl(process);
-};
-
-/** @internal */
-const forEachWhile = f => {
-  const process = readWithCause({
-    onInput: input => forEachWhileReader(f, input, 0, input.length, process),
-    onFailure: failCause$1,
-    onDone: () => unit
-  });
-  return new SinkImpl(process);
-};
-
-/** @internal */
-const forEachWhileReader = (f, input, index, length, cont) => {
-  if (index === length) {
-    return cont;
-  }
-  return Function_dist_effectFunction.pipe(fromEffect$1(f(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.unsafeGet(index)))), flatMap$1(bool => bool ? forEachWhileReader(f, input, index + 1, length, cont) : write(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index)))), catchAll(error => Function_dist_effectFunction.pipe(write(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(index))), zipRight$1(fail$1(error)))));
-};
-
-/** @internal */
-const forEachChunkWhile = f => {
-  const reader = readWith({
-    onInput: input => Function_dist_effectFunction.pipe(fromEffect$1(f(input)), flatMap$1(cont => cont ? reader : unit)),
-    onFailure: fail$1,
-    onDone: () => unit
-  });
-  return new SinkImpl(reader);
-};
-
-/** @internal */
-const fromChannel = channel => new SinkImpl(channel);
-
-/** @internal */
-const fromEffect = effect => new SinkImpl(fromEffect$1(effect));
-
-/** @internal */
-const fromHub = (hub, options) => fromQueue(hub, options);
-
-/** @internal */
-const fromPush = push => new SinkImpl(unwrapScoped$1(Function_dist_effectFunction.pipe(push, Effect_dist_effectEffect.map(fromPushPull))));
-const fromPushPull = push => readWith({
-  onInput: input => foldChannel(fromEffect$1(push(Option_dist_effectOption.some(input))), {
-    onFailure: ([either, leftovers]) => Either_dist_effectEither.match(either, {
-      onLeft: error => Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(fail$1(error))),
-      onRight: z => Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(succeedNow(z)))
-    }),
-    onSuccess: () => fromPushPull(push)
-  }),
-  onFailure: fail$1,
-  onDone: () => foldChannel(fromEffect$1(push(Option_dist_effectOption.none())), {
-    onFailure: ([either, leftovers]) => Either_dist_effectEither.match(either, {
-      onLeft: error => Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(fail$1(error))),
-      onRight: z => Function_dist_effectFunction.pipe(write(leftovers), zipRight$1(succeedNow(z)))
-    }),
-    onSuccess: () => fromEffect$1(Effect_dist_effectEffect.dieMessage("BUG: Sink.fromPush - please report an issue at https://github.com/Effect-TS/stream/issues"))
-  })
-});
-
-/** @internal */
-const fromQueue = (queue, options) => options?.shutdown ? unwrapScoped(Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.succeed(queue), Queue_dist_effectQueue.shutdown), fromQueue)) : forEachChunk(input => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offerAll(queue, input)));
-
-/** @internal */
-const head = () => fold(Option_dist_effectOption.none(), Option_dist_effectOption.isNone, (option, input) => Option_dist_effectOption.match(option, {
-  onNone: () => Option_dist_effectOption.some(input),
-  onSome: () => option
-}));
-
-/** @internal */
-const ignoreLeftover = self => new SinkImpl(drain$1(toChannel(self)));
-
-/** @internal */
-const last = () => foldLeftChunks(Option_dist_effectOption.none(), (s, input) => Option_dist_effectOption.orElse(Chunk_dist_effectChunk.last(input), () => s));
-
-/** @internal */
-const leftover = chunk => new SinkImpl(suspend$1(() => write(chunk)));
-
-/** @internal */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  return new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), map$1(f)));
-});
-
-/** @internal */
-const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), mapEffect$1(f))));
-
-/** @internal */
-const mapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), mapError$1(f))));
-
-/** @internal */
-const mapLeftover = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), mapOut(Chunk_dist_effectChunk.map(f)))));
-
-/** @internal */
-const never = /*#__PURE__*/fromEffect(Effect_dist_effectEffect.never);
-
-/** @internal */
-const orElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), orElse$1(() => toChannel(that())))));
-
-/** @internal */
-const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => new SinkImpl(Function_dist_effectFunction.pipe(toChannel(self), provideContext$1(context))));
-
-/** @internal */
-const race = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, raceBoth(that), map(Either_dist_effectEither.merge)));
-
-/** @internal */
-const raceBoth = /*#__PURE__*/Function_dist_effectFunction.dual(args => isSink(args[1]), (self, that, options) => raceWith(self, {
-  other: that,
-  onSelfDone: selfDone => mergeDecision.Done(Effect_dist_effectEffect.map(selfDone, Either_dist_effectEither.left)),
-  onOtherDone: thatDone => mergeDecision.Done(Effect_dist_effectEffect.map(thatDone, Either_dist_effectEither.right)),
-  capacity: options?.capacity ?? 16
-}));
-
-/** @internal */
-const raceWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const scoped = Effect_dist_effectEffect.gen(function* ($) {
-    const hub = yield* $(Hub_dist_effectHub.bounded(options?.capacity ?? 16));
-    const channel1 = yield* $(fromHubScoped(hub));
-    const channel2 = yield* $(fromHubScoped(hub));
-    const reader = toHub(hub);
-    const writer = Function_dist_effectFunction.pipe(channel1, pipeTo(toChannel(self)), mergeWith({
-      other: Function_dist_effectFunction.pipe(channel2, pipeTo(toChannel(options.other))),
-      onSelfDone: options.onSelfDone,
-      onOtherDone: options.onOtherDone
-    }));
-    const racedChannel = mergeWith(reader, {
-      other: writer,
-      onSelfDone: _ => mergeDecision.Await(exit => Effect_dist_effectEffect.suspend(() => exit)),
-      onOtherDone: done => mergeDecision.Done(Effect_dist_effectEffect.suspend(() => done))
-    });
-    return new SinkImpl(racedChannel);
-  });
-  return unwrapScoped(scoped);
-});
-
-/** @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) => {
-  const newChannel = Function_dist_effectFunction.pipe(self, toChannel, catchAll(error => Option_dist_effectOption.match(pf(error), {
-    onNone: () => failCauseSync$1(() => Cause_dist_effectCause.die(f(error))),
-    onSome: fail$1
-  })));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const some = predicate => fold(false, bool => !bool, (acc, input) => acc || predicate(input));
-
-/** @internal */
-const splitWhere = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const newChannel = Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.make(Chunk_dist_effectChunk.empty())), flatMap$1(ref => Function_dist_effectFunction.pipe(splitWhereSplitter(false, ref, f), pipeToOrFail(toChannel(self)), collectElements, flatMap$1(([leftovers, z]) => Function_dist_effectFunction.pipe(fromEffect$1(Ref_dist_effectRef.get(ref)), flatMap$1(leftover => Function_dist_effectFunction.pipe(write(Function_dist_effectFunction.pipe(leftover, Chunk_dist_effectChunk.appendAll(Chunk_dist_effectChunk.flatten(leftovers)))), zipRight$1(succeed$1(z)))))))));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const splitWhereSplitter = (written, leftovers, f) => readWithCause({
-  onInput: input => {
-    if (Chunk_dist_effectChunk.isEmpty(input)) {
-      return splitWhereSplitter(written, leftovers, f);
-    }
-    if (written) {
-      const index = indexWhere(input, f);
-      if (index === -1) {
-        return zipRight$1(write(input), splitWhereSplitter(true, leftovers, f));
-      }
-      const [left, right] = Chunk_dist_effectChunk.splitAt(input, index);
-      return zipRight$1(write(left), fromEffect$1(Ref_dist_effectRef.set(leftovers, right)));
-    }
-    const index = indexWhere(input, f, 1);
-    if (index === -1) {
-      return zipRight$1(write(input), splitWhereSplitter(true, leftovers, f));
-    }
-    const [left, right] = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.splitAt(Math.max(index, 1)));
-    return zipRight$1(write(left), fromEffect$1(Ref_dist_effectRef.set(leftovers, right)));
-  },
-  onFailure: failCause$1,
-  onDone: succeed$1
-});
-
-/** @internal */
-const indexWhere = (self, predicate, from = 0) => {
-  const iterator = self[Symbol.iterator]();
-  let index = 0;
-  let result = -1;
-  let next;
-  while (result < 0 && (next = iterator.next()) && !next.done) {
-    const a = next.value;
-    if (index >= from && predicate(a)) {
-      result = index;
-    }
-    index = index + 1;
-  }
-  return result;
-};
-
-/** @internal */
-const succeed = z => new SinkImpl(succeed$1(z));
-
-/** @internal */
-const sum = /*#__PURE__*/foldLeftChunks(0, (acc, chunk) => acc + Chunk_dist_effectChunk.reduce(chunk, 0, (s, a) => s + a));
-
-/** @internal */
-const summarized = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, summary, f) => {
-  const newChannel = Function_dist_effectFunction.pipe(fromEffect$1(summary), flatMap$1(start => Function_dist_effectFunction.pipe(self, toChannel, flatMap$1(done => Function_dist_effectFunction.pipe(fromEffect$1(summary), map$1(end => [done, f(start, end)]))))));
-  return new SinkImpl(newChannel);
-});
-
-/** @internal */
-const sync = evaluate => new SinkImpl(sync$1(evaluate));
-
-/** @internal */
-const take = n => Function_dist_effectFunction.pipe(foldChunks(Chunk_dist_effectChunk.empty(), chunk => chunk.length < n, (acc, chunk) => Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(chunk))), flatMap(acc => {
-  const [taken, leftover] = Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.splitAt(n));
-  return new SinkImpl(Function_dist_effectFunction.pipe(write(leftover), zipRight$1(succeedNow(taken))));
-}));
-
-/** @internal */
-const toChannel = self => Effect_dist_effectEffect.isEffect(self) ? toChannel(fromEffect(self)) : self.channel;
-
-/** @internal */
-const unwrap = effect => new SinkImpl(unwrap$1(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(sink => toChannel(sink)))));
-
-/** @internal */
-const unwrapScoped = effect => {
-  return new SinkImpl(unwrapScoped$1(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(sink => toChannel(sink)))));
-};
-
-/** @internal */
-const withDuration = self => Function_dist_effectFunction.pipe(self, summarized(Clock_dist_effectClock.currentTimeMillis, (start, end) => Duration_dist_effectDuration.millis(end - start)));
-
-/** @internal */
-const zip = /*#__PURE__*/Function_dist_effectFunction.dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, z2) => [z, z2], options));
-
-/** @internal */
-const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, _) => z, options));
-
-/** @internal */
-const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (_, z2) => z2, options));
-
-/** @internal */
-const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(args => isSink(args[1]), (self, that, f, options) => options?.concurrent ? raceWith(self, {
-  other: that,
-  onSelfDone: Exit_dist_effectExit.match({
-    onFailure: cause => mergeDecision.Done(Effect_dist_effectEffect.failCause(cause)),
-    onSuccess: leftZ => mergeDecision.Await(Exit_dist_effectExit.match({
-      onFailure: Effect_dist_effectEffect.failCause,
-      onSuccess: rightZ => Effect_dist_effectEffect.succeed(f(leftZ, rightZ))
-    }))
-  }),
-  onOtherDone: Exit_dist_effectExit.match({
-    onFailure: cause => mergeDecision.Done(Effect_dist_effectEffect.failCause(cause)),
-    onSuccess: rightZ => mergeDecision.Await(Exit_dist_effectExit.match({
-      onFailure: Effect_dist_effectEffect.failCause,
-      onSuccess: leftZ => Effect_dist_effectEffect.succeed(f(leftZ, rightZ))
-    }))
-  })
-}) : flatMap(self, z => map(that, z2 => f(z, z2))));
-
-// Circular with Channel
-
-/** @internal */
-const channelToSink = self => new SinkImpl(self);
-
-// Constants
-
-/** @internal */
-const count = /*#__PURE__*/foldLeftChunks(0, (acc, chunk) => acc + chunk.length);
-
-/** @internal */
-const mkString = /*#__PURE__*/suspend(() => {
-  const strings = [];
-  return Function_dist_effectFunction.pipe(foldLeftChunks(void 0, (_, elems) => Chunk_dist_effectChunk.map(elems, elem => {
-    strings.push(String(elem));
-  })), map(() => strings.join("")));
-});
-
-/** @internal */
-const timed = /*#__PURE__*/Function_dist_effectFunction.pipe( /*#__PURE__*/withDuration(drain), /*#__PURE__*/map(tuple => tuple[1]));
-
-exports.ChannelException = ChannelException;
-exports.ChannelExceptionTypeId = ChannelExceptionTypeId;
-exports.ChannelTypeId = ChannelTypeId;
-exports.SinkTypeId = SinkTypeId;
-exports.acquireReleaseOut = acquireReleaseOut;
-exports.acquireUseRelease = acquireUseRelease;
-exports.as = as;
-exports.as$1 = as$1;
-exports.asUnit = asUnit;
-exports.buffer = buffer;
-exports.bufferChunk = bufferChunk;
-exports.catchAll = catchAll;
-exports.catchAllCause = catchAllCause;
-exports.channelToSink = channelToSink;
-exports.collect = collect;
-exports.collectAll = collectAll;
-exports.collectAllFrom = collectAllFrom;
-exports.collectAllN = collectAllN;
-exports.collectAllToMap = collectAllToMap;
-exports.collectAllToMapN = collectAllToMapN;
-exports.collectAllToSet = collectAllToSet;
-exports.collectAllToSetN = collectAllToSetN;
-exports.collectAllUntil = collectAllUntil;
-exports.collectAllUntilEffect = collectAllUntilEffect;
-exports.collectAllWhile = collectAllWhile;
-exports.collectAllWhileEffect = collectAllWhileEffect;
-exports.collectAllWhileWith = collectAllWhileWith;
-exports.collectElements = collectElements;
-exports.collectLeftover = collectLeftover;
-exports.concatAll = concatAll;
-exports.concatAllWith = concatAllWith;
-exports.concatMap = concatMap;
-exports.concatMapWith = concatMapWith;
-exports.concatMapWithCustom = concatMapWithCustom;
-exports.concatOut = concatOut;
-exports.context = context;
-exports.context$1 = context$1;
-exports.contextWith = contextWith;
-exports.contextWith$1 = contextWith$1;
-exports.contextWithChannel = contextWithChannel;
-exports.contextWithEffect = contextWithEffect;
-exports.contextWithEffect$1 = contextWithEffect$1;
-exports.contextWithSink = contextWithSink;
-exports.count = count;
-exports.die = die;
-exports.dieMessage = dieMessage;
-exports.dieSync = dieSync;
-exports.dimap = dimap;
-exports.dimapChunks = dimapChunks;
-exports.dimapChunksEffect = dimapChunksEffect;
-exports.dimapEffect = dimapEffect;
-exports.doneCollect = doneCollect;
-exports.drain = drain$1;
-exports.drain$1 = drain;
-exports.drop = drop;
-exports.dropUntil = dropUntil;
-exports.dropUntilEffect = dropUntilEffect;
-exports.dropWhile = dropWhile;
-exports.dropWhileEffect = dropWhileEffect;
-exports.embedInput = embedInput;
-exports.emitCollect = emitCollect;
-exports.ensuring = ensuring$1;
-exports.ensuring$1 = ensuring;
-exports.ensuringWith = ensuringWith$1;
-exports.ensuringWith$1 = ensuringWith;
-exports.every = every;
-exports.fail = fail$1;
-exports.fail$1 = fail;
-exports.failCause = failCause$1;
-exports.failCause$1 = failCause;
-exports.failCauseSync = failCauseSync;
-exports.failCauseSync$1 = failCauseSync$1;
-exports.failSync = failSync;
-exports.failSync$1 = failSync$1;
-exports.filterInput = filterInput;
-exports.filterInputEffect = filterInputEffect;
-exports.findEffect = findEffect;
-exports.flatMap = flatMap$1;
-exports.flatMap$1 = flatMap;
-exports.flatten = flatten;
-exports.fold = fold;
-exports.foldCauseChannel = foldCauseChannel;
-exports.foldChannel = foldChannel;
-exports.foldChunks = foldChunks;
-exports.foldChunksEffect = foldChunksEffect;
-exports.foldEffect = foldEffect;
-exports.foldLeft = foldLeft;
-exports.foldLeftChunks = foldLeftChunks;
-exports.foldLeftChunksEffect = foldLeftChunksEffect;
-exports.foldLeftEffect = foldLeftEffect;
-exports.foldSink = foldSink;
-exports.foldUntil = foldUntil;
-exports.foldUntilEffect = foldUntilEffect;
-exports.foldWeighted = foldWeighted;
-exports.foldWeightedDecompose = foldWeightedDecompose;
-exports.foldWeightedDecomposeEffect = foldWeightedDecomposeEffect;
-exports.foldWeightedEffect = foldWeightedEffect;
-exports.forEach = forEach;
-exports.forEachChunk = forEachChunk;
-exports.forEachChunkWhile = forEachChunkWhile;
-exports.forEachWhile = forEachWhile;
-exports.fromChannel = fromChannel;
-exports.fromEffect = fromEffect$1;
-exports.fromEffect$1 = fromEffect;
-exports.fromEither = fromEither;
-exports.fromHub = fromHub;
-exports.fromHub$1 = fromHub$1;
-exports.fromHubScoped = fromHubScoped;
-exports.fromInput = fromInput;
-exports.fromOption = fromOption;
-exports.fromPush = fromPush;
-exports.fromQueue = fromQueue;
-exports.fromQueue$1 = fromQueue$1;
-exports.head = head;
-exports.identityChannel = identityChannel;
-exports.ignoreLeftover = ignoreLeftover;
-exports.interruptWhen = interruptWhen;
-exports.interruptWhenDeferred = interruptWhenDeferred;
-exports.isChannelException = isChannelException;
-exports.last = last;
-exports.leftover = leftover;
-exports.map = map;
-exports.map$1 = map$1;
-exports.mapEffect = mapEffect;
-exports.mapEffect$1 = mapEffect$1;
-exports.mapError = mapError$1;
-exports.mapError$1 = mapError;
-exports.mapErrorCause = mapErrorCause;
-exports.mapInput = mapInput;
-exports.mapInput$1 = mapInput$1;
-exports.mapInputChunks = mapInputChunks;
-exports.mapInputChunksEffect = mapInputChunksEffect;
-exports.mapInputContext = mapInputContext;
-exports.mapInputEffect = mapInputEffect;
-exports.mapInputEffect$1 = mapInputEffect$1;
-exports.mapInputError = mapInputError;
-exports.mapInputErrorEffect = mapInputErrorEffect;
-exports.mapInputIn = mapInputIn;
-exports.mapInputInEffect = mapInputInEffect;
-exports.mapLeftover = mapLeftover;
-exports.mapOut = mapOut;
-exports.mapOutEffect = mapOutEffect;
-exports.mapOutEffectPar = mapOutEffectPar;
-exports.mergeAll = mergeAll;
-exports.mergeAllUnbounded = mergeAllUnbounded;
-exports.mergeAllUnboundedWith = mergeAllUnboundedWith;
-exports.mergeAllWith = mergeAllWith;
-exports.mergeMap = mergeMap;
-exports.mergeOut = mergeOut;
-exports.mergeOutWith = mergeOutWith;
-exports.mergeWith = mergeWith;
-exports.mkString = mkString;
-exports.never = never;
-exports.never$1 = never$1;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse$1;
-exports.orElse$1 = orElse;
-exports.pipeTo = pipeTo;
-exports.pipeToOrFail = pipeToOrFail;
-exports.provideContext = provideContext$1;
-exports.provideContext$1 = provideContext;
-exports.provideLayer = provideLayer;
-exports.provideService = provideService;
-exports.provideSomeLayer = provideSomeLayer;
-exports.race = race;
-exports.raceBoth = raceBoth;
-exports.raceWith = raceWith;
-exports.read = read;
-exports.readOrFail = readOrFail;
-exports.readWith = readWith;
-exports.readWithCause = readWithCause;
-exports.refineOrDie = refineOrDie;
-exports.refineOrDieWith = refineOrDieWith;
-exports.repeated = repeated;
-exports.run = run$1;
-exports.run$1 = run;
-exports.runCollect = runCollect;
-exports.runDrain = runDrain;
-exports.runScoped = runScoped;
-exports.scoped = scoped;
-exports.some = some;
-exports.splitWhere = splitWhere;
-exports.succeed = succeed$1;
-exports.succeed$1 = succeed;
-exports.succeedNow = succeedNow;
-exports.sum = sum;
-exports.summarized = summarized;
-exports.suspend = suspend$1;
-exports.suspend$1 = suspend;
-exports.sync = sync$1;
-exports.sync$1 = sync;
-exports.take = take;
-exports.timed = timed;
-exports.toChannel = toChannel;
-exports.toHub = toHub;
-exports.toPull = toPull;
-exports.toQueue = toQueue;
-exports.unit = unit;
-exports.unwrap = unwrap$1;
-exports.unwrap$1 = unwrap;
-exports.unwrapScoped = unwrapScoped$1;
-exports.unwrapScoped$1 = unwrapScoped;
-exports.updateService = updateService;
-exports.withDuration = withDuration;
-exports.withSpan = withSpan;
-exports.write = write;
-exports.writeAll = writeAll;
-exports.writeChunk = writeChunk;
-exports.zip = zip;
-exports.zip$1 = zip$1;
-exports.zipLeft = zipLeft;
-exports.zipLeft$1 = zipLeft$1;
-exports.zipRight = zipRight$1;
-exports.zipRight$1 = zipRight;
-exports.zipWith = zipWith;