@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/channel/channelExecutor.ts

@@ -1,1200 +0,0 @@
-import * as Cause from "../../Cause.js"
-import type * as Channel from "../../Channel.js"
-import type * as ChildExecutorDecision from "../../ChildExecutorDecision.js"
-import type * as Context from "../../Context.js"
-import * as Deferred from "../../Deferred.js"
-import * as Effect from "../../Effect.js"
-import * as ExecutionStrategy from "../../ExecutionStrategy.js"
-import * as Exit from "../../Exit.js"
-import * as Fiber from "../../Fiber.js"
-import * as FiberId from "../../FiberId.js"
-import { dual, identity, pipe } from "../../Function.js"
-import * as HashSet from "../../HashSet.js"
-import * as Option from "../../Option.js"
-import * as Scope from "../../Scope.js"
-import type * as UpstreamPullStrategy from "../../UpstreamPullStrategy.js"
-import * as core from "../core-stream.js"
-import * as ChannelOpCodes from "../opCodes/channel.js"
-import * as ChildExecutorDecisionOpCodes from "../opCodes/channelChildExecutorDecision.js"
-import * as ChannelStateOpCodes from "../opCodes/channelState.js"
-import * as UpstreamPullStrategyOpCodes from "../opCodes/channelUpstreamPullStrategy.js"
-import * as ContinuationOpCodes from "../opCodes/continuation.js"
-import * as ChannelState from "./channelState.js"
-import * as Continuation from "./continuation.js"
-import * as Subexecutor from "./subexecutor.js"
-import * as upstreamPullRequest from "./upstreamPullRequest.js"
-
-export type ErasedChannel<R> = Channel.Channel<unknown, unknown, unknown, unknown, unknown, unknown, R>
-
-/** @internal */
-export type ErasedExecutor<R> = ChannelExecutor<unknown, unknown, unknown, unknown, unknown, unknown, R>
-
-/** @internal */
-export type ErasedContinuation<R> = Continuation.Continuation<
-  R,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->
-
-/** @internal */
-export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R>
-
-/** @internal */
-export class ChannelExecutor<
-  out OutElem,
-  in InElem = unknown,
-  out OutErr = never,
-  in InErr = unknown,
-  out OutDone = void,
-  in InDone = unknown,
-  in out Env = never
-> {
-  private _activeSubexecutor: Subexecutor.Subexecutor<Env> | undefined = undefined
-
-  private _cancelled: Exit.Exit<OutErr, OutDone> | undefined = undefined
-
-  private _closeLastSubstream: Effect.Effect<unknown, never, Env> | undefined = undefined
-
-  private _currentChannel: core.Primitive | undefined
-
-  private _done: Exit.Exit<unknown, unknown> | undefined = undefined
-
-  private _doneStack: Array<ErasedContinuation<Env>> = []
-
-  private _emitted: unknown | undefined = undefined
-
-  private _executeCloseLastSubstream: (
-    effect: Effect.Effect<unknown, never, Env>
-  ) => Effect.Effect<unknown, never, Env>
-
-  private _input: ErasedExecutor<Env> | undefined = undefined
-
-  private _inProgressFinalizer: Effect.Effect<unknown, never, Env> | undefined = undefined
-
-  private _providedEnv: Context.Context<unknown> | undefined
-
-  constructor(
-    initialChannel: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    providedEnv: Context.Context<unknown> | undefined,
-    executeCloseLastSubstream: (effect: Effect.Effect<unknown, never, Env>) => Effect.Effect<unknown, never, Env>
-  ) {
-    this._currentChannel = initialChannel as core.Primitive
-    this._executeCloseLastSubstream = executeCloseLastSubstream
-    this._providedEnv = providedEnv
-  }
-
-  run(): ChannelState.ChannelState<unknown, Env> {
-    let result: ChannelState.ChannelState<unknown, Env> | undefined = 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 = ChannelState.Done()
-          } else {
-            if (Effect.isEffect(this._currentChannel)) {
-              this._currentChannel = core.fromEffect(this._currentChannel) as core.Primitive
-            }
-            switch (this._currentChannel._tag) {
-              case ChannelOpCodes.OP_BRACKET_OUT: {
-                result = this.runBracketOut(this._currentChannel)
-                break
-              }
-
-              case ChannelOpCodes.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 as core.Primitive
-
-                if (this._input !== undefined) {
-                  const inputExecutor = this._input
-                  this._input = undefined
-
-                  const drainer = (): Effect.Effect<unknown, never, Env> =>
-                    Effect.flatMap(bridgeInput.awaitRead(), () =>
-                      Effect.suspend(() => {
-                        const state = inputExecutor.run() as ChannelState.Primitive
-                        switch (state._tag) {
-                          case ChannelStateOpCodes.OP_DONE: {
-                            return Exit.match(inputExecutor.getDone(), {
-                              onFailure: (cause) => bridgeInput.error(cause),
-                              onSuccess: (value) => bridgeInput.done(value)
-                            })
-                          }
-                          case ChannelStateOpCodes.OP_EMIT: {
-                            return Effect.flatMap(
-                              bridgeInput.emit(inputExecutor.getEmit()),
-                              () => drainer()
-                            )
-                          }
-                          case ChannelStateOpCodes.OP_FROM_EFFECT: {
-                            return Effect.matchCauseEffect(state.effect, {
-                              onFailure: (cause) => bridgeInput.error(cause),
-                              onSuccess: () => drainer()
-                            })
-                          }
-                          case ChannelStateOpCodes.OP_READ: {
-                            return readUpstream(
-                              state,
-                              () => drainer(),
-                              (cause) => bridgeInput.error(cause)
-                            )
-                          }
-                        }
-                      })) as Effect.Effect<unknown, never, Env>
-
-                  result = ChannelState.fromEffect(
-                    Effect.flatMap(
-                      Effect.forkDaemon(Effect.interruptible(drainer())),
-                      (fiber) =>
-                        Effect.sync(() =>
-                          this.addFinalizer((exit) =>
-                            Effect.flatMap(Fiber.interrupt(fiber), () =>
-                              Effect.suspend(() => {
-                                const effect = this.restorePipe(exit, inputExecutor)
-                                return effect !== undefined ? effect : Effect.void
-                              }))
-                          )
-                        )
-                    )
-                  )
-                }
-
-                break
-              }
-
-              case ChannelOpCodes.OP_CONCAT_ALL: {
-                const executor: ErasedExecutor<Env> = new ChannelExecutor(
-                  this._currentChannel.value() as Channel.Channel<
-                    never,
-                    unknown,
-                    never,
-                    unknown,
-                    never,
-                    unknown,
-                    Env
-                  >,
-                  this._providedEnv,
-                  (effect) =>
-                    Effect.sync(() => {
-                      const prevLastClose = this._closeLastSubstream === undefined
-                        ? Effect.void
-                        : this._closeLastSubstream
-                      this._closeLastSubstream = pipe(prevLastClose, Effect.zipRight(effect))
-                    })
-                )
-                executor._input = this._input
-
-                const channel = this._currentChannel
-                this._activeSubexecutor = new Subexecutor.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 ChannelOpCodes.OP_EMIT: {
-                this._emitted = this._currentChannel.out
-                this._currentChannel = (this._activeSubexecutor !== undefined ?
-                  undefined :
-                  core.void) as core.Primitive | undefined
-                result = ChannelState.Emit()
-                break
-              }
-
-              case ChannelOpCodes.OP_ENSURING: {
-                this.runEnsuring(this._currentChannel)
-                break
-              }
-
-              case ChannelOpCodes.OP_FAIL: {
-                result = this.doneHalt(this._currentChannel.error())
-                break
-              }
-
-              case ChannelOpCodes.OP_FOLD: {
-                this._doneStack.push(this._currentChannel.k as ErasedContinuation<Env>)
-                this._currentChannel = this._currentChannel.channel as core.Primitive
-                break
-              }
-
-              case ChannelOpCodes.OP_FROM_EFFECT: {
-                const effect = this._providedEnv === undefined ?
-                  this._currentChannel.effect() :
-                  pipe(
-                    this._currentChannel.effect(),
-                    Effect.provide(this._providedEnv)
-                  )
-
-                result = ChannelState.fromEffect(
-                  Effect.matchCauseEffect(effect, {
-                    onFailure: (cause) => {
-                      const state = this.doneHalt(cause)
-                      return state !== undefined && ChannelState.isFromEffect(state) ?
-                        state.effect :
-                        Effect.void
-                    },
-                    onSuccess: (value) => {
-                      const state = this.doneSucceed(value)
-                      return state !== undefined && ChannelState.isFromEffect(state) ?
-                        state.effect :
-                        Effect.void
-                    }
-                  })
-                ) as ChannelState.ChannelState<unknown, Env> | undefined
-
-                break
-              }
-
-              case ChannelOpCodes.OP_PIPE_TO: {
-                const previousInput = this._input
-
-                const leftExec: ErasedExecutor<Env> = new ChannelExecutor(
-                  this._currentChannel.left() as Channel.Channel<never, unknown, never, unknown, never, unknown, Env>,
-                  this._providedEnv,
-                  (effect) => this._executeCloseLastSubstream(effect)
-                )
-                leftExec._input = previousInput
-                this._input = leftExec
-
-                this.addFinalizer((exit) => {
-                  const effect = this.restorePipe(exit, previousInput)
-                  return effect !== undefined ? effect : Effect.void
-                })
-
-                this._currentChannel = this._currentChannel.right() as core.Primitive
-
-                break
-              }
-
-              case ChannelOpCodes.OP_PROVIDE: {
-                const previousEnv = this._providedEnv
-                this._providedEnv = this._currentChannel.context()
-                this._currentChannel = this._currentChannel.inner as core.Primitive
-                this.addFinalizer(() =>
-                  Effect.sync(() => {
-                    this._providedEnv = previousEnv
-                  })
-                )
-                break
-              }
-
-              case ChannelOpCodes.OP_READ: {
-                const read = this._currentChannel
-                result = ChannelState.Read(
-                  this._input!,
-                  identity,
-                  (emitted) => {
-                    try {
-                      this._currentChannel = read.more(emitted) as core.Primitive
-                    } catch (error) {
-                      this._currentChannel = read.done.onExit(Exit.die(error)) as core.Primitive
-                    }
-                    return undefined
-                  },
-                  (exit) => {
-                    const onExit = (exit: Exit.Exit<unknown, unknown>): core.Primitive => {
-                      return read.done.onExit(exit) as core.Primitive
-                    }
-                    this._currentChannel = onExit(exit)
-                    return undefined
-                  }
-                )
-                break
-              }
-
-              case ChannelOpCodes.OP_SUCCEED: {
-                result = this.doneSucceed(this._currentChannel.evaluate())
-                break
-              }
-
-              case ChannelOpCodes.OP_SUCCEED_NOW: {
-                result = this.doneSucceed(this._currentChannel.terminal)
-                break
-              }
-
-              case ChannelOpCodes.OP_SUSPEND: {
-                this._currentChannel = this._currentChannel.channel() as core.Primitive
-                break
-              }
-            }
-          }
-        } catch (error) {
-          this._currentChannel = core.failCause(Cause.die(error)) as core.Primitive
-        }
-      }
-    }
-    return result
-  }
-
-  getDone(): Exit.Exit<OutDone, OutErr> {
-    return this._done as Exit.Exit<OutDone, OutErr>
-  }
-
-  getEmit(): OutElem {
-    return this._emitted as OutElem
-  }
-
-  cancelWith(exit: Exit.Exit<OutErr, OutDone>): void {
-    this._cancelled = exit
-  }
-
-  clearInProgressFinalizer(): void {
-    this._inProgressFinalizer = undefined
-  }
-
-  storeInProgressFinalizer(finalizer: Effect.Effect<unknown, never, Env> | undefined): void {
-    this._inProgressFinalizer = finalizer
-  }
-
-  popAllFinalizers(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, Env> {
-    const finalizers: Array<ErasedFinalizer<Env>> = []
-    let next = this._doneStack.pop() as Continuation.Primitive | undefined
-    while (next) {
-      if (next._tag === "ContinuationFinalizer") {
-        finalizers.push(next.finalizer as ErasedFinalizer<Env>)
-      }
-      next = this._doneStack.pop() as Continuation.Primitive | undefined
-    }
-    const effect = (finalizers.length === 0 ? Effect.void : runFinalizers(finalizers, exit)) as Effect.Effect<
-      unknown,
-      never,
-      Env
-    >
-    this.storeInProgressFinalizer(effect)
-    return effect
-  }
-
-  popNextFinalizers(): Array<Continuation.ContinuationFinalizer<Env, unknown, unknown>> {
-    const builder: Array<Continuation.ContinuationFinalizer<Env, unknown, unknown>> = []
-    while (this._doneStack.length !== 0) {
-      const cont = this._doneStack[this._doneStack.length - 1] as Continuation.Primitive
-      if (cont._tag === ContinuationOpCodes.OP_CONTINUATION_K) {
-        return builder
-      }
-      builder.push(cont as Continuation.ContinuationFinalizer<Env, unknown, unknown>)
-      this._doneStack.pop()
-    }
-    return builder
-  }
-
-  restorePipe(
-    exit: Exit.Exit<unknown, unknown>,
-    prev: ErasedExecutor<Env> | undefined
-  ): Effect.Effect<unknown, never, Env> | undefined {
-    const currInput = this._input
-    this._input = prev
-    if (currInput !== undefined) {
-      const effect = currInput.close(exit)
-      return effect
-    }
-    return Effect.void
-  }
-
-  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, Env> | undefined {
-    let runInProgressFinalizers: Effect.Effect<unknown, never, Env> | undefined = undefined
-    const finalizer = this._inProgressFinalizer
-    if (finalizer !== undefined) {
-      runInProgressFinalizers = pipe(
-        finalizer,
-        Effect.ensuring(Effect.sync(() => this.clearInProgressFinalizer()))
-      )
-    }
-
-    let closeSelf: Effect.Effect<unknown, never, Env> | undefined = undefined
-    const selfFinalizers = this.popAllFinalizers(exit)
-    if (selfFinalizers !== undefined) {
-      closeSelf = pipe(
-        selfFinalizers,
-        Effect.ensuring(Effect.sync(() => this.clearInProgressFinalizer()))
-      )
-    }
-
-    const closeSubexecutors = this._activeSubexecutor === undefined ?
-      undefined :
-      this._activeSubexecutor.close(exit)
-
-    if (
-      closeSubexecutors === undefined &&
-      runInProgressFinalizers === undefined &&
-      closeSelf === undefined
-    ) {
-      return undefined
-    }
-
-    return pipe(
-      Effect.exit(ifNotNull(closeSubexecutors)),
-      Effect.zip(Effect.exit(ifNotNull(runInProgressFinalizers))),
-      Effect.zip(Effect.exit(ifNotNull(closeSelf))),
-      Effect.map(([[exit1, exit2], exit3]) => pipe(exit1, Exit.zipRight(exit2), Exit.zipRight(exit3))),
-      Effect.uninterruptible,
-      // TODO: remove
-      Effect.flatMap((exit) => Effect.suspend(() => exit))
-    )
-  }
-
-  doneSucceed(value: unknown): ChannelState.ChannelState<unknown, Env> | undefined {
-    if (this._doneStack.length === 0) {
-      this._done = Exit.succeed(value)
-      this._currentChannel = undefined
-      return ChannelState.Done()
-    }
-
-    const head = this._doneStack[this._doneStack.length - 1] as Continuation.Primitive
-    if (head._tag === ContinuationOpCodes.OP_CONTINUATION_K) {
-      this._doneStack.pop()
-      this._currentChannel = head.onSuccess(value) as core.Primitive
-      return undefined
-    }
-
-    const finalizers = this.popNextFinalizers()
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse()
-      this._done = Exit.succeed(value)
-      this._currentChannel = undefined
-      return ChannelState.Done()
-    }
-
-    const finalizerEffect = runFinalizers(finalizers.map((f) => f.finalizer), Exit.succeed(value))!
-    this.storeInProgressFinalizer(finalizerEffect)
-
-    const effect = pipe(
-      finalizerEffect,
-      Effect.ensuring(Effect.sync(() => this.clearInProgressFinalizer())),
-      Effect.uninterruptible,
-      Effect.flatMap(() => Effect.sync(() => this.doneSucceed(value)))
-    )
-
-    return ChannelState.fromEffect(effect)
-  }
-
-  doneHalt(cause: Cause.Cause<unknown>): ChannelState.ChannelState<unknown, Env> | undefined {
-    if (this._doneStack.length === 0) {
-      this._done = Exit.failCause(cause)
-      this._currentChannel = undefined
-      return ChannelState.Done()
-    }
-
-    const head = this._doneStack[this._doneStack.length - 1] as Continuation.Primitive
-    if (head._tag === ContinuationOpCodes.OP_CONTINUATION_K) {
-      this._doneStack.pop()
-      try {
-        this._currentChannel = head.onHalt(cause) as core.Primitive
-      } catch (error) {
-        this._currentChannel = core.failCause(Cause.die(error)) as core.Primitive
-      }
-      return undefined
-    }
-
-    const finalizers = this.popNextFinalizers()
-    if (this._doneStack.length === 0) {
-      this._doneStack = finalizers.reverse()
-      this._done = Exit.failCause(cause)
-      this._currentChannel = undefined
-      return ChannelState.Done()
-    }
-
-    const finalizerEffect = runFinalizers(finalizers.map((f) => f.finalizer), Exit.failCause(cause))!
-    this.storeInProgressFinalizer(finalizerEffect)
-
-    const effect = pipe(
-      finalizerEffect,
-      Effect.ensuring(Effect.sync(() => this.clearInProgressFinalizer())),
-      Effect.uninterruptible,
-      Effect.flatMap(() => Effect.sync(() => this.doneHalt(cause)))
-    )
-
-    return ChannelState.fromEffect(effect)
-  }
-
-  processCancellation(): ChannelState.ChannelState<unknown, Env> {
-    this._currentChannel = undefined
-    this._done = this._cancelled
-    this._cancelled = undefined
-    return ChannelState.Done()
-  }
-
-  runBracketOut(bracketOut: core.BracketOut): ChannelState.ChannelState<unknown, Env> {
-    const effect = Effect.uninterruptible(
-      Effect.matchCauseEffect(this.provide(bracketOut.acquire() as Effect.Effect<OutDone, OutErr, Env>), {
-        onFailure: (cause) =>
-          Effect.sync(() => {
-            this._currentChannel = core.failCause(cause) as core.Primitive
-          }),
-        onSuccess: (out) =>
-          Effect.sync(() => {
-            this.addFinalizer((exit) =>
-              this.provide(bracketOut.finalizer(out, exit)) as Effect.Effect<unknown, never, Env>
-            )
-            this._currentChannel = core.write(out) as core.Primitive
-          })
-      })
-    )
-    return ChannelState.fromEffect(effect) as ChannelState.ChannelState<unknown, Env>
-  }
-
-  provide(effect: Effect.Effect<unknown, unknown, unknown>): Effect.Effect<unknown, unknown, unknown> {
-    if (this._providedEnv === undefined) {
-      return effect
-    }
-    return pipe(effect, Effect.provide(this._providedEnv))
-  }
-
-  runEnsuring(ensuring: core.Ensuring): void {
-    this.addFinalizer(ensuring.finalizer as ErasedFinalizer<Env>)
-    this._currentChannel = ensuring.channel as core.Primitive
-  }
-
-  addFinalizer(f: ErasedFinalizer<Env>): void {
-    this._doneStack.push(new Continuation.ContinuationFinalizerImpl(f))
-  }
-
-  runSubexecutor(): ChannelState.ChannelState<unknown, Env> | undefined {
-    const subexecutor = this._activeSubexecutor as Subexecutor.Primitive<Env>
-    switch (subexecutor._tag) {
-      case Subexecutor.OP_PULL_FROM_CHILD: {
-        return this.pullFromChild(
-          subexecutor.childExecutor,
-          subexecutor.parentSubexecutor,
-          subexecutor.onEmit,
-          subexecutor
-        )
-      }
-      case Subexecutor.OP_PULL_FROM_UPSTREAM: {
-        return this.pullFromUpstream(subexecutor)
-      }
-      case Subexecutor.OP_DRAIN_CHILD_EXECUTORS: {
-        return this.drainChildExecutors(subexecutor)
-      }
-      case Subexecutor.OP_EMIT: {
-        this._emitted = subexecutor.value
-        this._activeSubexecutor = subexecutor.next
-        return ChannelState.Emit()
-      }
-    }
-  }
-
-  replaceSubexecutor(nextSubExec: Subexecutor.Subexecutor<Env>): void {
-    this._currentChannel = undefined
-    this._activeSubexecutor = nextSubExec
-  }
-
-  finishWithExit(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, unknown, Env> {
-    const state = Exit.match(exit, {
-      onFailure: (cause) => this.doneHalt(cause),
-      onSuccess: (value) => this.doneSucceed(value)
-    })
-    this._activeSubexecutor = undefined
-    return state === undefined ?
-      Effect.void :
-      ChannelState.effect(state)
-  }
-
-  finishSubexecutorWithCloseEffect(
-    subexecutorDone: Exit.Exit<unknown, unknown>,
-    ...closeFuncs: Array<(exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, Env> | undefined>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    this.addFinalizer(() =>
-      pipe(
-        closeFuncs,
-        Effect.forEach((closeFunc) =>
-          pipe(
-            Effect.sync(() => closeFunc(subexecutorDone)),
-            Effect.flatMap((closeEffect) => closeEffect !== undefined ? closeEffect : Effect.void)
-          ), { discard: true })
-      )
-    )
-    const state = pipe(
-      subexecutorDone,
-      Exit.match({
-        onFailure: (cause) => this.doneHalt(cause),
-        onSuccess: (value) => this.doneSucceed(value)
-      })
-    )
-    this._activeSubexecutor = undefined
-    return state
-  }
-
-  applyUpstreamPullStrategy(
-    upstreamFinished: boolean,
-    queue: ReadonlyArray<Subexecutor.PullFromChild<Env> | undefined>,
-    strategy: UpstreamPullStrategy.UpstreamPullStrategy<unknown>
-  ): [Option.Option<unknown>, ReadonlyArray<Subexecutor.PullFromChild<Env> | undefined>] {
-    switch (strategy._tag) {
-      case UpstreamPullStrategyOpCodes.OP_PULL_AFTER_NEXT: {
-        const shouldPrepend = !upstreamFinished || queue.some((subexecutor) => subexecutor !== undefined)
-        return [strategy.emitSeparator, shouldPrepend ? [undefined, ...queue] : queue]
-      }
-      case UpstreamPullStrategyOpCodes.OP_PULL_AFTER_ALL_ENQUEUED: {
-        const shouldEnqueue = !upstreamFinished || queue.some((subexecutor) => subexecutor !== undefined)
-        return [strategy.emitSeparator, shouldEnqueue ? [...queue, undefined] : queue]
-      }
-    }
-  }
-
-  pullFromChild(
-    childExecutor: ErasedExecutor<Env>,
-    parentSubexecutor: Subexecutor.Subexecutor<Env>,
-    onEmitted: (emitted: unknown) => ChildExecutorDecision.ChildExecutorDecision,
-    subexecutor: Subexecutor.PullFromChild<Env>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    return ChannelState.Read(
-      childExecutor,
-      identity,
-      (emitted) => {
-        const childExecutorDecision = onEmitted(emitted)
-        switch (childExecutorDecision._tag) {
-          case ChildExecutorDecisionOpCodes.OP_CONTINUE: {
-            break
-          }
-          case ChildExecutorDecisionOpCodes.OP_CLOSE: {
-            this.finishWithDoneValue(childExecutor, parentSubexecutor, childExecutorDecision.value)
-            break
-          }
-          case ChildExecutorDecisionOpCodes.OP_YIELD: {
-            const modifiedParent = parentSubexecutor.enqueuePullFromChild(subexecutor)
-            this.replaceSubexecutor(modifiedParent)
-            break
-          }
-        }
-        this._activeSubexecutor = new Subexecutor.Emit(emitted, this._activeSubexecutor!)
-        return undefined
-      },
-      Exit.match({
-        onFailure: (cause) => {
-          const state = this.handleSubexecutorFailure(childExecutor, parentSubexecutor, cause)
-          return state === undefined ?
-            undefined :
-            ChannelState.effectOrUndefinedIgnored(state) as Effect.Effect<void, never, Env>
-        },
-        onSuccess: (doneValue) => {
-          this.finishWithDoneValue(childExecutor, parentSubexecutor, doneValue)
-          return undefined
-        }
-      })
-    )
-  }
-
-  finishWithDoneValue(
-    childExecutor: ErasedExecutor<Env>,
-    parentSubexecutor: Subexecutor.Subexecutor<Env>,
-    doneValue: unknown
-  ): void {
-    const subexecutor = parentSubexecutor as Subexecutor.Primitive<Env>
-    switch (subexecutor._tag) {
-      case Subexecutor.OP_PULL_FROM_UPSTREAM: {
-        const modifiedParent = new Subexecutor.PullFromUpstream(
-          subexecutor.upstreamExecutor,
-          subexecutor.createChild,
-          subexecutor.lastDone !== undefined
-            ? subexecutor.combineChildResults(
-              subexecutor.lastDone,
-              doneValue
-            )
-            : doneValue,
-          subexecutor.activeChildExecutors,
-          subexecutor.combineChildResults,
-          subexecutor.combineWithChildResult,
-          subexecutor.onPull,
-          subexecutor.onEmit
-        )
-        this._closeLastSubstream = childExecutor.close(Exit.succeed(doneValue))
-        this.replaceSubexecutor(modifiedParent)
-        break
-      }
-      case Subexecutor.OP_DRAIN_CHILD_EXECUTORS: {
-        const modifiedParent = new Subexecutor.DrainChildExecutors(
-          subexecutor.upstreamExecutor,
-          subexecutor.lastDone !== undefined
-            ? subexecutor.combineChildResults(
-              subexecutor.lastDone,
-              doneValue
-            )
-            : doneValue,
-          subexecutor.activeChildExecutors,
-          subexecutor.upstreamDone,
-          subexecutor.combineChildResults,
-          subexecutor.combineWithChildResult,
-          subexecutor.onPull
-        )
-        this._closeLastSubstream = childExecutor.close(Exit.succeed(doneValue))
-        this.replaceSubexecutor(modifiedParent)
-        break
-      }
-      default: {
-        break
-      }
-    }
-  }
-
-  handleSubexecutorFailure(
-    childExecutor: ErasedExecutor<Env>,
-    parentSubexecutor: Subexecutor.Subexecutor<Env>,
-    cause: Cause.Cause<unknown>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    return this.finishSubexecutorWithCloseEffect(
-      Exit.failCause(cause),
-      (exit) => parentSubexecutor.close(exit),
-      (exit) => childExecutor.close(exit)
-    )
-  }
-
-  pullFromUpstream(
-    subexecutor: Subexecutor.PullFromUpstream<Env>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      return this.performPullFromUpstream(subexecutor)
-    }
-
-    const activeChild = subexecutor.activeChildExecutors[0]
-
-    const parentSubexecutor = new Subexecutor.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 Subexecutor.PullFromChild(
-        activeChild.childExecutor,
-        parentSubexecutor,
-        activeChild.onEmit
-      )
-    )
-
-    return undefined
-  }
-
-  performPullFromUpstream(
-    subexecutor: Subexecutor.PullFromUpstream<Env>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    return ChannelState.Read(
-      subexecutor.upstreamExecutor,
-      (effect) => {
-        const closeLastSubstream = this._closeLastSubstream === undefined ? Effect.void : this._closeLastSubstream
-        this._closeLastSubstream = undefined
-        return pipe(
-          this._executeCloseLastSubstream(closeLastSubstream),
-          Effect.zipRight(effect)
-        )
-      },
-      (emitted) => {
-        if (this._closeLastSubstream !== undefined) {
-          const closeLastSubstream = this._closeLastSubstream
-          this._closeLastSubstream = undefined
-          return pipe(
-            this._executeCloseLastSubstream(closeLastSubstream),
-            Effect.map(() => {
-              const childExecutor: ErasedExecutor<Env> = new ChannelExecutor(
-                subexecutor.createChild(emitted),
-                this._providedEnv,
-                this._executeCloseLastSubstream
-              )
-
-              childExecutor._input = this._input
-
-              const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(
-                false,
-                subexecutor.activeChildExecutors,
-                subexecutor.onPull(upstreamPullRequest.Pulled(emitted))
-              )
-
-              this._activeSubexecutor = new Subexecutor.PullFromChild(
-                childExecutor,
-                new Subexecutor.PullFromUpstream(
-                  subexecutor.upstreamExecutor,
-                  subexecutor.createChild,
-                  subexecutor.lastDone,
-                  updatedChildExecutors,
-                  subexecutor.combineChildResults,
-                  subexecutor.combineWithChildResult,
-                  subexecutor.onPull,
-                  subexecutor.onEmit
-                ),
-                subexecutor.onEmit
-              )
-
-              if (Option.isSome(emitSeparator)) {
-                this._activeSubexecutor = new Subexecutor.Emit(emitSeparator.value, this._activeSubexecutor)
-              }
-
-              return undefined
-            })
-          )
-        }
-
-        const childExecutor: ErasedExecutor<Env> = new ChannelExecutor(
-          subexecutor.createChild(emitted),
-          this._providedEnv,
-          this._executeCloseLastSubstream
-        )
-
-        childExecutor._input = this._input
-
-        const [emitSeparator, updatedChildExecutors] = this.applyUpstreamPullStrategy(
-          false,
-          subexecutor.activeChildExecutors,
-          subexecutor.onPull(upstreamPullRequest.Pulled(emitted))
-        )
-
-        this._activeSubexecutor = new Subexecutor.PullFromChild(
-          childExecutor,
-          new Subexecutor.PullFromUpstream(
-            subexecutor.upstreamExecutor,
-            subexecutor.createChild,
-            subexecutor.lastDone,
-            updatedChildExecutors,
-            subexecutor.combineChildResults,
-            subexecutor.combineWithChildResult,
-            subexecutor.onPull,
-            subexecutor.onEmit
-          ),
-          subexecutor.onEmit
-        )
-
-        if (Option.isSome(emitSeparator)) {
-          this._activeSubexecutor = new Subexecutor.Emit(emitSeparator.value, this._activeSubexecutor)
-        }
-
-        return undefined
-      },
-      (exit) => {
-        if (subexecutor.activeChildExecutors.some((subexecutor) => subexecutor !== undefined)) {
-          const drain = new Subexecutor.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),
-              Effect.map(() => this.replaceSubexecutor(drain))
-            )
-          }
-
-          this.replaceSubexecutor(drain)
-
-          return undefined
-        }
-
-        const closeLastSubstream = this._closeLastSubstream
-        const state = this.finishSubexecutorWithCloseEffect(
-          pipe(exit, Exit.map((a) => subexecutor.combineWithChildResult(subexecutor.lastDone, a))),
-          () => closeLastSubstream,
-          (exit) => subexecutor.upstreamExecutor.close(exit)
-        )
-        return state === undefined ?
-          undefined :
-          // NOTE: assuming finalizers cannot fail
-          ChannelState.effectOrUndefinedIgnored(state as ChannelState.ChannelState<never, Env>)
-      }
-    )
-  }
-
-  drainChildExecutors(
-    subexecutor: Subexecutor.DrainChildExecutors<Env>
-  ): ChannelState.ChannelState<unknown, Env> | undefined {
-    if (subexecutor.activeChildExecutors.length === 0) {
-      const lastClose = this._closeLastSubstream
-      if (lastClose !== undefined) {
-        this.addFinalizer(() => Effect.succeed(lastClose))
-      }
-      return this.finishSubexecutorWithCloseEffect(
-        subexecutor.upstreamDone,
-        () => lastClose,
-        (exit) => subexecutor.upstreamExecutor.close(exit)
-      )
-    }
-
-    const activeChild = subexecutor.activeChildExecutors[0]
-    const rest = subexecutor.activeChildExecutors.slice(1)
-
-    if (activeChild === undefined) {
-      const [emitSeparator, remainingExecutors] = this.applyUpstreamPullStrategy(
-        true,
-        rest,
-        subexecutor.onPull(
-          upstreamPullRequest.NoUpstream(rest.reduce((n, curr) => curr !== undefined ? n + 1 : n, 0))
-        )
-      )
-
-      this.replaceSubexecutor(
-        new Subexecutor.DrainChildExecutors(
-          subexecutor.upstreamExecutor,
-          subexecutor.lastDone,
-          remainingExecutors,
-          subexecutor.upstreamDone,
-          subexecutor.combineChildResults,
-          subexecutor.combineWithChildResult,
-          subexecutor.onPull
-        )
-      )
-
-      if (Option.isSome(emitSeparator)) {
-        this._emitted = emitSeparator.value
-        return ChannelState.Emit()
-      }
-
-      return undefined
-    }
-
-    const parentSubexecutor = new Subexecutor.DrainChildExecutors(
-      subexecutor.upstreamExecutor,
-      subexecutor.lastDone,
-      rest,
-      subexecutor.upstreamDone,
-      subexecutor.combineChildResults,
-      subexecutor.combineWithChildResult,
-      subexecutor.onPull
-    )
-
-    this.replaceSubexecutor(
-      new Subexecutor.PullFromChild(
-        activeChild.childExecutor,
-        parentSubexecutor,
-        activeChild.onEmit
-      )
-    )
-
-    return undefined
-  }
-}
-
-const ifNotNull = <Env>(effect: Effect.Effect<unknown, never, Env> | undefined): Effect.Effect<unknown, never, Env> =>
-  effect !== undefined ? effect : Effect.void
-
-const runFinalizers = <Env>(
-  finalizers: Array<ErasedFinalizer<Env>>,
-  exit: Exit.Exit<unknown, unknown>
-): Effect.Effect<unknown, never, Env> => {
-  return pipe(
-    Effect.forEach(finalizers, (fin) => Effect.exit(fin(exit))),
-    Effect.map((exits) => pipe(Exit.all(exits), Option.getOrElse(() => Exit.void))),
-    Effect.flatMap((exit) => Effect.suspend(() => exit as Exit.Exit<unknown>))
-  )
-}
-
-/**
- * @internal
- */
-export const readUpstream = <A, E2, R, E>(
-  r: ChannelState.Read,
-  onSuccess: () => Effect.Effect<A, E2, R>,
-  onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A, E2, R>
-): Effect.Effect<A, E2, R> => {
-  const readStack = [r as ChannelState.Read]
-  const read = (): Effect.Effect<A, E2, R> => {
-    const current = readStack.pop()
-    if (current === undefined || current.upstream === undefined) {
-      return Effect.dieMessage("Unexpected end of input for channel execution")
-    }
-    const state = current.upstream.run() as ChannelState.Primitive
-    switch (state._tag) {
-      case ChannelStateOpCodes.OP_EMIT: {
-        const emitEffect = current.onEmit(current.upstream.getEmit())
-        if (readStack.length === 0) {
-          if (emitEffect === undefined) {
-            return Effect.suspend(onSuccess)
-          }
-          return pipe(
-            emitEffect as Effect.Effect<void>,
-            Effect.matchCauseEffect({ onFailure, onSuccess })
-          )
-        }
-        if (emitEffect === undefined) {
-          return Effect.suspend(() => read())
-        }
-        return pipe(
-          emitEffect as Effect.Effect<void>,
-          Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
-        )
-      }
-
-      case ChannelStateOpCodes.OP_DONE: {
-        const doneEffect = current.onDone(current.upstream.getDone())
-        if (readStack.length === 0) {
-          if (doneEffect === undefined) {
-            return Effect.suspend(onSuccess)
-          }
-          return pipe(
-            doneEffect as Effect.Effect<void>,
-            Effect.matchCauseEffect({ onFailure, onSuccess })
-          )
-        }
-        if (doneEffect === undefined) {
-          return Effect.suspend(() => read())
-        }
-        return pipe(
-          doneEffect as Effect.Effect<void>,
-          Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
-        )
-      }
-
-      case ChannelStateOpCodes.OP_FROM_EFFECT: {
-        readStack.push(current)
-        return pipe(
-          current.onEffect(state.effect as Effect.Effect<void>) as Effect.Effect<void>,
-          Effect.catchAllCause((cause) =>
-            Effect.suspend(() => {
-              const doneEffect = current.onDone(Exit.failCause(cause)) as Effect.Effect<void>
-              return doneEffect === undefined ? Effect.void : doneEffect
-            })
-          ),
-          Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
-        )
-      }
-
-      case ChannelStateOpCodes.OP_READ: {
-        readStack.push(current)
-        readStack.push(state)
-        return Effect.suspend(() => read())
-      }
-    }
-  }
-  return read()
-}
-
-/** @internal */
-export const runIn = dual<
-  (scope: Scope.Scope) => <Env, InErr, InDone, OutErr, OutDone>(
-    self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-  ) => Effect.Effect<OutDone, OutErr, Env>,
-  <Env, InErr, InDone, OutErr, OutDone>(
-    self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>,
-    scope: Scope.Scope
-  ) => Effect.Effect<OutDone, OutErr, Env>
->(2, <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>,
-  scope: Scope.Scope
-) => {
-  const run = (
-    channelDeferred: Deferred.Deferred<OutDone, OutErr>,
-    scopeDeferred: Deferred.Deferred<void>,
-    scope: Scope.Scope
-  ) =>
-    Effect.acquireUseRelease(
-      Effect.sync(() => new ChannelExecutor(self, void 0, identity)),
-      (exec) =>
-        Effect.suspend(() =>
-          runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec).pipe(
-            Effect.intoDeferred(channelDeferred),
-            Effect.zipRight(Deferred.await(channelDeferred)),
-            Effect.zipLeft(Deferred.await(scopeDeferred))
-          )
-        ),
-      (exec, exit) => {
-        const finalize = exec.close(exit)
-        if (finalize === undefined) {
-          return Effect.void
-        }
-        return Effect.tapErrorCause(
-          finalize,
-          (cause) => Scope.addFinalizer(scope, Effect.failCause(cause))
-        )
-      }
-    )
-  return Effect.uninterruptibleMask((restore) =>
-    Effect.all([
-      Scope.fork(scope, ExecutionStrategy.sequential),
-      Deferred.make<OutDone, OutErr>(),
-      Deferred.make<void>()
-    ]).pipe(Effect.flatMap(([child, channelDeferred, scopeDeferred]) =>
-      restore(run(channelDeferred, scopeDeferred, child)).pipe(
-        Effect.forkIn(scope),
-        Effect.flatMap((fiber) =>
-          scope.addFinalizer((exit) => {
-            const interruptors = Exit.isFailure(exit) ? Cause.interruptors(exit.cause) : undefined
-            return Deferred.isDone(channelDeferred).pipe(
-              Effect.flatMap((isDone) =>
-                isDone
-                  ? Deferred.succeed(scopeDeferred, void 0).pipe(
-                    Effect.zipRight(Fiber.await(fiber)),
-                    Effect.zipRight(Fiber.inheritAll(fiber))
-                  )
-                  : Deferred.succeed(scopeDeferred, void 0).pipe(
-                    Effect.zipRight(
-                      interruptors && HashSet.size(interruptors) > 0
-                        ? Fiber.interruptAs(fiber, FiberId.combineAll(interruptors))
-                        : Fiber.interrupt(fiber)
-                    ),
-                    Effect.zipRight(Fiber.inheritAll(fiber))
-                  )
-              )
-            )
-          }).pipe(Effect.zipRight(restore(Deferred.await(channelDeferred))))
-        )
-      )
-    ))
-  )
-})
-
-/** @internal */
-const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
-  channelState: ChannelState.ChannelState<OutErr, Env>,
-  exec: ChannelExecutor<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => {
-  const op = channelState as ChannelState.Primitive
-  switch (op._tag) {
-    case ChannelStateOpCodes.OP_FROM_EFFECT: {
-      return pipe(
-        op.effect as Effect.Effect<OutDone, OutErr, Env>,
-        Effect.flatMap(() => runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
-      )
-    }
-    case ChannelStateOpCodes.OP_EMIT: {
-      // Can't really happen because Out <:< Nothing. So just skip ahead.
-      return runScopedInterpret<Env, InErr, InDone, OutErr, OutDone>(
-        exec.run() as ChannelState.ChannelState<OutErr, Env>,
-        exec
-      )
-    }
-    case ChannelStateOpCodes.OP_DONE: {
-      return Effect.suspend(() => exec.getDone())
-    }
-    case ChannelStateOpCodes.OP_READ: {
-      return readUpstream(
-        op,
-        () => runScopedInterpret(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
-        Effect.failCause
-      ) as Effect.Effect<OutDone, OutErr, Env>
-    }
-  }
-}