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

package/dist/sink-3f26fc31.esm.js

@@ -0,0 +1,2877 @@
+import { f as fail$2, a as failureOrCause, d as die$2, m as map$4, b as isInterrupted, c as isDieType, R as RuntimeException } from './Cause-8be0b9a6.esm.js';
+import { f as fromIterable, u as unsafeGet$1, e as empty, i as isEmpty, l as unsafeFromArray, b as appendAll, c as append, n as toReadonlyArray, d as drop$1, z as flatten$2, s as map$5, A as dropWhile$1, g as filter, o as of, B as splitAt, h as isNonEmpty, C as last$1, y as reduce } from './Chunk-98371336.esm.js';
+import { a as currentTimeMillis } from './Clock-ab907687.esm.js';
+import { m as millis } from './Duration-5e9f2327.esm.js';
+import { i as isEffect, e as unit$1, g as ignore, z as zipWith$1, h as exit, s as sync$2, p as provide, m as matchCauseEffect, j as zipRight$3, k as flatMap$2, l as suspend$2, n as forkDaemon, o as ensuring$2, q as uninterruptible, r as map$2, t as zip$2, v as forEach$1, w as succeed$3, x as scoped$1, u as uninterruptibleMask, y as scope, A as forkScoped, B as addFinalizer, C as zipLeft$2, D as all$1, F as dieMessage$1, c as catchAllCause$1, G as acquireUseRelease$1, H as intoDeferred, I as tapErrorCause, f as failCause$3, J as tap, K as context$2, L as matchCause, d as flatten$1, M as gen, N as acquireRelease, O as makeSemaphore, P as interruptible, Q as asUnit$1, R as raceFirst, S as forever, T as raceWith$1, b as as$2, U as race$1, V as when, W as repeatWhile, X as never$2, Y as withSpanScoped, Z as repeatUntil, _ as takeWhile, $ as contextWith$2, a0 as filter$1, a1 as dropUntil$1, a2 as dropWhile$2 } from './Effect-d5910dae.esm.js';
+import { b as match, l as left, r as right, m as merge$2 } from './Either-09270bbc.esm.js';
+import { e as isFailure, z as zipRight$2, d as die$1, m as match$1, s as succeed$2, a as failCause$2, g as all, u as unit$2, h as map$3, j as zip$3 } from './Exit-e31718e3.esm.js';
+import { d as dual, i as identity, b as constVoid, p as pipe, c as constTrue } from './Function-52fb7d21.esm.js';
+import { e as empty$1, j as has, u as unsafeGet$2, s as set$1 } from './HashMap-e644e23b.esm.js';
+import { e as empty$2, h as has$1, a as add$1 } from './HashSet-dff2542b.esm.js';
+import { s as subscribe, b as bounded$1 } from './Hub-9f3d5c5d.esm.js';
+import { n as none, i as isSome, g as getOrElse, b as match$2, s as some$1, a as isNone, o as orElse$2 } from './Option-1d073850.esm.js';
+import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
+import { t as take$1, b as bounded, s as shutdown, o as offer, u as unbounded, a as size, c as offerAll } from './Queue-bbebbeda.esm.js';
+import { X as span } from './ReadonlyArray-199ff80e.esm.js';
+import { m as make$1, g as get, s as set, u as update, a as modify } from './Ref-9a9de951.esm.js';
+import { b as add, m as merge$1, c as make$4, u as unsafeGet } from './Context-48179faa.esm.js';
+import { s as succeed$4, _ as _await, m as make, f as failCause$4, i as isDone } from './Deferred-554d3588.esm.js';
+import { e as equals } from './Equal-7d4ae7e7.esm.js';
+import { i as interrupt, a as inheritAll, j as join, _ as _await$1 } from './Fiber-38517971.esm.js';
+import { b as build, m as merge, c as context$3 } from './Layer-f7be72db.esm.js';
+import { f as fork, a as addFinalizer$1, m as make$3, e as extend, c as close } from './Scope-0ffde3bb.esm.js';
+import { a as sequential } from './ExecutionStrategy-c6f7c490.esm.js';
+import { C as Continue, O as OP_YIELD, a as OP_CLOSE, b as OP_CONTINUE } from './childExecutorDecision-49f0f19c.esm.js';
+import { P as PullAfterNext, O as OP_PULL_AFTER_ALL_ENQUEUED, a as OP_PULL_AFTER_NEXT } from './upstreamPullStrategy-d1505fa4.esm.js';
+import { N as NoUpstream, P as Pulled } from './upstreamPullRequest-be86e51c.esm.js';
+import { D as Done$1, A as Await, O as OP_DONE$1 } from './mergeDecision-32146c34.esm.js';
+import { B as BothRunning, O as OP_RIGHT_DONE, R as RightDone, a as OP_LEFT_DONE, L as LeftDone, b as OP_BOTH_RUNNING } from './mergeState-21728f0b.esm.js';
+import { m as match$3, B as BackPressure } from './mergeStrategy-84dd9011.esm.js';
+import { m as make$2 } from './singleProducerAsyncInput-c67ef1c6.esm.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 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 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 || isEffect(u);
+
+/** @internal */
+const acquireReleaseOut = /*#__PURE__*/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__*/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(() => [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, constVoid, 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 = () => PullAfterNext(none());
+  op.onEmit = () => Continue;
+  op.value = () => channels;
+  op.k = identity;
+  return op;
+};
+
+/** @internal */
+const concatMapWith = /*#__PURE__*/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 = () => PullAfterNext(none());
+  op.onEmit = () => Continue;
+  op.value = () => self;
+  op.k = f;
+  return op;
+});
+
+/** @internal */
+const concatMapWithCustom = /*#__PURE__*/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__*/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__*/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(fail$2(error));
+
+/** @internal */
+const failSync$1 = evaluate => failCauseSync$1(() => fail$2(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__*/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__*/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__*/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__*/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 => match(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 : unit$1;
+
+/** @internal */
+const effectOrUndefinedIgnored = self => isFromEffect(self) ? 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$1) {
+    const fin1 = this.childExecutor.close(exit$1);
+    const fin2 = this.parentSubexecutor.close(exit$1);
+    if (fin1 !== undefined && fin2 !== undefined) {
+      return zipWith$1(exit(fin1), exit(fin2), (exit1, exit2) => pipe(exit1, zipRight$2(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$1) {
+    const fin1 = this.upstreamExecutor.close(exit$1);
+    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit$1) : undefined), fin1];
+    const result = fins.reduce((acc, next) => {
+      if (acc !== undefined && next !== undefined) {
+        return zipWith$1(acc, exit(next), (exit1, exit2) => zipRight$2(exit1, exit2));
+      } else if (acc !== undefined) {
+        return acc;
+      } else if (next !== undefined) {
+        return 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$1) {
+    const fin1 = this.upstreamExecutor.close(exit$1);
+    const fins = [...this.activeChildExecutors.map(child => child !== undefined ? child.childExecutor.close(exit$1) : undefined), fin1];
+    const result = fins.reduce((acc, next) => {
+      if (acc !== undefined && next !== undefined) {
+        return zipWith$1(acc, exit(next), (exit1, exit2) => zipRight$2(exit1, exit2));
+      } else if (acc !== undefined) {
+        return acc;
+      } else if (next !== undefined) {
+        return 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 (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 = () => flatMap$2(bridgeInput.awaitRead(), () => suspend$2(() => {
+                        const state = inputExecutor.run();
+                        switch (state._tag) {
+                          case OP_DONE:
+                            {
+                              return match$1(inputExecutor.getDone(), {
+                                onFailure: cause => bridgeInput.error(cause),
+                                onSuccess: value => bridgeInput.done(value)
+                              });
+                            }
+                          case OP_EMIT$1:
+                            {
+                              return flatMap$2(bridgeInput.emit(inputExecutor.getEmit()), () => drainer());
+                            }
+                          case OP_FROM_EFFECT:
+                            {
+                              return matchCauseEffect(state.effect, {
+                                onFailure: cause => bridgeInput.error(cause),
+                                onSuccess: () => drainer()
+                              });
+                            }
+                          case OP_READ:
+                            {
+                              return readUpstream(state, () => drainer(), cause => bridgeInput.error(cause));
+                            }
+                        }
+                      }));
+                      result = FromEffect(flatMap$2(forkDaemon(drainer()), fiber => sync$2(() => this.addFinalizer(exit => flatMap$2(interrupt(fiber), () => suspend$2(() => {
+                        const effect = this.restorePipe(exit, inputExecutor);
+                        return effect !== undefined ? effect : unit$1;
+                      }))))));
+                    }
+                    break;
+                  }
+                case OP_CONCAT_ALL:
+                  {
+                    const executor = new ChannelExecutor(this._currentChannel.value(), this._providedEnv, effect => sync$2(() => {
+                      const prevLastClose = this._closeLastSubstream === undefined ? unit$1 : this._closeLastSubstream;
+                      this._closeLastSubstream = pipe(prevLastClose, zipRight$3(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() : pipe(this._currentChannel.effect(), provide(this._providedEnv));
+                    result = FromEffect(matchCauseEffect(effect, {
+                      onFailure: cause => {
+                        const state = this.doneHalt(cause);
+                        return state !== undefined && isFromEffect(state) ? state.effect : unit$1;
+                      },
+                      onSuccess: value => {
+                        const state = this.doneSucceed(value);
+                        return state !== undefined && isFromEffect(state) ? state.effect : unit$1;
+                      }
+                    }));
+                    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 : unit$1;
+                    });
+                    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(() => sync$2(() => {
+                      this._providedEnv = previousEnv;
+                    }));
+                    break;
+                  }
+                case OP_READ$1:
+                  {
+                    const read = this._currentChannel;
+                    result = Read(this._input, identity, emitted => {
+                      try {
+                        this._currentChannel = read.more(emitted);
+                      } catch (error) {
+                        this._currentChannel = read.done.onExit(die$1(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(die$2(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 ? unit$1 : 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 unit$1;
+  }
+  close(exit$1) {
+    let runInProgressFinalizers = undefined;
+    const finalizer = this._inProgressFinalizer;
+    if (finalizer !== undefined) {
+      runInProgressFinalizers = pipe(finalizer, ensuring$2(sync$2(() => this.clearInProgressFinalizer())));
+    }
+    let closeSelf = undefined;
+    const selfFinalizers = this.popAllFinalizers(exit$1);
+    if (selfFinalizers !== undefined) {
+      closeSelf = pipe(selfFinalizers, ensuring$2(sync$2(() => this.clearInProgressFinalizer())));
+    }
+    const closeSubexecutors = this._activeSubexecutor === undefined ? undefined : this._activeSubexecutor.close(exit$1);
+    if (closeSubexecutors === undefined && runInProgressFinalizers === undefined && closeSelf === undefined) {
+      return undefined;
+    }
+    return pipe(exit(ifNotNull(closeSubexecutors)), zip$2(exit(ifNotNull(runInProgressFinalizers))), zip$2(exit(ifNotNull(closeSelf))), map$2(([[exit1, exit2], exit3]) => pipe(exit1, zipRight$2(exit2), zipRight$2(exit3))), uninterruptible,
+    // TODO: remove
+    flatMap$2(exit => suspend$2(() => exit)));
+  }
+  doneSucceed(value) {
+    if (this._doneStack.length === 0) {
+      this._done = succeed$2(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 = succeed$2(value);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), succeed$2(value));
+    this.storeInProgressFinalizer(finalizerEffect);
+    const effect = pipe(finalizerEffect, ensuring$2(sync$2(() => this.clearInProgressFinalizer())), uninterruptible, flatMap$2(() => sync$2(() => this.doneSucceed(value))));
+    return FromEffect(effect);
+  }
+  doneHalt(cause) {
+    if (this._doneStack.length === 0) {
+      this._done = failCause$2(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 = failCause$2(cause);
+      this._currentChannel = undefined;
+      return Done();
+    }
+    const finalizerEffect = runFinalizers(finalizers.map(f => f.finalizer), failCause$2(cause));
+    this.storeInProgressFinalizer(finalizerEffect);
+    const effect = pipe(finalizerEffect, ensuring$2(sync$2(() => this.clearInProgressFinalizer())), uninterruptible, flatMap$2(() => sync$2(() => this.doneHalt(cause))));
+    return FromEffect(effect);
+  }
+  processCancellation() {
+    this._currentChannel = undefined;
+    this._done = this._cancelled;
+    this._cancelled = undefined;
+    return Done();
+  }
+  runBracketOut(bracketOut) {
+    const effect = uninterruptible(matchCauseEffect(this.provide(bracketOut.acquire()), {
+      onFailure: cause => sync$2(() => {
+        this._currentChannel = failCause$1(cause);
+      }),
+      onSuccess: out => sync$2(() => {
+        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 pipe(effect, 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 = match$1(exit, {
+      onFailure: cause => this.doneHalt(cause),
+      onSuccess: value => this.doneSucceed(value)
+    });
+    this._activeSubexecutor = undefined;
+    return state === undefined ? unit$1 : effect(state);
+  }
+  finishSubexecutorWithCloseEffect(subexecutorDone, ...closeFuncs) {
+    this.addFinalizer(() => pipe(closeFuncs, forEach$1(closeFunc => pipe(sync$2(() => closeFunc(subexecutorDone)), flatMap$2(closeEffect => closeEffect !== undefined ? closeEffect : unit$1)), {
+      discard: true
+    })));
+    const state = pipe(subexecutorDone, match$1({
+      onFailure: cause => this.doneHalt(cause),
+      onSuccess: value => this.doneSucceed(value)
+    }));
+    this._activeSubexecutor = undefined;
+    return state;
+  }
+  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
+    switch (strategy._tag) {
+      case OP_PULL_AFTER_NEXT:
+        {
+          const shouldPrepend = !upstreamFinished || queue.some(subexecutor => subexecutor !== undefined);
+          return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue];
+        }
+      case 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, identity, emitted => {
+      const childExecutorDecision = onEmitted(emitted);
+      switch (childExecutorDecision._tag) {
+        case OP_CONTINUE:
+          {
+            break;
+          }
+        case OP_CLOSE:
+          {
+            this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision.value);
+            break;
+          }
+        case OP_YIELD:
+          {
+            const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor);
+            this.replaceSubexecutor(modifiedParent);
+            break;
+          }
+      }
+      this._activeSubexecutor = new Emit(emitted, this._activeSubexecutor);
+      return undefined;
+    }, match$1({
+      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(succeed$2(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(succeed$2(doneValue));
+          this.replaceSubexecutor(modifiedParent);
+          break;
+        }
+    }
+  }
+  handleSubexecutorFailure(childExecutor, parentSubexecutor, cause) {
+    return this.finishSubexecutorWithCloseEffect(failCause$2(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 ? unit$1 : this._closeLastSubstream;
+      this._closeLastSubstream = undefined;
+      return pipe(this._executeCloseLastSubstream(closeLastSubstream), zipRight$3(effect));
+    }, emitted => {
+      if (this._closeLastSubstream !== undefined) {
+        const closeLastSubstream = this._closeLastSubstream;
+        this._closeLastSubstream = undefined;
+        return pipe(this._executeCloseLastSubstream(closeLastSubstream), map$2(() => {
+          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(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 (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(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 (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 pipe(this._executeCloseLastSubstream(closeLastSubstream), map$2(() => this.replaceSubexecutor(drain)));
+        }
+        this.replaceSubexecutor(drain);
+        return undefined;
+      }
+      const closeLastSubstream = this._closeLastSubstream;
+      const state = this.finishSubexecutorWithCloseEffect(pipe(exit, map$3(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(() => succeed$3(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(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 (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 : unit$1;
+const runFinalizers = (finalizers, exit$1) => {
+  return pipe(forEach$1(finalizers, fin => exit(fin(exit$1))), map$2(exits => pipe(all(exits), getOrElse(() => unit$2))), flatMap$2(exit => suspend$2(() => exit)));
+};
+
+/**
+ * @internal
+ */
+const readUpstream = (r, onSuccess, onFailure) => {
+  const readStack = [r];
+  const read = () => {
+    const current = readStack.pop();
+    if (current === undefined || current.upstream === undefined) {
+      return dieMessage$1("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 suspend$2(onSuccess);
+            }
+            return pipe(emitEffect, matchCauseEffect({
+              onFailure,
+              onSuccess
+            }));
+          }
+          if (emitEffect === undefined) {
+            return suspend$2(() => read());
+          }
+          return pipe(emitEffect, matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_DONE:
+        {
+          const doneEffect = current.onDone(current.upstream.getDone());
+          if (readStack.length === 0) {
+            if (doneEffect === undefined) {
+              return suspend$2(onSuccess);
+            }
+            return pipe(doneEffect, matchCauseEffect({
+              onFailure,
+              onSuccess
+            }));
+          }
+          if (doneEffect === undefined) {
+            return suspend$2(() => read());
+          }
+          return pipe(doneEffect, matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_FROM_EFFECT:
+        {
+          readStack.push(current);
+          return pipe(current.onEffect(state.effect), catchAllCause$1(cause => suspend$2(() => {
+            const doneEffect = current.onDone(failCause$2(cause));
+            return doneEffect === undefined ? unit$1 : doneEffect;
+          })), matchCauseEffect({
+            onFailure,
+            onSuccess: () => read()
+          }));
+        }
+      case OP_READ:
+        {
+          readStack.push(current);
+          readStack.push(state);
+          return suspend$2(() => read());
+        }
+    }
+  };
+  return read();
+};
+
+/** @internal */
+const run$1 = self => pipe(runScoped(self), scoped$1);
+
+/** @internal */
+const runScoped = self => {
+  const run = (channelDeferred, scopeDeferred, scope) => acquireUseRelease$1(sync$2(() => new ChannelExecutor(self, void 0, identity)), exec => suspend$2(() => pipe(runScopedInterpret(exec.run(), exec), intoDeferred(channelDeferred), zipRight$3(_await(channelDeferred)), zipLeft$2(_await(scopeDeferred)))), (exec, exit) => {
+    const finalize = exec.close(exit);
+    if (finalize === undefined) {
+      return unit$1;
+    }
+    return tapErrorCause(finalize, cause => addFinalizer$1(scope, failCause$3(cause)));
+  });
+  return uninterruptibleMask(restore => flatMap$2(scope, parent => pipe(all$1([fork(parent, sequential), make(), make()]), flatMap$2(([child, channelDeferred, scopeDeferred]) => pipe(forkScoped(restore(run(channelDeferred, scopeDeferred, child))), flatMap$2(fiber => pipe(addFinalizer(() => succeed$4(scopeDeferred, void 0)), zipRight$3(restore(_await(channelDeferred))), zipLeft$2(inheritAll(fiber)))))))));
+};
+
+/** @internal */
+const runScopedInterpret = (channelState, exec) => {
+  const op = channelState;
+  switch (op._tag) {
+    case OP_FROM_EFFECT:
+      {
+        return pipe(op.effect, flatMap$2(() => 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 suspend$2(() => exec.getDone());
+      }
+    case OP_READ:
+      {
+        return readUpstream(op, () => runScopedInterpret(exec.run(), exec), failCause$3);
+      }
+  }
+};
+
+/** @internal */
+const acquireUseRelease = (acquire, use, release) => flatMap$1(fromEffect$1(make$1(() => unit$1)), ref => pipe(fromEffect$1(uninterruptible(tap(acquire, a => set(ref, exit => release(a, exit))))), flatMap$1(use), ensuringWith$1(exit => flatMap$2(get(ref), f => f(exit)))));
+
+/** @internal */
+const as$1 = /*#__PURE__*/dual(2, (self, value) => map$1(self, () => value));
+
+/** @internal */
+const asUnit = self => map$1(self, constVoid);
+
+/** @internal */
+const buffer = options => suspend$1(() => {
+  const doBuffer = (empty, isEmpty, ref) => unwrap$1(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: empty(),
+  isEmpty: isEmpty,
+  ref
+});
+
+/** @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => match(failureOrCause(cause), {
+  onLeft: f,
+  onRight: failCause$1
+})));
+
+/** @internal */
+const concatMap = /*#__PURE__*/dual(2, (self, f) => concatMapWith(self, f, () => void 0, () => void 0));
+
+/** @internal */
+const collect = /*#__PURE__*/dual(2, (self, pf) => {
+  const collector = readWith({
+    onInput: out => match$2(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__*/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__*/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__*/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__*/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__*/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__*/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 pipe(pipeTo(self, doneCollectReader(builder)), flatMap$1(outDone => succeed$1([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__*/dual(2, (self, finalizer) => ensuringWith$1(self, () => finalizer));
+
+/** @internal */
+const context$1 = () => fromEffect$1(context$2());
+
+/** @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, identity);
+
+/** @internal */
+const foldChannel = /*#__PURE__*/dual(2, (self, options) => foldCauseChannel(self, {
+  onFailure: cause => {
+    const either = 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(() => 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(map$2(subscribe(hub), fromQueue$1));
+
+/** @internal */
+const fromHubScoped = hub => map$2(subscribe(hub), fromQueue$1);
+
+/** @internal */
+const fromOption = option => suspend$1(() => match$2(option, {
+  onNone: () => fail$1(none()),
+  onSome: succeed$1
+}));
+
+/** @internal */
+const fromQueue$1 = queue => suspend$1(() => fromQueueInternal(queue));
+
+/** @internal */
+const fromQueueInternal = queue => pipe(fromEffect$1(take$1(queue)), flatMap$1(match({
+  onLeft: match$1({
+    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__*/dual(2, (self, effect) => mergeWith(self, {
+  other: fromEffect$1(effect),
+  onSelfDone: selfDone => Done$1(suspend$2(() => selfDone)),
+  onOtherDone: effectDone => Done$1(suspend$2(() => effectDone))
+}));
+
+/** @internal */
+const interruptWhenDeferred = /*#__PURE__*/dual(2, (self, deferred) => interruptWhen(self, _await(deferred)));
+
+/** @internal */
+const map$1 = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, a => sync$1(() => f(a))));
+
+/** @internal */
+const mapEffect$1 = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, z => fromEffect$1(f(z))));
+
+/** @internal */
+const mapError$1 = /*#__PURE__*/dual(2, (self, f) => mapErrorCause(self, map$4(f)));
+
+/** @internal */
+const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => failCause$1(f(cause))));
+
+/** @internal */
+const mapOut = /*#__PURE__*/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__*/dual(2, (self, f) => {
+  const reader = readWithCause({
+    onInput: outElem => pipe(fromEffect$1(f(outElem)), flatMap$1(write), flatMap$1(() => reader)),
+    onFailure: failCause$1,
+    onDone: succeedNow
+  });
+  return pipeTo(self, reader);
+});
+
+/** @internal */
+const mapOutEffectPar = /*#__PURE__*/dual(3, (self, f, n) => pipe(gen(function* ($) {
+  const queue = yield* $(acquireRelease(bounded(n), queue => shutdown(queue)));
+  const errorSignal = yield* $(make());
+  const withPermits = n === Number.POSITIVE_INFINITY ? _ => identity : (yield* $(makeSemaphore(n))).withPermits;
+  const pull = yield* $(toPull(self));
+  yield* $(matchCauseEffect(pull, {
+    onFailure: cause => offer(queue, failCause$3(cause)),
+    onSuccess: either => match(either, {
+      onLeft: outDone => {
+        const lock = withPermits(n);
+        return zipRight$3(interruptible(lock(unit$1)), asUnit$1(offer(queue, succeed$3(left(outDone)))));
+      },
+      onRight: outElem => gen(function* ($) {
+        const deferred = yield* $(make());
+        const latch = yield* $(make());
+        yield* $(asUnit$1(offer(queue, map$2(_await(deferred), right))));
+        yield* $(succeed$4(latch, void 0), zipRight$3(pipe(uninterruptibleMask(restore => pipe(exit(restore(_await(errorSignal))), raceFirst(exit(restore(f(outElem)))),
+        // TODO: remove
+        flatMap$2(exit => suspend$2(() => exit)))), tapErrorCause(cause => failCause$4(errorSignal, cause)), intoDeferred(deferred))), withPermits(1), forkScoped);
+        yield* $(_await(latch));
+      })
+    })
+  }), forever, interruptible, forkScoped);
+  return queue;
+}), map$2(queue => {
+  const consumer = unwrap$1(matchCause(flatten$1(take$1(queue)), {
+    onFailure: failCause$1,
+    onSuccess: match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap$1(write(outElem), () => consumer)
+    })
+  }));
+  return consumer;
+}), unwrapScoped$1));
+
+/** @internal */
+const mergeAll = options => {
+  return channels => mergeAllWith(options)(channels, constVoid);
+};
+
+/** @internal */
+const mergeAllUnbounded = channels => mergeAllWith({
+  concurrency: "unbounded"
+})(channels, constVoid);
+
+/** @internal */
+const mergeAllUnboundedWith = (channels, f) => mergeAllWith({
+  concurrency: "unbounded"
+})(channels, f);
+
+/** @internal */
+const mergeAllWith = ({
+  bufferSize = 16,
+  concurrency,
+  mergeStrategy = BackPressure()
+}) => (channels, f) => pipe(gen(function* ($) {
+  const input = yield* $(make$2());
+  const queueReader = fromInput(input);
+  const queue = yield* $(acquireRelease(bounded(bufferSize), queue => shutdown(queue)));
+  const cancelers = yield* $(acquireRelease(unbounded(), queue => shutdown(queue)));
+  const lastDone = yield* $(make$1(none()));
+  const errorSignal = yield* $(make());
+  const withPermits = concurrency === "unbounded" ? _ => identity : (yield* $(makeSemaphore(concurrency))).withPermits;
+  const pull = yield* $(toPull(channels));
+  const evaluatePull = pull => pipe(flatMap$2(pull, match({
+    onLeft: done => succeed$3(some$1(done)),
+    onRight: outElem => as$2(offer(queue, succeed$3(right(outElem))), none())
+  })), repeatUntil(isSome), flatMap$2(match$2({
+    onNone: () => unit$1,
+    onSome: outDone => update(lastDone, match$2({
+      onNone: () => some$1(outDone),
+      onSome: lastDone => some$1(f(lastDone, outDone))
+    }))
+  })), catchAllCause$1(cause => isInterrupted(cause) ? failCause$3(cause) : pipe(offer(queue, failCause$3(cause)), zipRight$3(succeed$4(errorSignal, void 0)), asUnit$1)));
+  yield* $(matchCauseEffect(pull, {
+    onFailure: cause => pipe(offer(queue, failCause$3(cause)), zipRight$3(succeed$3(false))),
+    onSuccess: match({
+      onLeft: outDone => raceWith$1(_await(errorSignal), withPermits(concurrency)(unit$1), {
+        onSelfDone: (_, permitAcquisition) => pipe(interrupt(permitAcquisition), as$2(false)),
+        onOtherDone: (_, failureAwait) => pipe(interrupt(failureAwait), zipRight$3(pipe(get(lastDone), flatMap$2(match$2({
+          onNone: () => offer(queue, succeed$3(left(outDone))),
+          onSome: lastDone => offer(queue, succeed$3(left(f(lastDone, outDone))))
+        })), as$2(false))))
+      }),
+      onRight: channel => pipe(mergeStrategy, match$3({
+        onBackPressure: () => gen(function* ($) {
+          const latch = yield* $(make());
+          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$2(pull => pipe(evaluatePull(pull), race$1(_await(errorSignal)))), scoped$1);
+          yield* $(succeed$4(latch, void 0), zipRight$3(raceEffects), withPermits(1), forkScoped);
+          yield* $(_await(latch));
+          const errored = yield* $(isDone(errorSignal));
+          return !errored;
+        }),
+        onBufferSliding: () => gen(function* ($) {
+          const canceler = yield* $(make());
+          const latch = yield* $(make());
+          const size$1 = yield* $(size(cancelers));
+          yield* $(take$1(cancelers), flatMap$2(_ => succeed$4(_, void 0)), when(() => concurrency === "unbounded" ? false : size$1 >= concurrency));
+          yield* $(offer(cancelers, canceler));
+          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$2(pull => pipe(evaluatePull(pull), race$1(_await(errorSignal)), race$1(_await(canceler)))), scoped$1);
+          yield* $(succeed$4(latch, void 0), zipRight$3(raceEffects), withPermits(1), forkScoped);
+          yield* $(_await(latch));
+          const errored = yield* $(isDone(errorSignal));
+          return !errored;
+        })
+      }))
+    })
+  }), repeatWhile(identity), forkScoped);
+  return [queue, input];
+}), map$2(([queue, input]) => {
+  const consumer = pipe(take$1(queue), flatten$1, matchCause({
+    onFailure: failCause$1,
+    onSuccess: match({
+      onLeft: succeedNow,
+      onRight: outElem => flatMap$1(write(outElem), () => consumer)
+    })
+  }), unwrap$1);
+  return embedInput(consumer, input);
+}), unwrapScoped$1);
+
+/** @internal */
+const mergeMap = /*#__PURE__*/dual(3, (self, f, options) => mergeAll(options)(mapOut(self, f)));
+
+/** @internal */
+const mergeOut = /*#__PURE__*/dual(2, (self, n) => mergeAll({
+  concurrency: n
+})(mapOut(self, identity)));
+
+/** @internal */
+const mergeOutWith = /*#__PURE__*/dual(3, (self, n, f) => mergeAllWith({
+  concurrency: n
+})(mapOut(self, identity), f));
+
+/** @internal */
+const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped$1(flatMap$2(make$2(), input => {
+  const queueReader = fromInput(input);
+  return map$2(zip$2(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 === OP_DONE$1) {
+          return succeed$3(fromEffect$1(zipRight$3(interrupt(fiber), op.effect)));
+        }
+        return map$2(_await$1(fiber), match$1({
+          onFailure: cause => fromEffect$1(op.f(failCause$2(cause))),
+          onSuccess: match({
+            onLeft: done => fromEffect$1(op.f(succeed$2(done))),
+            onRight: elem => zipRight$1(write(elem), go(single(op.f)))
+          })
+        }));
+      };
+      return match$1(exit, {
+        onFailure: cause => onDecision(done(failCause$2(cause))),
+        onSuccess: match({
+          onLeft: z => onDecision(done(succeed$2(z))),
+          onRight: elem => succeed$3(flatMap$1(write(elem), () => flatMap$1(fromEffect$1(forkDaemon(pull)), leftFiber => go(both(leftFiber, fiber)))))
+        })
+      });
+    };
+    const go = state => {
+      switch (state._tag) {
+        case OP_BOTH_RUNNING:
+          {
+            const leftJoin = interruptible(join(state.left));
+            const rightJoin = interruptible(join(state.right));
+            return unwrap$1(raceWith$1(leftJoin, rightJoin, {
+              onSelfDone: (leftExit, rf) => zipRight$3(interrupt(rf), handleSide(leftExit, state.right, pullL)(options.onSelfDone, BothRunning, f => LeftDone(f))),
+              onOtherDone: (rightExit, lf) => zipRight$3(interrupt(lf), handleSide(rightExit, state.left, pullR)(options.onOtherDone, (left, right) => BothRunning(right, left), f => RightDone(f)))
+            }));
+          }
+        case OP_LEFT_DONE:
+          {
+            return unwrap$1(map$2(exit(pullR), match$1({
+              onFailure: cause => fromEffect$1(state.f(failCause$2(cause))),
+              onSuccess: match({
+                onLeft: done => fromEffect$1(state.f(succeed$2(done))),
+                onRight: elem => flatMap$1(write(elem), () => go(LeftDone(state.f)))
+              })
+            })));
+          }
+        case OP_RIGHT_DONE:
+          {
+            return unwrap$1(map$2(exit(pullL), match$1({
+              onFailure: cause => fromEffect$1(state.f(failCause$2(cause))),
+              onSuccess: match({
+                onLeft: done => fromEffect$1(state.f(succeed$2(done))),
+                onRight: elem => flatMap$1(write(elem), () => go(RightDone(state.f)))
+              })
+            })));
+          }
+      }
+    };
+    return pipe(fromEffect$1(zipWith$1(forkDaemon(pullL), forkDaemon(pullR), (left, right) => BothRunning(left, right))), flatMap$1(go), embedInput(input));
+  });
+})));
+
+/** @internal */
+const never$1 = /*#__PURE__*/fromEffect$1(never$2);
+
+/** @internal */
+const orDie = /*#__PURE__*/dual(2, (self, error) => orDieWith(self, error));
+
+/** @internal */
+const orDieWith = /*#__PURE__*/dual(2, (self, f) => catchAll(self, e => {
+  throw f(e);
+}));
+
+/** @internal */
+const orElse$1 = /*#__PURE__*/dual(2, (self, that) => catchAll(self, that));
+
+/** @internal */
+const pipeToOrFail = /*#__PURE__*/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(die$2(channelException));
+    },
+    onDone: succeedNow
+  });
+  const writer = readWithCause({
+    onInput: outElem => pipe(write(outElem), flatMap$1(() => writer)),
+    onFailure: cause => isDieType(cause) && isChannelException(cause.defect) && 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__*/dual(3, (self, tag, service) => {
+  return flatMap$1(context$1(), context => provideContext$1(self, add(context, tag, service)));
+});
+
+/** @internal */
+const provideLayer = /*#__PURE__*/dual(2, (self, layer) => unwrapScoped$1(map$2(build(layer), env => provideContext$1(self, env))));
+
+/** @internal */
+const mapInputContext = /*#__PURE__*/dual(2, (self, f) => contextWithChannel(context => provideContext$1(self, f(context))));
+
+/** @internal */
+const provideSomeLayer = /*#__PURE__*/dual(2, (self, layer) =>
+// @ts-expect-error
+provideLayer(self, merge(context$3(), layer)));
+
+/** @internal */
+const read = () => readOrFail(none());
+
+/** @internal */
+const repeated = self => flatMap$1(self, () => repeated(self));
+
+/** @internal */
+const run = self => scoped$1(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(uninterruptibleMask(restore => map$2(make$3(), scope => acquireReleaseOut(tapErrorCause(restore(extend(scope)(effect)), cause => close(scope, failCause$2(cause))), (_, exit) => close(scope, exit)))));
+
+/** @internal */
+const toHub = hub => toQueue(hub);
+
+/** @internal */
+const toPull = self => map$2(acquireRelease(sync$2(() => new ChannelExecutor(self, void 0, identity)), (exec, exit) => {
+  const finalize = exec.close(exit);
+  return finalize === undefined ? unit$1 : finalize;
+}), exec => suspend$2(() => interpretToPull(exec.run(), exec)));
+
+/** @internal */
+const interpretToPull = (channelState, exec) => {
+  const state = channelState;
+  switch (state._tag) {
+    case OP_DONE:
+      {
+        return match$1(exec.getDone(), {
+          onFailure: failCause$3,
+          onSuccess: done => succeed$3(left(done))
+        });
+      }
+    case OP_EMIT$1:
+      {
+        return succeed$3(right(exec.getEmit()));
+      }
+    case OP_FROM_EFFECT:
+      {
+        return pipe(state.effect, flatMap$2(() => interpretToPull(exec.run(), exec)));
+      }
+    case OP_READ:
+      {
+        return readUpstream(state, () => interpretToPull(exec.run(), exec), cause => failCause$3(cause));
+      }
+  }
+};
+
+/** @internal */
+const toQueue = queue => suspend$1(() => toQueueInternal(queue));
+
+/** @internal */
+const toQueueInternal = queue => {
+  return readWithCause({
+    onInput: elem => flatMap$1(fromEffect$1(offer(queue, right(elem))), () => toQueueInternal(queue)),
+    onFailure: cause => fromEffect$1(pipe(offer(queue, left(failCause$2(cause))))),
+    onDone: done => fromEffect$1(pipe(offer(queue, left(succeed$2(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__*/dual(3, (self, tag, f) => mapInputContext(self, context => merge$1(context, make$4(tag, f(unsafeGet(context, tag))))));
+
+/** @internal */
+const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped$1(as$2(withSpanScoped(name, options), self)));
+
+/** @internal */
+const writeAll = (...outs) => writeChunk(fromIterable(outs));
+
+/** @internal */
+const writeChunk = outs => writeChunkWriter(0, outs.length, outs);
+
+/** @internal */
+const writeChunkWriter = (idx, len, chunk) => {
+  return idx === len ? unit : pipe(write(pipe(chunk, unsafeGet$1(idx))), flatMap$1(() => writeChunkWriter(idx + 1, len, chunk)));
+};
+
+/** @internal */
+const zip$1 = /*#__PURE__*/dual(args => isChannel(args[1]), (self, that, options) => options?.concurrent ? mergeWith(self, {
+  other: that,
+  onSelfDone: exit1 => Await(exit2 => suspend$2(() => zip$3(exit1, exit2))),
+  onOtherDone: exit2 => Await(exit1 => suspend$2(() => zip$3(exit1, exit2)))
+}) : flatMap$1(self, a => map$1(that, b => [a, b])));
+
+/** @internal */
+const zipLeft$1 = /*#__PURE__*/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__*/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 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__*/dual(2, (self, z) => pipe(self, map(() => z)));
+
+/** @internal */
+const collectAll = () => new SinkImpl(collectAllLoop(empty()));
+
+/** @internal */
+const collectAllLoop = acc => readWithCause({
+  onInput: chunk => collectAllLoop(pipe(acc, appendAll(chunk))),
+  onFailure: failCause$1,
+  onDone: () => succeed$1(acc)
+});
+
+/** @internal */
+const collectAllN = n => suspend(() => fromChannel(collectAllNLoop(n, empty())));
+
+/** @internal */
+const collectAllNLoop = (n, acc) => readWithCause({
+  onInput: chunk => {
+    const [collected, leftovers] = splitAt(chunk, n);
+    if (collected.length < n) {
+      return collectAllNLoop(n - collected.length, appendAll(acc, collected));
+    }
+    if (isEmpty(leftovers)) {
+      return succeed$1(appendAll(acc, collected));
+    }
+    return flatMap$1(write(leftovers), () => succeed$1(appendAll(acc, collected)));
+  },
+  onFailure: failCause$1,
+  onDone: () => succeed$1(acc)
+});
+
+/** @internal */
+const collectAllFrom = self => collectAllWhileWith(self, {
+  initial: empty(),
+  while: constTrue,
+  body: (chunk, z) => pipe(chunk, append(z))
+});
+
+/** @internal */
+const collectAllToMap = (key, merge) => {
+  return pipe(foldLeftChunks(empty$1(), (map, chunk) => pipe(chunk, reduce(map, (map, input) => {
+    const k = key(input);
+    const v = pipe(map, has(k)) ? merge(pipe(map, unsafeGet$2(k)), input) : input;
+    return pipe(map, set$1(k, v));
+  }))));
+};
+
+/** @internal */
+const collectAllToMapN = (n, key, merge) => {
+  return foldWeighted({
+    initial: empty$1(),
+    maxCost: n,
+    cost: (acc, input) => pipe(acc, has(key(input))) ? 0 : 1,
+    body: (acc, input) => {
+      const k = key(input);
+      const v = pipe(acc, has(k)) ? merge(pipe(acc, unsafeGet$2(k)), input) : input;
+      return pipe(acc, set$1(k, v));
+    }
+  });
+};
+
+/** @internal */
+const collectAllToSet = () => foldLeftChunks(empty$2(), (acc, chunk) => pipe(chunk, reduce(acc, (acc, input) => pipe(acc, add$1(input)))));
+
+/** @internal */
+const collectAllToSetN = n => foldWeighted({
+  initial: empty$2(),
+  maxCost: n,
+  cost: (acc, input) => has$1(acc, input) ? 0 : 1,
+  body: (acc, input) => add$1(acc, input)
+});
+
+/** @internal */
+const collectAllUntil = p => {
+  return pipe(fold([empty(), true], tuple => tuple[1], ([chunk, _], input) => [pipe(chunk, append(input)), !p(input)]), map(tuple => tuple[0]));
+};
+
+/** @internal */
+const collectAllUntilEffect = p => {
+  return pipe(foldEffect([empty(), true], tuple => tuple[1], ([chunk, _], input) => pipe(p(input), map$2(bool => [pipe(chunk, append(input)), !bool]))), map(tuple => tuple[0]));
+};
+
+/** @internal */
+const collectAllWhile = predicate => fromChannel(collectAllWhileReader(predicate, empty()));
+
+/** @internal */
+const collectAllWhileReader = (predicate, done) => readWith({
+  onInput: input => {
+    const [collected, leftovers] = pipe(toReadonlyArray(input), span(predicate));
+    if (leftovers.length === 0) {
+      return collectAllWhileReader(predicate, pipe(done, appendAll(unsafeFromArray(collected))));
+    }
+    return pipe(write(unsafeFromArray(leftovers)), zipRight$1(succeed$1(pipe(done, appendAll(unsafeFromArray(collected))))));
+  },
+  onFailure: fail$1,
+  onDone: () => succeed$1(done)
+});
+
+/** @internal */
+const collectAllWhileEffect = predicate => fromChannel(collectAllWhileEffectReader(predicate, empty()));
+
+/** @internal */
+const collectAllWhileEffectReader = (predicate, done) => readWith({
+  onInput: input => pipe(fromEffect$1(pipe(input, takeWhile(predicate), map$2(unsafeFromArray))), flatMap$1(collected => {
+    const leftovers = pipe(input, drop$1(collected.length));
+    if (isEmpty(leftovers)) {
+      return collectAllWhileEffectReader(predicate, pipe(done, appendAll(collected)));
+    }
+    return pipe(write(leftovers), zipRight$1(succeed$1(pipe(done, appendAll(collected)))));
+  })),
+  onFailure: fail$1,
+  onDone: () => succeed$1(done)
+});
+
+/** @internal */
+const collectAllWhileWith = /*#__PURE__*/dual(2, (self, options) => {
+  const refs = pipe(make$1(empty()), zip$2(make$1(false)));
+  const newChannel = pipe(fromEffect$1(refs), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = readWith({
+      onInput: input => pipe(write(input), flatMap$1(() => upstreamMarker)),
+      onFailure: fail$1,
+      onDone: done => pipe(fromEffect$1(set(upstreamDoneRef, true)), as$1(done))
+    });
+    return 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 pipe(toChannel(self), doneCollect, foldChannel({
+    onFailure: fail$1,
+    onSuccess: ([leftovers, doneValue]) => p(doneValue) ? pipe(fromEffect$1(set(leftoversRef, flatten$2(leftovers))), flatMap$1(() => pipe(fromEffect$1(get(upstreamDoneRef)), flatMap$1(upstreamDone => {
+      const accumulatedResult = f(currentResult, doneValue);
+      return upstreamDone ? pipe(write(flatten$2(leftovers)), as$1(accumulatedResult)) : collectAllWhileWithLoop(self, leftoversRef, upstreamDoneRef, accumulatedResult, p, f);
+    })))) : pipe(write(flatten$2(leftovers)), as$1(currentResult))
+  }));
+};
+
+/** @internal */
+const collectLeftover = self => new SinkImpl(pipe(collectElements(toChannel(self)), map$1(([chunks, z]) => [z, flatten$2(chunks)])));
+
+/** @internal */
+const mapInput = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapInputChunks(map$5(f))));
+
+/** @internal */
+const mapInputEffect = /*#__PURE__*/dual(2, (self, f) => mapInputChunksEffect(self, chunk => map$2(forEach$1(chunk, v => f(v)), unsafeFromArray)));
+
+/** @internal */
+const mapInputChunks = /*#__PURE__*/dual(2, (self, f) => {
+  const loop = readWith({
+    onInput: chunk => pipe(write(f(chunk)), flatMap$1(() => loop)),
+    onFailure: fail$1,
+    onDone: succeed$1
+  });
+  return new SinkImpl(pipe(loop, pipeTo(toChannel(self))));
+});
+
+/** @internal */
+const mapInputChunksEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const loop = readWith({
+    onInput: chunk => pipe(fromEffect$1(f(chunk)), flatMap$1(write), flatMap$1(() => loop)),
+    onFailure: fail$1,
+    onDone: succeed$1
+  });
+  return new SinkImpl(pipe(loop, pipeToOrFail(toChannel(self))));
+});
+
+/** @internal */
+const die = defect => failCause(die$2(defect));
+
+/** @internal */
+const dieMessage = message => failCause(die$2(RuntimeException(message)));
+
+/** @internal */
+const dieSync = evaluate => failCauseSync(() => die$2(evaluate()));
+
+/** @internal */
+const dimap = /*#__PURE__*/dual(2, (self, options) => map(mapInput(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapEffect = /*#__PURE__*/dual(2, (self, options) => mapEffect(mapInputEffect(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapChunks = /*#__PURE__*/dual(2, (self, options) => map(mapInputChunks(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapChunksEffect = /*#__PURE__*/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 = pipe(input, drop$1(n));
+    const leftover = Math.max(n - input.length, 0);
+    const more = isEmpty(input) || leftover > 0;
+    if (more) {
+      return dropLoop(leftover);
+    }
+    return pipe(write(dropped), zipRight$1(identityChannel()));
+  },
+  onFailure: fail$1,
+  onDone: () => unit
+});
+
+/** @internal */
+const dropUntil = predicate => new SinkImpl(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 => pipe(input, dropUntil$1(predicate), map$2(leftover => {
+    const more = leftover.length === 0;
+    return more ? dropUntilEffectReader(predicate) : pipe(write(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 = pipe(input, dropWhile$1(predicate));
+    if (isEmpty(out)) {
+      return dropWhileReader(predicate);
+    }
+    return 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 => pipe(input, dropWhile$2(predicate), map$2(leftover => {
+    const more = leftover.length === 0;
+    return more ? dropWhileEffectReader(predicate) : pipe(write(unsafeFromArray(leftover)), zipRight$1(identityChannel()));
+  }), unwrap$1),
+  onFailure: fail$1,
+  onDone: () => unit
+});
+
+/** @internal */
+const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => new SinkImpl(pipe(self, toChannel, ensuring$1(finalizer))));
+
+/** @internal */
+const ensuringWith = /*#__PURE__*/dual(2, (self, finalizer) => new SinkImpl(pipe(self, toChannel, ensuringWith$1(finalizer))));
+
+/** @internal */
+const context = () => fromEffect(context$2());
+
+/** @internal */
+const contextWith = f => pipe(context(), map(f));
+
+/** @internal */
+const contextWithEffect = f => pipe(context(), mapEffect(f));
+
+/** @internal */
+const contextWithSink = f => new SinkImpl(unwrap$1(pipe(contextWith$2(context => toChannel(f(context))))));
+
+/** @internal */
+const every = predicate => fold(true, 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 => pipe(self, mapInputChunks(filter(f)));
+};
+
+/** @internal */
+const filterInputEffect = /*#__PURE__*/dual(2, (self, f) => mapInputChunksEffect(self, chunk => map$2(filter$1(chunk, f), unsafeFromArray)));
+
+/** @internal */
+const findEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const newChannel = pipe(fromEffect$1(pipe(make$1(empty()), zip$2(make$1(false)))), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = readWith({
+      onInput: input => pipe(write(input), flatMap$1(() => upstreamMarker)),
+      onFailure: fail$1,
+      onDone: done => pipe(fromEffect$1(set(upstreamDoneRef, true)), as$1(done))
+    });
+    const loop = foldChannel(collectElements(toChannel(self)), {
+      onFailure: fail$1,
+      onSuccess: ([leftovers, doneValue]) => pipe(fromEffect$1(f(doneValue)), flatMap$1(satisfied => pipe(fromEffect$1(set(leftoversRef, flatten$2(leftovers))), zipRight$1(pipe(fromEffect$1(get(upstreamDoneRef)), flatMap$1(upstreamDone => {
+        if (satisfied) {
+          return pipe(write(flatten$2(leftovers)), as$1(some$1(doneValue)));
+        }
+        if (upstreamDone) {
+          return pipe(write(flatten$2(leftovers)), as$1(none()));
+        }
+        return loop;
+      }))))))
+    });
+    return 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 (isNonEmpty(leftovers)) {
+        return 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, empty()];
+  }
+  const s1 = f(s, pipe(chunk, unsafeGet$1(index)));
+  if (contFn(s1)) {
+    return foldChunkSplit(s1, chunk, contFn, f, index + 1, length);
+  }
+  return [s1, pipe(chunk, drop$1(index + 1))];
+};
+
+/** @internal */
+const foldSink = /*#__PURE__*/dual(2, (self, options) => {
+  const newChannel = pipe(toChannel(self), collectElements, foldChannel({
+    onFailure: error => toChannel(options.onFailure(error)),
+    onSuccess: ([leftovers, z]) => suspend$1(() => {
+      const leftoversRef = {
+        ref: pipe(leftovers, filter(isNonEmpty))
+      };
+      const refReader = pipe(sync$1(() => {
+        const ref = leftoversRef.ref;
+        leftoversRef.ref = 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 = pipe(refReader, zipRight$1(passthrough), pipeTo(toChannel(options.onSuccess(z))));
+      return flatMap$1(collectElements(continuationSink), ([newLeftovers, z1]) => 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 => 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 => pipe(fromEffect$1(foldChunkSplitEffect(s, input, contFn, f)), flatMap$1(([nextS, leftovers]) => pipe(leftovers, match$2({
+      onNone: () => foldEffectReader(nextS, contFn, f),
+      onSome: leftover => 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 succeed$3([s, none()]);
+  }
+  return pipe(f(s, pipe(chunk, unsafeGet$1(index))), flatMap$2(s1 => contFn(s1) ? foldChunkSplitEffectInternal(s1, chunk, index + 1, length, contFn, f) : succeed$3([s1, some$1(pipe(chunk, drop$1(index + 1)))])));
+};
+
+/** @internal */
+const foldLeft = (s, f) => ignoreLeftover(fold(s, constTrue, f));
+
+/** @internal */
+const foldLeftChunks = (s, f) => foldChunks(s, constTrue, f);
+
+/** @internal */
+const foldLeftChunksEffect = (s, f) => ignoreLeftover(foldChunksEffect(s, constTrue, f));
+
+/** @internal */
+const foldLeftEffect = (s, f) => foldEffect(s, constTrue, f);
+
+/** @internal */
+const foldUntil = (s, max, f) => 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) => pipe(foldEffect([s, 0], tuple => tuple[1] < max, ([output, count], input) => pipe(f(output, input), map$2(s => [s, count + 1]))), map(tuple => tuple[0]));
+
+/** @internal */
+const foldWeighted = options => foldWeightedDecompose({
+  ...options,
+  decompose: 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 (isNonEmpty(leftovers)) {
+      return 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, empty()];
+  }
+  const elem = pipe(input, unsafeGet$1(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, pipe(input, drop$1(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, pipe(input, drop$1(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 = pipe(decomposed, appendAll(pipe(input, drop$1(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 => succeed$3(of(input))
+});
+
+/** @internal */
+const foldWeightedDecomposeEffectLoop = (s, max, costFn, decompose, f, cost, dirty) => readWith({
+  onInput: input => pipe(fromEffect$1(foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, dirty, cost, 0)), flatMap$1(([nextS, nextCost, nextDirty, leftovers]) => {
+    if (isNonEmpty(leftovers)) {
+      return 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 succeed$3([s, cost, dirty, empty()]);
+  }
+  const elem = pipe(input, unsafeGet$1(index));
+  return pipe(costFn(s, elem), map$2(newCost => cost + newCost), flatMap$2(total => {
+    if (total <= max) {
+      return pipe(f(s, elem), flatMap$2(s => foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, true, total, index + 1)));
+    }
+    return pipe(decompose(elem), flatMap$2(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 pipe(f(s, elem), map$2(s => [s, total, true, pipe(input, drop$1(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 succeed$3([s, cost, dirty, pipe(input, drop$1(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 = pipe(decomposed, appendAll(pipe(input, drop$1(index + 1))));
+      return foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, next, dirty, cost, 0);
+    }));
+  }));
+};
+
+/** @internal */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => foldSink(self, {
+  onFailure: fail,
+  onSuccess: f
+}));
+
+/** @internal */
+const forEach = f => {
+  const process = readWithCause({
+    onInput: input => pipe(fromEffect$1(forEach$1(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 => 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 pipe(fromEffect$1(f(pipe(input, unsafeGet$1(index)))), flatMap$1(bool => bool ? forEachWhileReader(f, input, index + 1, length, cont) : write(pipe(input, drop$1(index)))), catchAll(error => pipe(write(pipe(input, drop$1(index))), zipRight$1(fail$1(error)))));
+};
+
+/** @internal */
+const forEachChunkWhile = f => {
+  const reader = readWith({
+    onInput: input => 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(pipe(push, map$2(fromPushPull))));
+const fromPushPull = push => readWith({
+  onInput: input => foldChannel(fromEffect$1(push(some$1(input))), {
+    onFailure: ([either, leftovers]) => match(either, {
+      onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
+      onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
+    }),
+    onSuccess: () => fromPushPull(push)
+  }),
+  onFailure: fail$1,
+  onDone: () => foldChannel(fromEffect$1(push(none())), {
+    onFailure: ([either, leftovers]) => match(either, {
+      onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
+      onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
+    }),
+    onSuccess: () => fromEffect$1(dieMessage$1("BUG: Sink.fromPush - please report an issue at https://github.com/Effect-TS/stream/issues"))
+  })
+});
+
+/** @internal */
+const fromQueue = (queue, options) => options?.shutdown ? unwrapScoped(map$2(acquireRelease(succeed$3(queue), shutdown), fromQueue)) : forEachChunk(input => pipe(offerAll(queue, input)));
+
+/** @internal */
+const head = () => fold(none(), isNone, (option, input) => match$2(option, {
+  onNone: () => some$1(input),
+  onSome: () => option
+}));
+
+/** @internal */
+const ignoreLeftover = self => new SinkImpl(drain$1(toChannel(self)));
+
+/** @internal */
+const last = () => foldLeftChunks(none(), (s, input) => orElse$2(last$1(input), () => s));
+
+/** @internal */
+const leftover = chunk => new SinkImpl(suspend$1(() => write(chunk)));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => {
+  return new SinkImpl(pipe(toChannel(self), map$1(f)));
+});
+
+/** @internal */
+const mapEffect = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapEffect$1(f))));
+
+/** @internal */
+const mapError = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapError$1(f))));
+
+/** @internal */
+const mapLeftover = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapOut(map$5(f)))));
+
+/** @internal */
+const never = /*#__PURE__*/fromEffect(never$2);
+
+/** @internal */
+const orElse = /*#__PURE__*/dual(2, (self, that) => new SinkImpl(pipe(toChannel(self), orElse$1(() => toChannel(that())))));
+
+/** @internal */
+const provideContext = /*#__PURE__*/dual(2, (self, context) => new SinkImpl(pipe(toChannel(self), provideContext$1(context))));
+
+/** @internal */
+const race = /*#__PURE__*/dual(2, (self, that) => pipe(self, raceBoth(that), map(merge$2)));
+
+/** @internal */
+const raceBoth = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => raceWith(self, {
+  other: that,
+  onSelfDone: selfDone => Done$1(map$2(selfDone, left)),
+  onOtherDone: thatDone => Done$1(map$2(thatDone, right)),
+  capacity: options?.capacity ?? 16
+}));
+
+/** @internal */
+const raceWith = /*#__PURE__*/dual(2, (self, options) => {
+  const scoped = gen(function* ($) {
+    const hub = yield* $(bounded$1(options?.capacity ?? 16));
+    const channel1 = yield* $(fromHubScoped(hub));
+    const channel2 = yield* $(fromHubScoped(hub));
+    const reader = toHub(hub);
+    const writer = pipe(channel1, pipeTo(toChannel(self)), mergeWith({
+      other: pipe(channel2, pipeTo(toChannel(options.other))),
+      onSelfDone: options.onSelfDone,
+      onOtherDone: options.onOtherDone
+    }));
+    const racedChannel = mergeWith(reader, {
+      other: writer,
+      onSelfDone: _ => Await(exit => suspend$2(() => exit)),
+      onOtherDone: done => Done$1(suspend$2(() => done))
+    });
+    return new SinkImpl(racedChannel);
+  });
+  return unwrapScoped(scoped);
+});
+
+/** @internal */
+const refineOrDie = /*#__PURE__*/dual(2, (self, pf) => pipe(self, refineOrDieWith(pf, identity)));
+
+/** @internal */
+const refineOrDieWith = /*#__PURE__*/dual(3, (self, pf, f) => {
+  const newChannel = pipe(self, toChannel, catchAll(error => match$2(pf(error), {
+    onNone: () => failCauseSync$1(() => die$2(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__*/dual(2, (self, f) => {
+  const newChannel = pipe(fromEffect$1(make$1(empty())), flatMap$1(ref => pipe(splitWhereSplitter(false, ref, f), pipeToOrFail(toChannel(self)), collectElements, flatMap$1(([leftovers, z]) => pipe(fromEffect$1(get(ref)), flatMap$1(leftover => pipe(write(pipe(leftover, appendAll(flatten$2(leftovers)))), zipRight$1(succeed$1(z)))))))));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const splitWhereSplitter = (written, leftovers, f) => readWithCause({
+  onInput: input => {
+    if (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] = splitAt(input, index);
+      return zipRight$1(write(left), fromEffect$1(set(leftovers, right)));
+    }
+    const index = indexWhere(input, f, 1);
+    if (index === -1) {
+      return zipRight$1(write(input), splitWhereSplitter(true, leftovers, f));
+    }
+    const [left, right] = pipe(input, splitAt(Math.max(index, 1)));
+    return zipRight$1(write(left), fromEffect$1(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 + reduce(chunk, 0, (s, a) => s + a));
+
+/** @internal */
+const summarized = /*#__PURE__*/dual(3, (self, summary, f) => {
+  const newChannel = pipe(fromEffect$1(summary), flatMap$1(start => pipe(self, toChannel, flatMap$1(done => 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 => pipe(foldChunks(empty(), chunk => chunk.length < n, (acc, chunk) => pipe(acc, appendAll(chunk))), flatMap(acc => {
+  const [taken, leftover] = pipe(acc, splitAt(n));
+  return new SinkImpl(pipe(write(leftover), zipRight$1(succeedNow(taken))));
+}));
+
+/** @internal */
+const toChannel = self => isEffect(self) ? toChannel(fromEffect(self)) : self.channel;
+
+/** @internal */
+const unwrap = effect => new SinkImpl(unwrap$1(pipe(effect, map$2(sink => toChannel(sink)))));
+
+/** @internal */
+const unwrapScoped = effect => {
+  return new SinkImpl(unwrapScoped$1(pipe(effect, map$2(sink => toChannel(sink)))));
+};
+
+/** @internal */
+const withDuration = self => pipe(self, summarized(currentTimeMillis, (start, end) => millis(end - start)));
+
+/** @internal */
+const zip = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, z2) => [z, z2], options));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, _) => z, options));
+
+/** @internal */
+const zipRight = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (_, z2) => z2, options));
+
+/** @internal */
+const zipWith = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, f, options) => options?.concurrent ? raceWith(self, {
+  other: that,
+  onSelfDone: match$1({
+    onFailure: cause => Done$1(failCause$3(cause)),
+    onSuccess: leftZ => Await(match$1({
+      onFailure: failCause$3,
+      onSuccess: rightZ => succeed$3(f(leftZ, rightZ))
+    }))
+  }),
+  onOtherDone: match$1({
+    onFailure: cause => Done$1(failCause$3(cause)),
+    onSuccess: rightZ => Await(match$1({
+      onFailure: failCause$3,
+      onSuccess: leftZ => succeed$3(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 pipe(foldLeftChunks(void 0, (_, elems) => map$5(elems, elem => {
+    strings.push(String(elem));
+  })), map(() => strings.join("")));
+});
+
+/** @internal */
+const timed = /*#__PURE__*/pipe( /*#__PURE__*/withDuration(drain), /*#__PURE__*/map(tuple => tuple[1]));
+
+export { drain as $, succeed$1 as A, mapOut as B, ChannelTypeId as C, mapOutEffectPar as D, repeated as E, collectAllN as F, interruptWhen as G, interruptWhenDeferred as H, mapOutEffect as I, mapError$1 as J, mapErrorCause as K, mergeWith as L, mkString as M, orDieWith as N, orElse$1 as O, foldSink as P, collectLeftover as Q, zipRight as R, SinkTypeId as S, fromEffect as T, fail as U, fromChannel as V, provideContext$1 as W, catchAll as X, runDrain as Y, collectAll as Z, count as _, readWithCause as a, foldUntilEffect as a$, fold as a0, foldEffect as a1, forEach as a2, forEachChunk as a3, forEachWhile as a4, head as a5, last as a6, sum as a7, scoped as a8, foldCauseChannel as a9, dimapChunks as aA, dimapChunksEffect as aB, drop as aC, dropUntil as aD, dropUntilEffect as aE, dropWhile as aF, dropWhileEffect as aG, ensuring as aH, ensuringWith as aI, context as aJ, contextWith as aK, contextWithEffect as aL, contextWithSink as aM, every as aN, failSync as aO, failCause as aP, failCauseSync as aQ, filterInput as aR, filterInputEffect as aS, findEffect as aT, foldChunks as aU, foldChunksEffect as aV, foldLeft as aW, foldLeftChunks as aX, foldLeftChunksEffect as aY, foldLeftEffect as aZ, foldUntil as a_, toPull as aa, fromInput as ab, embedInput as ac, mergeMap as ad, sync$1 as ae, writeAll as af, as as ag, collectAllFrom as ah, collectAllToMap as ai, collectAllToMapN as aj, collectAllToSet as ak, collectAllToSetN as al, collectAllUntil as am, collectAllUntilEffect as an, collectAllWhile as ao, collectAllWhileEffect as ap, collectAllWhileWith as aq, mapInput as ar, mapInputEffect as as, mapInputChunks as at, mapInputChunksEffect as au, die as av, dieMessage as aw, dieSync as ax, dimap as ay, dimapEffect as az, fromEffect$1 as b, failCauseSync$1 as b$, foldWeighted as b0, foldWeightedDecompose as b1, foldWeightedDecomposeEffect as b2, foldWeightedEffect as b3, forEachChunkWhile as b4, flatMap as b5, fromHub as b6, fromPush as b7, fromQueue as b8, ignoreLeftover as b9, zipWith as bA, ChannelExceptionTypeId as bB, acquireUseRelease as bC, acquireReleaseOut as bD, as$1 as bE, asUnit as bF, buffer as bG, bufferChunk as bH, concatAll as bI, concatAllWith as bJ, concatMapWith as bK, concatMapWithCustom as bL, collect as bM, concatOut as bN, mapInput$1 as bO, mapInputEffect$1 as bP, mapInputError as bQ, mapInputErrorEffect as bR, mapInputIn as bS, mapInputInEffect as bT, doneCollect as bU, emitCollect as bV, context$1 as bW, contextWith$1 as bX, contextWithChannel as bY, contextWithEffect$1 as bZ, failSync$1 as b_, leftover as ba, map as bb, mapEffect as bc, mapError as bd, mapLeftover as be, never as bf, orElse as bg, provideContext as bh, race as bi, raceBoth as bj, raceWith as bk, refineOrDie as bl, refineOrDieWith as bm, some as bn, splitWhere as bo, succeed as bp, summarized as bq, suspend as br, sync as bs, take as bt, timed as bu, unwrap as bv, unwrapScoped as bw, withDuration as bx, zip as by, zipLeft as bz, failCause$1 as c, flatten as c0, foldChannel as c1, fromEither as c2, fromHub$1 as c3, fromHubScoped as c4, fromOption as c5, fromQueue$1 as c6, map$1 as c7, mapEffect$1 as c8, mergeAll as c9, mergeAllUnbounded as ca, mergeAllUnboundedWith as cb, mergeAllWith as cc, mergeOut as cd, mergeOutWith as ce, never$1 as cf, orDie as cg, provideLayer as ch, mapInputContext as ci, provideSomeLayer as cj, provideService as ck, read as cl, readOrFail as cm, run as cn, runCollect as co, toHub as cp, toQueue as cq, channelToSink as cr, updateService as cs, withSpan as ct, zip$1 as cu, zipLeft$1 as cv, ChannelException as cw, isChannelException as cx, drain$1 as d, unit as e, flatMap$1 as f, run$1 as g, pipeToOrFail as h, collectElements as i, unwrapScoped$1 as j, fail$1 as k, catchAllCause as l, concatMap as m, writeChunk as n, readWith as o, pipeTo as p, identityChannel as q, runScoped as r, suspend$1 as s, toChannel as t, unwrap$1 as u, succeedNow as v, write as w, ensuring$1 as x, ensuringWith$1 as y, zipRight$1 as z };