@fncts/io 0.0.1

package/_cjs/Channel/internal/ChannelExecutor.cjs

@@ -0,0 +1,954 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChannelExecutor = void 0;
+exports.readUpstream = readUpstream;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Queue/api"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/internal/Stack"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/constructors"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/constructors"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Fiber/api/interrupt"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/core-api"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Queue/constructors"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/definition"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/List/api/unsafeTail"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/mutable/ListBuffer"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/interrupt"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/sequenceT"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/UpstreamPullRequest/api"));
+
+var tsplus_module_21 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_22 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/ChildExecutorDecision/api"));
+
+var tsplus_module_23 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/api"));
+
+var _function = /*#__PURE__*/require("@fncts/base/data/function");
+
+var _definition3 = /*#__PURE__*/require("@fncts/io/Channel/definition");
+
+var State = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/internal/ChannelState"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const fileName_1 = "(@fncts/io) src/Channel/internal/ChannelExecutor.ts";
+
+class PullFromUpstream {
+  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;
+    this._tag = "PullFromUpstream"
+    /* SubexecutorStackTag.PullFromUpstream */
+    ;
+  }
+
+  close(ex) {
+    const fin1 = this.upstreamExecutor.close(ex);
+    const fins = tsplus_module_1.enqueue_(tsplus_module_1.map_(this.activeChildExecutors, child => child !== null ? child.childExecutor.close(ex) : null), fin1);
+    const finalizer = tsplus_module_1.foldLeft_(fins, null, (acc, next) => {
+      if (acc === null) {
+        if (next === null) {
+          return null;
+        } else {
+          return tsplus_module_2.result(next);
+        }
+      } else {
+        if (next === null) {
+          return acc;
+        } else {
+          return tsplus_module_2.zipWith_(acc, tsplus_module_2.result(next), (a, b) => tsplus_module_3.apSecond_(a, b));
+        }
+      }
+    });
+
+    if (finalizer) {
+      return tsplus_module_2.flatMap_(finalizer, tsplus_module_2.fromExitNow, fileName_1 + ":71:31");
+    } else {
+      return null;
+    }
+  }
+
+  enqueuePullFromChild(child) {
+    return new PullFromUpstream(this.upstreamExecutor, this.createChild, this.lastDone, tsplus_module_1.enqueue_(this.activeChildExecutors, child), this.combineChildResults, this.combineWithChildResult, this.onPull, this.onEmit);
+  }
+
+}
+
+class PullFromChild {
+  constructor(childExecutor, parentSubexecutor, onEmit) {
+    this.childExecutor = childExecutor;
+    this.parentSubexecutor = parentSubexecutor;
+    this.onEmit = onEmit;
+    this._tag = "PullFromChild"
+    /* SubexecutorStackTag.PullFromChild */
+    ;
+  }
+
+  close(ex) {
+    const fin1 = this.childExecutor.close(ex);
+    const fin2 = this.parentSubexecutor.close(ex);
+
+    if (fin1 === null) {
+      if (fin2 === null) {
+        return null;
+      } else {
+        return fin2;
+      }
+    } else {
+      if (fin2 === null) {
+        return fin1;
+      } else {
+        return tsplus_module_2.flatMap_(tsplus_module_2.zipWith_(tsplus_module_2.result(fin1), tsplus_module_2.result(fin2), (a, b) => tsplus_module_3.apSecond_(a, b)), tsplus_module_2.fromExitNow, fileName_1 + ":112:81");
+      }
+    }
+  }
+
+  enqueuePullFromChild(_child) {
+    return this;
+  }
+
+}
+
+class DrainChildExecutors {
+  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;
+    this._tag = "DrainChildExecutors"
+    /* SubexecutorStackTag.DrainChildExecutors */
+    ;
+  }
+
+  close(ex) {
+    const fin1 = this.upstreamExecutor.close(ex);
+    const fins = tsplus_module_1.enqueue_(tsplus_module_1.map_(this.activeChildExecutors, child => child !== null ? child.childExecutor.close(ex) : null), fin1);
+    return tsplus_module_1.foldLeft_(fins, null, (acc, next) => {
+      if (acc === null) {
+        if (next === null) {
+          return null;
+        } else {
+          return tsplus_module_2.result(next);
+        }
+      } else {
+        if (next === null) {
+          return acc;
+        } else {
+          return tsplus_module_2.zipWith_(acc, tsplus_module_2.result(next), (a, b) => tsplus_module_3.apSecond_(a, b));
+        }
+      }
+    });
+  }
+
+  enqueuePullFromChild(child) {
+    return new DrainChildExecutors(this.upstreamExecutor, this.lastDone, tsplus_module_1.enqueue_(this.activeChildExecutors, child), this.upstreamDone, this.combineChildResults, this.combineWithChildResult, this.onPull);
+  }
+
+}
+
+class Emit {
+  constructor(value, next) {
+    this.value = value;
+    this.next = next;
+    this._tag = "Emit"
+    /* SubexecutorStackTag.Emit */
+    ;
+  }
+
+  close(ex) {
+    return this.next !== null ? this.next.close(ex) : null;
+  }
+
+  enqueuePullFromChild(_child) {
+    return this;
+  }
+
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * ChannelExecutor
+ * -------------------------------------------------------------------------------------------------
+ */
+
+
+function readUpstream(r, cont) {
+  const readStack = tsplus_module_4.single(r);
+
+  const read = () => {
+    const current = readStack.pop();
+
+    if (current.upstream === null) {
+      return tsplus_module_2.defer(cont, fileName_1 + ":194:22");
+    }
+
+    const state = current.upstream.run();
+
+    switch (state._tag) {
+      case "Emit"
+      /* State.ChannelStateTag.Emit */
+      :
+        {
+          const emitEffect = current.onEmit(current.upstream.getEmit());
+
+          if (readStack === undefined) {
+            if (emitEffect === null) {
+              return tsplus_module_2.defer(() => cont(), fileName_1 + ":202:28");
+            } else {
+              return tsplus_module_2.flatMap_(emitEffect, () => cont(), fileName_1 + ":204:38");
+            }
+          } else {
+            if (emitEffect === null) {
+              return tsplus_module_2.defer(() => read(), fileName_1 + ":208:28");
+            } else {
+              return tsplus_module_2.flatMap_(emitEffect, () => read(), fileName_1 + ":210:38");
+            }
+          }
+        }
+
+      case "Done"
+      /* State.ChannelStateTag.Done */
+      :
+        {
+          const doneEffect = current.onDone(current.upstream.getDone());
+
+          if (readStack === undefined) {
+            if (doneEffect === null) {
+              return tsplus_module_2.defer(() => cont(), fileName_1 + ":218:28");
+            } else {
+              return tsplus_module_2.flatMap_(doneEffect, () => cont(), fileName_1 + ":220:38");
+            }
+          } else {
+            if (doneEffect === null) {
+              return tsplus_module_2.defer(() => read(), fileName_1 + ":224:28");
+            } else {
+              return tsplus_module_2.flatMap_(doneEffect, () => read(), fileName_1 + ":226:38");
+            }
+          }
+        }
+
+      case "Effect"
+      /* State.ChannelStateTag.Effect */
+      :
+        {
+          readStack.push(current);
+          return tsplus_module_2.flatMap_(tsplus_module_2.catchAllCause_(current.onEffect(state.io), cause => tsplus_module_2.defer(() => {
+            const doneEffect = current.onDone(tsplus_module_5.failCause(cause));
+            return doneEffect === null ? tsplus_module_2.unit : doneEffect;
+          }, fileName_1 + ":235:21"), fileName_1 + ":234:25"), () => read(), fileName_1 + ":240:19");
+        }
+
+      case "Read"
+      /* State.ChannelStateTag.Read */
+      :
+        {
+          readStack.push(current);
+          readStack.push(state);
+          return tsplus_module_2.defer(() => read(), fileName_1 + ":245:24");
+        }
+    }
+  };
+
+  return read();
+}
+
+class ChannelExecutor {
+  constructor(initialChannel, providedEnv, executeCloseLastSubstream) {
+    this.providedEnv = providedEnv;
+    this.executeCloseLastSubstream = executeCloseLastSubstream;
+    this.input = null;
+    this.inProgressFinalizer = null;
+    this.activeSubexecutor = null;
+    this.doneStack = tsplus_module_6.nil();
+    this.done = null;
+    this.cancelled = null;
+    this.closeLastSubstream = null;
+    this.currentChannel = initialChannel();
+  }
+
+  getDone() {
+    return this.done;
+  }
+
+  getEmit() {
+    return this.emitted;
+  }
+
+  cancelWith(exit) {
+    this.cancelled = exit;
+  }
+
+  run() {
+    let result = null;
+
+    while (result === null) {
+      if (this.cancelled !== null) {
+        result = this.processCancellation();
+      } else if (this.activeSubexecutor !== null) {
+        result = this.runSubexecutor();
+      } else {
+        if (this.currentChannel === null) {
+          return State._Done;
+        } else {
+          try {
+            void 0;
+            const currentChannel = this.currentChannel;
+
+            switch (currentChannel._tag) {
+              case "Bridge"
+              /* ChannelTag.Bridge */
+              :
+                {
+                  if (this.input !== null) {
+                    const inputExecutor = this.input;
+                    this.input = null;
+                    const drainer = tsplus_module_2.apSecond_(currentChannel.input.awaitRead, tsplus_module_2.defer(() => {
+                      const state = inputExecutor.run();
+
+                      switch (state._tag) {
+                        case "Done"
+                        /* State.ChannelStateTag.Done */
+                        :
+                          {
+                            const done = inputExecutor.getDone();
+                            return tsplus_module_3.match_(done, cause => currentChannel.input.error(cause), value => currentChannel.input.done(value));
+                          }
+
+                        case "Emit"
+                        /* State.ChannelStateTag.Emit */
+                        :
+                          {
+                            return tsplus_module_2.flatMap_(currentChannel.input.emit(inputExecutor.getEmit()), () => drainer, fileName_1 + ":317:92");
+                          }
+
+                        case "Effect"
+                        /* State.ChannelStateTag.Effect */
+                        :
+                          {
+                            return tsplus_module_2.matchCauseIO_(state.effect, cause => currentChannel.input.error(cause), () => drainer, fileName_1 + ":320:59");
+                          }
+
+                        case "Read"
+                        /* State.ChannelStateTag.Read */
+                        :
+                          {
+                            return tsplus_module_2.catchAllCause_(readUpstream(state, () => drainer), cause => currentChannel.input.error(cause), fileName_1 + ":326:82");
+                          }
+                      }
+                    }, fileName_1 + ":305:29"), fileName_1 + ":304:94");
+                    result = new State.Effect(tsplus_module_2.flatMap_(tsplus_module_2.fork(drainer), fiber => tsplus_module_2.succeed(() => {
+                      this.addFinalizer(exit => tsplus_module_2.apSecond_(tsplus_module_7.interrupt(fiber), tsplus_module_2.defer(() => {
+                        const effect = this.restorePipe(exit, inputExecutor);
+
+                        if (effect !== null) {
+                          return effect;
+                        } else {
+                          return tsplus_module_2.unit;
+                        }
+                      }, fileName_1 + ":338:37"), fileName_1 + ":337:51"));
+                    }, fileName_1 + ":335:33"), fileName_1 + ":334:41"));
+                  }
+
+                  break;
+                }
+
+              case "PipeTo"
+              /* ChannelTag.PipeTo */
+              :
+                {
+                  const previousInput = this.input;
+                  const leftExec = new ChannelExecutor(currentChannel.left, this.providedEnv, _ => this.executeCloseLastSubstream(_));
+                  leftExec.input = previousInput;
+                  this.input = leftExec;
+                  this.addFinalizer(exit => {
+                    const effect = this.restorePipe(exit, previousInput);
+
+                    if (effect !== null) {
+                      return effect;
+                    } else {
+                      return tsplus_module_2.unit;
+                    }
+                  });
+                  this.currentChannel = currentChannel.right();
+                  break;
+                }
+
+              case "Read"
+              /* ChannelTag.Read */
+              :
+                {
+                  const read = currentChannel;
+                  result = new State.Read(this.input, _function.identity, out => {
+                    this.currentChannel = read.more(out);
+                    return null;
+                  }, exit => {
+                    this.currentChannel = read.done.onExit(exit);
+                    return null;
+                  });
+                  break;
+                }
+
+              case "Done"
+              /* ChannelTag.Done */
+              :
+                {
+                  result = this.doneSucceed(currentChannel.terminal());
+                  break;
+                }
+
+              case "Halt"
+              /* ChannelTag.Halt */
+              :
+                {
+                  result = this.doneHalt(currentChannel.cause());
+                  break;
+                }
+
+              case "FromIO"
+              /* ChannelTag.FromIO */
+              :
+                {
+                  const pio = this.providedEnv === null ? currentChannel.io : tsplus_module_8.provideEnvironment_(currentChannel.io, this.providedEnv, fileName_1 + ":400:59");
+                  result = new State.Effect(tsplus_module_2.matchCauseIO_(pio, cause => {
+                    const state = this.doneHalt(cause);
+
+                    if (state !== null && state._tag === "Effect"
+                    /* State.ChannelStateTag.Effect */
+                    ) {
+                      return state.effect;
+                    } else {
+                      return tsplus_module_2.unit;
+                    }
+                  }, z => {
+                    const state = this.doneSucceed(z);
+
+                    if (state !== null && state._tag === "Effect"
+                    /* State.ChannelStateTag.Effect */
+                    ) {
+                      return state.effect;
+                    } else {
+                      return tsplus_module_2.unit;
+                    }
+                  }, fileName_1 + ":402:35"));
+                  break;
+                }
+
+              case "Defer"
+              /* ChannelTag.Defer */
+              :
+                {
+                  this.currentChannel = currentChannel.effect();
+                  break;
+                }
+
+              case "Emit"
+              /* ChannelTag.Emit */
+              :
+                {
+                  this.emitted = currentChannel.out();
+                  this.currentChannel = this.activeSubexecutor !== null ? null : tsplus_module_9.endNow(undefined);
+                  result = State._Emit;
+                  break;
+                }
+
+              case "Ensuring"
+              /* ChannelTag.Ensuring */
+              :
+                {
+                  this.runEnsuring(currentChannel);
+                  break;
+                }
+
+              case "ConcatAll"
+              /* ChannelTag.ConcatAll */
+              :
+                {
+                  const innerExecuteLastClose = f => tsplus_module_2.succeed(() => {
+                    const prevLastClose = this.closeLastSubstream === null ? tsplus_module_2.unit : this.closeLastSubstream;
+                    this.closeLastSubstream = tsplus_module_2.flatMap_(prevLastClose, () => f, fileName_1 + ":441:68");
+                  }, fileName_1 + ":439:29");
+
+                  const exec = new ChannelExecutor(() => currentChannel.value, this.providedEnv, innerExecuteLastClose);
+                  exec.input = this.input;
+                  this.activeSubexecutor = new PullFromUpstream(exec, currentChannel.k, null, tsplus_module_10.empty(), currentChannel.combineInners, currentChannel.combineAll, currentChannel.onPull, currentChannel.onEmit);
+                  this.closeLastSubstream = null;
+                  this.currentChannel = null;
+                  break;
+                }
+
+              case "Fold"
+              /* ChannelTag.Fold */
+              :
+                {
+                  this.doneStack = tsplus_module_11.prepend_(this.doneStack, currentChannel.k);
+                  this.currentChannel = currentChannel.value;
+                  break;
+                }
+
+              case "BracketOut"
+              /* ChannelTag.BracketOut */
+              :
+                {
+                  result = this.runBracketOut(currentChannel);
+                  break;
+                }
+
+              case "Provide"
+              /* ChannelTag.Provide */
+              :
+                {
+                  const previousEnv = this.providedEnv;
+                  this.providedEnv = currentChannel.environment;
+                  this.currentChannel = currentChannel.inner;
+                  this.addFinalizer(() => tsplus_module_2.succeed(() => {
+                    this.providedEnv = previousEnv;
+                  }, fileName_1 + ":473:29"));
+                  break;
+                }
+            }
+          } catch (e) {
+            this.currentChannel = tsplus_module_9.failCauseNow(tsplus_module_12.halt(e));
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  restorePipe(exit, prev) {
+    const currInput = this.input;
+    this.input = prev;
+    return currInput !== null ? currInput.close(exit) : tsplus_module_2.unit;
+  }
+
+  popAllFinalizers(exit) {
+    /**
+     * @tsplus tailrec
+     */
+    const unwind = (acc, conts) => {
+      if (tsplus_module_13.isEmpty(conts)) {
+        return acc;
+      } else {
+        const head = tsplus_module_11.unsafeHead(conts);
+        (0, _definition3.concreteContinuation)(head);
+
+        if (head._tag === "ContinuationK"
+        /* ChannelTag.ContinuationK */
+        ) {
+          return unwind(acc, tsplus_module_14.unsafeTail(conts));
+        } else {
+          return unwind(tsplus_module_2.apSecond_(acc, tsplus_module_2.result(head.finalizer(exit)), fileName_1 + ":511:37"), tsplus_module_14.unsafeTail(conts));
+        }
+      }
+    };
+
+    const effect = tsplus_module_2.flatMap_(unwind(tsplus_module_2.succeedNow(tsplus_module_5.succeed(undefined), fileName_1 + ":515:42"), this.doneStack), tsplus_module_2.fromExitNow, fileName_1 + ":515:92");
+    this.doneStack = tsplus_module_6.nil();
+    this.storeInProgressFinalizer(effect);
+    return effect;
+  }
+
+  popNextFinalizers() {
+    const builder = new tsplus_module_15.ListBuffer();
+    /**
+     * @tsplus tailrec
+     */
+
+    const go = stack => {
+      if (tsplus_module_13.isEmpty(stack)) {
+        return tsplus_module_6.nil();
+      } else {
+        const head = tsplus_module_11.unsafeHead(stack);
+        (0, _definition3.concreteContinuation)(head);
+
+        if (head._tag === "ContinuationK"
+        /* ChannelTag.ContinuationK */
+        ) {
+          return stack;
+        } else {
+          builder.append(head);
+          return go(tsplus_module_14.unsafeTail(stack));
+        }
+      }
+    };
+
+    this.doneStack = go(this.doneStack);
+    return builder.toList;
+  }
+
+  storeInProgressFinalizer(finalizer) {
+    this.inProgressFinalizer = finalizer;
+  }
+
+  clearInProgressFinalizer() {
+    this.inProgressFinalizer = null;
+  }
+
+  ifNotNull(io) {
+    return io !== null ? io : tsplus_module_2.unit;
+  }
+
+  close(exit) {
+    const runInProgressFinalizers = this.inProgressFinalizer !== null ? tsplus_module_2.ensuring_(this.inProgressFinalizer, tsplus_module_2.succeed(() => this.clearInProgressFinalizer(), fileName_1 + ":559:55"), fileName_1 + ":559:44") : null;
+    const closeSubexecutors = this.activeSubexecutor === null ? null : this.activeSubexecutor.close(exit);
+    let closeSelf = null;
+    const selfFinalizers = this.popAllFinalizers(exit);
+
+    if (selfFinalizers !== null) {
+      closeSelf = tsplus_module_2.ensuring_(selfFinalizers, tsplus_module_2.succeed(() => this.clearInProgressFinalizer(), fileName_1 + ":570:53"), fileName_1 + ":570:42");
+    }
+
+    if (closeSubexecutors === null && runInProgressFinalizers === null && closeSelf === null) {
+      return null;
+    } else {
+      return tsplus_module_2.flatMap_(tsplus_module_16.uninterruptible(tsplus_module_2.map_(tsplus_module_17.sequenceT(tsplus_module_2.result(this.ifNotNull(closeSubexecutors)), tsplus_module_2.result(this.ifNotNull(runInProgressFinalizers)), tsplus_module_2.result(this.ifNotNull(closeSelf))), ([a, b, c]) => tsplus_module_3.apSecond_(tsplus_module_3.apSecond_(a, b), c), fileName_1 + ":581:13")), tsplus_module_2.fromExitNow, fileName_1 + ":582:33");
+    }
+  }
+
+  processCancellation() {
+    this.currentChannel = null;
+    this.done = this.cancelled;
+    this.cancelled = null;
+    return State._Done;
+  }
+
+  finishSubexecutorWithCloseEffect(subexecDone, ...closeFns) {
+    this.addFinalizer(() => tsplus_module_2.foreachDiscard_(closeFns, closeFn => tsplus_module_2.flatMap_(tsplus_module_2.succeed(() => closeFn(subexecDone), fileName_1 + ":599:19"), closeEffect => {
+      if (closeEffect !== null) {
+        return closeEffect;
+      } else {
+        return tsplus_module_2.unit;
+      }
+    }, fileName_1 + ":599:49")));
+    const state = tsplus_module_3.match_(subexecDone, e => this.doneHalt(e), a => this.doneSucceed(a));
+    this.activeSubexecutor = null;
+    return state;
+  }
+
+  runFinalizers(finalizers, exit) {
+    if (tsplus_module_13.isEmpty(finalizers)) {
+      return tsplus_module_2.unit;
+    }
+
+    return tsplus_module_2.flatMap_(tsplus_module_2.map_(tsplus_module_2.foreach_(finalizers, cont => tsplus_module_2.result(cont(exit)), fileName_1 + ":623:22"), results => tsplus_module_18.getOrElse_(tsplus_module_3.collectAll(results), () => tsplus_module_5.unit), fileName_1 + ":624:11"), tsplus_module_2.fromExitNow, fileName_1 + ":625:15");
+  }
+
+  runSubexecutor() {
+    switch (this.activeSubexecutor._tag) {
+      case "PullFromUpstream"
+      /* SubexecutorStackTag.PullFromUpstream */
+      :
+        {
+          return this.pullFromUpstream(this.activeSubexecutor);
+        }
+
+      case "DrainChildExecutors"
+      /* SubexecutorStackTag.DrainChildExecutors */
+      :
+        {
+          return this.drainChildExecutors(this.activeSubexecutor);
+        }
+
+      case "PullFromChild"
+      /* SubexecutorStackTag.PullFromChild */
+      :
+        {
+          return this.pullFromChild(this.activeSubexecutor.childExecutor, this.activeSubexecutor.parentSubexecutor, this.activeSubexecutor.onEmit, this.activeSubexecutor);
+        }
+
+      case "Emit"
+      /* SubexecutorStackTag.Emit */
+      :
+        {
+          this.emitted = this.activeSubexecutor.value;
+          this.activeSubexecutor = this.activeSubexecutor.next;
+          return new State.Emit();
+        }
+    }
+  }
+
+  replaceSubexecutor(nextSubExec) {
+    this.currentChannel = null;
+    this.activeSubexecutor = nextSubExec;
+  }
+
+  applyUpstreamPullStrategy(upstreamFinished, queue, strategy) {
+    switch (strategy._tag) {
+      case "PullAfterNext":
+        {
+          return [strategy.emitSeparator, !upstreamFinished || tsplus_module_1.exists_(queue, _ => _ !== null) ? tsplus_module_1.prepend_(queue, null) : queue];
+        }
+
+      case "PullAfterAllEnqueued":
+        {
+          return [strategy.emitSeparator, !upstreamFinished || tsplus_module_1.exists_(queue, _ => _ !== null) ? tsplus_module_1.enqueue_(queue, null) : queue];
+        }
+    }
+  }
+
+  pullFromUpstream(subexec) {
+    return tsplus_module_19.match_(tsplus_module_1.dequeue(subexec.activeChildExecutors), () => this.performPullFromUpstream(subexec), ([activeChild, rest]) => {
+      if (activeChild === null) {
+        return this.performPullFromUpstream(new PullFromUpstream(subexec.upstreamExecutor, subexec.createChild, subexec.lastDone, rest, subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull, subexec.onEmit));
+      } else {
+        this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, new PullFromUpstream(subexec.upstreamExecutor, subexec.createChild, subexec.lastDone, rest, subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull, subexec.onEmit), activeChild.onEmit));
+        return null;
+      }
+    });
+  }
+
+  performPullFromUpstream(subexec) {
+    return new State.Read(subexec.upstreamExecutor, effect => {
+      const closeLast = this.closeLastSubstream === null ? tsplus_module_2.unit : this.closeLastSubstream;
+      this.closeLastSubstream = null;
+      return tsplus_module_2.apSecond_(this.executeCloseLastSubstream(closeLast), effect, fileName_1 + ":724:66");
+    }, emitted => {
+      if (this.closeLastSubstream !== null) {
+        const closeLast = this.closeLastSubstream;
+        this.closeLastSubstream = null;
+        return tsplus_module_2.map_(this.executeCloseLastSubstream(closeLast), () => {
+          const childExecutor = new ChannelExecutor(() => subexec.createChild(emitted), this.providedEnv, _ => this.executeCloseLastSubstream(_));
+          childExecutor.input = this.input;
+          const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexec.activeChildExecutors, subexec.onPull(tsplus_module_20.pulled(emitted)));
+          this.activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexec.upstreamExecutor, subexec.createChild, subexec.lastDone, updatedChildExecutors, subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull, subexec.onEmit), subexec.onEmit);
+
+          if (tsplus_module_21.isJust(emitSeparator)) {
+            this.activeSubexecutor = new Emit(emitSeparator.value, this.activeSubexecutor);
+          }
+        }, fileName_1 + ":730:63");
+      } else {
+        const childExecutor = new ChannelExecutor(() => subexec.createChild(emitted), this.providedEnv, _ => this.executeCloseLastSubstream(_));
+        childExecutor.input = this.input;
+        const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(false, subexec.activeChildExecutors, subexec.onPull(tsplus_module_20.pulled(emitted)));
+        this.activeSubexecutor = new PullFromChild(childExecutor, new PullFromUpstream(subexec.upstreamExecutor, subexec.createChild, subexec.lastDone, updatedChildExecutors, subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull, subexec.onEmit), subexec.onEmit);
+
+        if (tsplus_module_21.isJust(emitSeparator)) {
+          this.activeSubexecutor = new Emit(emitSeparator.value, this.activeSubexecutor);
+        }
+
+        return null;
+      }
+    }, exit => {
+      if (tsplus_module_1.exists_(subexec.activeChildExecutors, _ => _ !== null)) {
+        const drain = new DrainChildExecutors(subexec.upstreamExecutor, subexec.lastDone, tsplus_module_1.enqueue_(subexec.activeChildExecutors, null), subexec.upstreamExecutor.getDone(), subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull);
+
+        if (this.closeLastSubstream !== null) {
+          const closeLast = this.closeLastSubstream;
+          this.closeLastSubstream = null;
+          return tsplus_module_2.map_(this.executeCloseLastSubstream(closeLast), () => {
+            this.replaceSubexecutor(drain);
+          }, fileName_1 + ":810:65");
+        } else {
+          this.replaceSubexecutor(drain);
+          return null;
+        }
+      } else {
+        const lastClose = this.closeLastSubstream;
+        return State.effectOrNullIgnored(this.finishSubexecutorWithCloseEffect(tsplus_module_3.map_(exit, _ => subexec.combineWithChildResult(subexec.lastDone, _)), () => lastClose, exit => subexec.upstreamExecutor.close(exit)));
+      }
+    });
+  }
+
+  drainChildExecutors(subexec) {
+    return tsplus_module_19.match_(tsplus_module_1.dequeue(subexec.activeChildExecutors), () => {
+      const lastClose = this.closeLastSubstream;
+
+      if (lastClose !== null) {
+        this.addFinalizer(_ => lastClose);
+      }
+
+      return this.finishSubexecutorWithCloseEffect(subexec.upstreamDone, () => lastClose, _ => subexec.upstreamExecutor.close(_));
+    }, ([activeChild, rest]) => {
+      if (activeChild === null) {
+        const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(true, rest, subexec.onPull(tsplus_module_20.noUpstream(tsplus_module_1.count_(rest, _ => _ !== null))));
+        this.replaceSubexecutor(new DrainChildExecutors(subexec.upstreamExecutor, subexec.lastDone, remainingExecutors, subexec.upstreamExecutor.getDone(), subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull));
+        return tsplus_module_19.match_(emitSeparator, () => null, value => {
+          this.emitted = value;
+          return new State.Emit();
+        });
+      } else {
+        this.replaceSubexecutor(new PullFromChild(activeChild.childExecutor, new DrainChildExecutors(subexec.upstreamExecutor, subexec.lastDone, rest, subexec.upstreamExecutor.getDone(), subexec.combineChildResults, subexec.combineWithChildResult, subexec.onPull), activeChild.onEmit));
+        return null;
+      }
+    });
+  }
+
+  pullFromChild(childExecutor, parentSubexecutor, onEmitted, subexec) {
+    const handleSubexecFailure = cause => {
+      return this.finishSubexecutorWithCloseEffect(tsplus_module_5.failCause(cause), _ => parentSubexecutor.close(_), _ => childExecutor.close(_));
+    };
+
+    const finishWithDoneValue = doneValue => {
+      switch (parentSubexecutor._tag) {
+        case "PullFromUpstream"
+        /* SubexecutorStackTag.PullFromUpstream */
+        :
+          {
+            const modifiedParent = new PullFromUpstream(parentSubexecutor.upstreamExecutor, parentSubexecutor.createChild, parentSubexecutor.lastDone !== null ? parentSubexecutor.combineChildResults(parentSubexecutor.lastDone, doneValue) : doneValue, parentSubexecutor.activeChildExecutors, parentSubexecutor.combineChildResults, parentSubexecutor.combineWithChildResult, parentSubexecutor.onPull, parentSubexecutor.onEmit);
+            this.closeLastSubstream = childExecutor.close(tsplus_module_5.succeed(doneValue));
+            this.replaceSubexecutor(modifiedParent);
+            break;
+          }
+
+        case "DrainChildExecutors"
+        /* SubexecutorStackTag.DrainChildExecutors */
+        :
+          {
+            const modifiedParent = new DrainChildExecutors(parentSubexecutor.upstreamExecutor, parentSubexecutor.lastDone !== null ? parentSubexecutor.combineChildResults(parentSubexecutor.lastDone, doneValue) : doneValue, parentSubexecutor.activeChildExecutors, parentSubexecutor.upstreamDone, parentSubexecutor.combineChildResults, parentSubexecutor.combineWithChildResult, parentSubexecutor.onPull);
+            this.closeLastSubstream = childExecutor.close(tsplus_module_5.succeed(doneValue));
+            this.replaceSubexecutor(modifiedParent);
+            break;
+          }
+
+        default:
+          {
+            throw new Error("Bug: this should not get here");
+          }
+      }
+    };
+
+    return new State.Read(childExecutor, _function.identity, emitted => {
+      tsplus_module_22.match_(onEmitted(emitted), () => void 0, doneValue => finishWithDoneValue(doneValue), () => {
+        const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexec);
+        this.replaceSubexecutor(modifiedParent);
+      });
+      this.activeSubexecutor = new Emit(emitted, this.activeSubexecutor);
+      return null;
+    }, exit => tsplus_module_3.match_(exit, cause => State.effectOrNullIgnored(handleSubexecFailure(cause)), doneValue => {
+      finishWithDoneValue(doneValue);
+      return null;
+    }));
+  }
+
+  doneSucceed(z) {
+    if (tsplus_module_13.isEmpty(this.doneStack)) {
+      this.done = tsplus_module_5.succeed(z);
+      this.currentChannel = null;
+      return State._Done;
+    }
+
+    const head = tsplus_module_11.unsafeHead(this.doneStack);
+    (0, _definition3.concreteContinuation)(head);
+
+    if (head._tag === "ContinuationK"
+    /* ChannelTag.ContinuationK */
+    ) {
+      this.doneStack = tsplus_module_14.unsafeTail(this.doneStack);
+      this.currentChannel = head.onSuccess(z);
+      return null;
+    } else {
+      const finalizers = this.popNextFinalizers();
+
+      if (tsplus_module_13.isEmpty(this.doneStack)) {
+        this.doneStack = finalizers;
+        this.done = tsplus_module_5.succeed(z);
+        this.currentChannel = null;
+        return State._Done;
+      } else {
+        const finalizerEffect = this.runFinalizers(tsplus_module_11.map_(finalizers, _ => _.finalizer), tsplus_module_5.succeed(z));
+        this.storeInProgressFinalizer(finalizerEffect);
+        return new State.Effect(tsplus_module_2.flatMap_(tsplus_module_16.uninterruptible(tsplus_module_2.ensuring_(finalizerEffect, tsplus_module_2.succeed(() => {
+          this.clearInProgressFinalizer();
+        }, fileName_1 + ":1002:25"), fileName_1 + ":1001:22")), () => tsplus_module_2.succeed(() => this.doneSucceed(z), fileName_1 + ":1006:54"), fileName_1 + ":1006:37"));
+      }
+    }
+  }
+
+  doneHalt(cause) {
+    if (tsplus_module_13.isEmpty(this.doneStack)) {
+      this.done = tsplus_module_5.failCause(cause);
+      this.currentChannel = null;
+      return State._Done;
+    }
+
+    const head = tsplus_module_11.unsafeHead(this.doneStack);
+    (0, _definition3.concreteContinuation)(head);
+
+    if (head._tag === "ContinuationK"
+    /* ChannelTag.ContinuationK */
+    ) {
+      this.doneStack = tsplus_module_14.unsafeTail(this.doneStack);
+      this.currentChannel = head.onHalt(cause);
+      return null;
+    } else {
+      const finalizers = this.popNextFinalizers();
+
+      if (tsplus_module_13.isEmpty(this.doneStack)) {
+        this.doneStack = finalizers;
+        this.done = tsplus_module_5.failCause(cause);
+        this.currentChannel = null;
+        return State._Done;
+      } else {
+        const finalizerEffect = this.runFinalizers(tsplus_module_11.map_(finalizers, _ => _.finalizer), tsplus_module_5.failCause(cause));
+        this.storeInProgressFinalizer(finalizerEffect);
+        return new State.Effect(tsplus_module_2.flatMap_(tsplus_module_16.uninterruptible(tsplus_module_2.ensuring_(finalizerEffect, tsplus_module_2.succeed(() => {
+          this.clearInProgressFinalizer();
+        }, fileName_1 + ":1042:25"), fileName_1 + ":1041:22")), () => tsplus_module_2.succeed(() => this.doneHalt(cause), fileName_1 + ":1046:54"), fileName_1 + ":1046:37"));
+      }
+    }
+  }
+
+  addFinalizer(f) {
+    this.doneStack = tsplus_module_11.prepend_(this.doneStack, new _definition3.ContinuationFinalizer(f));
+  }
+
+  runBracketOut(bracketOut) {
+    return new State.Effect(tsplus_module_16.uninterruptibleMask(({
+      restore
+    }) => tsplus_module_2.matchCauseIO_(restore(bracketOut.acquire), cause => tsplus_module_2.succeed(() => {
+      this.currentChannel = tsplus_module_9.failCause(() => cause);
+    }, fileName_1 + ":1061:23"), out => tsplus_module_2.succeed(() => {
+      this.addFinalizer(e => bracketOut.finalizer(out, e));
+      this.currentChannel = tsplus_module_23.write(() => out);
+    }, fileName_1 + ":1065:23"), fileName_1 + ":1059:49")));
+  }
+
+  runEnsuring(ensuring) {
+    this.addFinalizer(ensuring.finalizer);
+    this.currentChannel = ensuring.channel;
+  }
+
+}
+
+exports.ChannelExecutor = ChannelExecutor;
+//# sourceMappingURL=ChannelExecutor.cjs.map