effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/sink-3105a90f.cjs.dev.js

@@ -0,0 +1,3094 @@
+'use strict';
+
+var Cause_dist_effectCause = require('./Cause-d77e20dc.cjs.dev.js');
+var Chunk_dist_effectChunk = require('./Chunk-937f4423.cjs.dev.js');
+var Clock_dist_effectClock = require('./Clock-589e9dc5.cjs.dev.js');
+var Duration_dist_effectDuration = require('./Duration-8b174e0b.cjs.dev.js');
+var Effect_dist_effectEffect = require('./Effect-d362f43a.cjs.dev.js');
+var Either_dist_effectEither = require('./Either-ae722a9e.cjs.dev.js');
+var Exit_dist_effectExit = require('./Exit-7a385294.cjs.dev.js');
+var Function_dist_effectFunction = require('./Function-fd10bde3.cjs.dev.js');
+var HashMap_dist_effectHashMap = require('./HashMap-ee35ace5.cjs.dev.js');
+var HashSet_dist_effectHashSet = require('./HashSet-43b520e9.cjs.dev.js');
+var Hub_dist_effectHub = require('./Hub-dd9d70e7.cjs.dev.js');
+var Option_dist_effectOption = require('./Option-837ae0da.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-ef202667.cjs.dev.js');
+var Queue_dist_effectQueue = require('./Queue-48d0b9d4.cjs.dev.js');
+var ReadonlyArray_dist_effectReadonlyArray = require('./ReadonlyArray-885e80a2.cjs.dev.js');
+var Ref_dist_effectRef = require('./Ref-8d85fc7a.cjs.dev.js');
+var Context_dist_effectContext = require('./Context-fdaa5c44.cjs.dev.js');
+var Deferred_dist_effectDeferred = require('./Deferred-143efa7b.cjs.dev.js');
+var Equal_dist_effectEqual = require('./Equal-8654b1af.cjs.dev.js');
+var Fiber_dist_effectFiber = require('./Fiber-1a996e3f.cjs.dev.js');
+var Layer_dist_effectLayer = require('./Layer-11122c64.cjs.dev.js');
+var Scope_dist_effectScope = require('./Scope-3cf29072.cjs.dev.js');
+var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-cd9204b4.cjs.dev.js');
+var childExecutorDecision = require('./childExecutorDecision-c1c3b8b6.cjs.dev.js');
+var upstreamPullStrategy = require('./upstreamPullStrategy-29c0b698.cjs.dev.js');
+var upstreamPullRequest = require('./upstreamPullRequest-f986731f.cjs.dev.js');
+var mergeDecision = require('./mergeDecision-75feaab3.cjs.dev.js');
+var mergeState = require('./mergeState-e9aa09b9.cjs.dev.js');
+var mergeStrategy = require('./mergeStrategy-8fe47c7e.cjs.dev.js');
+var singleProducerAsyncInput = require('./singleProducerAsyncInput-6508b7f1.cjs.dev.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;