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

package/src/internal/channel.ts

@@ -1,2603 +0,0 @@
-import * as Cause from "../Cause.js"
-import type * as Channel from "../Channel.js"
-import * as Chunk from "../Chunk.js"
-import * as Context from "../Context.js"
-import * as Deferred from "../Deferred.js"
-import * as Effect from "../Effect.js"
-import * as Either from "../Either.js"
-import * as Equal from "../Equal.js"
-import * as Exit from "../Exit.js"
-import * as Fiber from "../Fiber.js"
-import * as FiberRef from "../FiberRef.js"
-import { constVoid, dual, identity, pipe } from "../Function.js"
-import type { LazyArg } from "../Function.js"
-import * as Layer from "../Layer.js"
-import type * as MergeDecision from "../MergeDecision.js"
-import type * as MergeState from "../MergeState.js"
-import type * as MergeStrategy from "../MergeStrategy.js"
-import * as Option from "../Option.js"
-import { hasProperty, type Predicate } from "../Predicate.js"
-import * as PubSub from "../PubSub.js"
-import * as Queue from "../Queue.js"
-import * as Ref from "../Ref.js"
-import * as Scope from "../Scope.js"
-import type * as SingleProducerAsyncInput from "../SingleProducerAsyncInput.js"
-import type * as Tracer from "../Tracer.js"
-import type * as Types from "../Types.js"
-import * as executor from "./channel/channelExecutor.js"
-import type * as ChannelState from "./channel/channelState.js"
-import * as mergeDecision from "./channel/mergeDecision.js"
-import * as mergeState from "./channel/mergeState.js"
-import * as mergeStrategy_ from "./channel/mergeStrategy.js"
-import * as singleProducerAsyncInput from "./channel/singleProducerAsyncInput.js"
-import * as coreEffect from "./core-effect.js"
-import * as core from "./core-stream.js"
-import * as MergeDecisionOpCodes from "./opCodes/channelMergeDecision.js"
-import * as MergeStateOpCodes from "./opCodes/channelMergeState.js"
-import * as ChannelStateOpCodes from "./opCodes/channelState.js"
-import * as tracer from "./tracer.js"
-
-/** @internal */
-export const acquireUseRelease = <Acquired, OutErr, Env, OutElem1, InElem, InErr, OutDone, InDone>(
-  acquire: Effect.Effect<Acquired, OutErr, Env>,
-  use: (a: Acquired) => Channel.Channel<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  release: (a: Acquired, exit: Exit.Exit<OutDone, OutErr>) => Effect.Effect<any, never, Env>
-): Channel.Channel<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env> =>
-  core.flatMap(
-    core.fromEffect(
-      Ref.make<
-        (exit: Exit.Exit<OutDone, OutErr>) => Effect.Effect<any, never, Env>
-      >(() => Effect.void)
-    ),
-    (ref) =>
-      pipe(
-        core.fromEffect(
-          Effect.uninterruptible(
-            Effect.tap(
-              acquire,
-              (a) => Ref.set(ref, (exit) => release(a, exit))
-            )
-          )
-        ),
-        core.flatMap(use),
-        core.ensuringWith((exit) => Effect.flatMap(Ref.get(ref), (f) => f(exit)))
-      )
-  )
-
-/** @internal */
-export const as = dual<
-  <OutDone2>(
-    value: OutDone2
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    value: OutDone2
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  value: OutDone2
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env> => map(self, () => value))
-
-/** @internal */
-export const asVoid = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> => map(self, constVoid)
-
-/** @internal */
-export const buffer = <InElem, InErr, InDone>(
-  options: {
-    readonly empty: InElem
-    readonly isEmpty: Predicate<InElem>
-    readonly ref: Ref.Ref<InElem>
-  }
-): Channel.Channel<InElem, InElem, InErr, InErr, InDone, InDone> =>
-  core.suspend(() => {
-    const doBuffer = <InErr, InElem, InDone>(
-      empty: InElem,
-      isEmpty: Predicate<InElem>,
-      ref: Ref.Ref<InElem>
-    ): Channel.Channel<InElem, InElem, InErr, InErr, InDone, InDone> =>
-      unwrap(
-        Ref.modify(ref, (inElem) =>
-          isEmpty(inElem) ?
-            [
-              core.readWith({
-                onInput: (input: InElem) =>
-                  core.flatMap(
-                    core.write(input),
-                    () => doBuffer<InErr, InElem, InDone>(empty, isEmpty, ref)
-                  ),
-                onFailure: (error: InErr) => core.fail(error),
-                onDone: (done: InDone) => core.succeedNow(done)
-              }),
-              inElem
-            ] as const :
-            [
-              core.flatMap(
-                core.write(inElem),
-                () => doBuffer<InErr, InElem, InDone>(empty, isEmpty, ref)
-              ),
-              empty
-            ] as const)
-      )
-    return doBuffer(options.empty, options.isEmpty, options.ref)
-  })
-
-/** @internal */
-export const bufferChunk = <InElem, InErr, InDone>(
-  ref: Ref.Ref<Chunk.Chunk<InElem>>
-): Channel.Channel<Chunk.Chunk<InElem>, Chunk.Chunk<InElem>, InErr, InErr, InDone, InDone> =>
-  buffer({
-    empty: Chunk.empty(),
-    isEmpty: Chunk.isEmpty,
-    ref
-  })
-
-/** @internal */
-export const catchAll = dual<
-  <OutErr, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    f: (error: OutErr) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-  ) => <OutElem, InElem, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone1 | OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (error: OutErr) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone1 | OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(
-  2,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (error: OutErr) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-  ): Channel.Channel<
-    OutElem | OutElem1,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone | OutDone1,
-    InDone & InDone1,
-    Env | Env1
-  > =>
-    core.catchAllCause(self, (cause) =>
-      Either.match(Cause.failureOrCause(cause), {
-        onLeft: f,
-        onRight: core.failCause
-      }))
-)
-
-/** @internal */
-export const concatMap = dual<
-  <OutElem, OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>(
-    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem2,
-    InElem & InElem2,
-    OutErr2 | OutErr,
-    InErr & InErr2,
-    unknown,
-    InDone & InDone2,
-    Env2 | Env
-  >,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, X>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
-  ) => Channel.Channel<
-    OutElem2,
-    InElem & InElem2,
-    OutErr2 | OutErr,
-    InErr & InErr2,
-    unknown,
-    InDone & InDone2,
-    Env2 | Env
-  >
->(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, X>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
-): Channel.Channel<
-  OutElem2,
-  InElem & InElem2,
-  OutErr | OutErr2,
-  InErr & InErr2,
-  unknown,
-  InDone & InDone2,
-  Env | Env2
-> => core.concatMapWith(self, f, () => void 0, () => void 0))
-
-/** @internal */
-export const collect = dual<
-  <OutElem, OutElem2>(
-    pf: (o: OutElem) => Option.Option<OutElem2>
-  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem>
-  ) => Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    pf: (o: OutElem) => Option.Option<OutElem2>
-  ) => Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  pf: (o: OutElem) => Option.Option<OutElem2>
-): Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env> => {
-  const collector: Channel.Channel<OutElem2, OutElem, OutErr, OutErr, OutDone, OutDone, Env> = core
-    .readWith({
-      onInput: (out) =>
-        Option.match(pf(out), {
-          onNone: () => collector,
-          onSome: (out2) => core.flatMap(core.write(out2), () => collector)
-        }),
-      onFailure: core.fail,
-      onDone: core.succeedNow
-    })
-  return core.pipeTo(self, collector)
-})
-
-/** @internal */
-export const concatOut = <OutElem, InElem, OutErr, InErr, InDone, Env, OutDone>(
-  self: Channel.Channel<
-    Channel.Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env>,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env
-  >
-): Channel.Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env> => core.concatAll(self)
-
-/** @internal */
-export const mapInput = dual<
-  <InDone0, InDone>(
-    f: (a: InDone0) => InDone
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (a: InDone0) => InDone
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (a: InDone0) => InDone
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env> => {
-  const reader: Channel.Channel<InElem, InElem, InErr, InErr, InDone, InDone0> = core.readWith({
-    onInput: (inElem: InElem) => core.flatMap(core.write(inElem), () => reader),
-    onFailure: core.fail,
-    onDone: (done: InDone0) => core.succeedNow(f(done))
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const mapInputEffect = dual<
-  <InDone0, InDone, InErr, Env1>(
-    f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-  ) => <OutElem, InElem, OutErr, OutDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env | Env1> => {
-  const reader: Channel.Channel<InElem, InElem, InErr, InErr, InDone, InDone0, Env1> = core.readWith({
-    onInput: (inElem) => core.flatMap(core.write(inElem), () => reader),
-    onFailure: core.fail,
-    onDone: (done) => core.fromEffect(f(done))
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const mapInputError = dual<
-  <InErr0, InErr>(
-    f: (a: InErr0) => InErr
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (a: InErr0) => InErr
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (a: InErr0) => InErr
-): Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env> => {
-  const reader: Channel.Channel<InElem, InElem, InErr, InErr0, InDone, InDone> = core.readWith({
-    onInput: (inElem: InElem) => core.flatMap(core.write(inElem), () => reader),
-    onFailure: (error) => core.fail(f(error)),
-    onDone: core.succeedNow
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const mapInputErrorEffect = dual<
-  <InErr0, InDone, InErr, Env1>(
-    f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-  ) => <OutElem, InElem, OutErr, OutDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-): Channel.Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env | Env1> => {
-  const reader: Channel.Channel<InElem, InElem, InErr, InErr0, InDone, InDone, Env1> = core.readWith({
-    onInput: (inElem) => core.flatMap(core.write(inElem), () => reader),
-    onFailure: (error) => core.fromEffect(f(error)),
-    onDone: core.succeedNow
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const mapInputIn = dual<
-  <InElem0, InElem>(
-    f: (a: InElem0) => InElem
-  ) => <OutElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (a: InElem0) => InElem
-  ) => Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (a: InElem0) => InElem
-): Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env> => {
-  const reader: Channel.Channel<InElem, InElem0, InErr, InErr, InDone, InDone> = core.readWith({
-    onInput: (inElem) => core.flatMap(core.write(f(inElem)), () => reader),
-    onFailure: core.fail,
-    onDone: core.succeedNow
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const mapInputInEffect = dual<
-  <InElem0, InElem, InErr, Env1>(
-    f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-  ) => <OutElem, OutErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-  ) => Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-): Channel.Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env | Env1> => {
-  const reader: Channel.Channel<InElem, InElem0, InErr, InErr, InDone, InDone, Env1> = core.readWith({
-    onInput: (inElem) => core.flatMap(core.flatMap(core.fromEffect(f(inElem)), core.write), () => reader),
-    onFailure: core.fail,
-    onDone: core.succeedNow
-  })
-  return core.pipeTo(reader, self)
-})
-
-/** @internal */
-export const doneCollect = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Channel.Channel<never, InElem, OutErr, InErr, [Chunk.Chunk<OutElem>, OutDone], InDone, Env> =>
-  core.suspend(() => {
-    const builder: Array<OutElem> = []
-    return pipe(
-      core.pipeTo(self, doneCollectReader<Env, OutErr, OutElem, OutDone>(builder)),
-      core.flatMap((outDone) => core.succeed([Chunk.unsafeFromArray(builder), outDone]))
-    )
-  })
-
-/** @internal */
-const doneCollectReader = <Env, OutErr, OutElem, OutDone>(
-  builder: Array<OutElem>
-): Channel.Channel<never, OutElem, OutErr, OutErr, OutDone, OutDone, Env> => {
-  return core.readWith({
-    onInput: (outElem) =>
-      core.flatMap(
-        core.sync(() => {
-          builder.push(outElem)
-        }),
-        () => doneCollectReader<Env, OutErr, OutElem, OutDone>(builder)
-      ),
-    onFailure: core.fail,
-    onDone: core.succeed
-  })
-}
-
-/** @internal */
-export const drain = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Channel.Channel<never, InElem, OutErr, InErr, OutDone, InDone, Env> => {
-  const drainer: Channel.Channel<never, OutElem, OutErr, OutErr, OutDone, OutDone, Env> = core
-    .readWithCause({
-      onInput: () => drainer,
-      onFailure: core.failCause,
-      onDone: core.succeed
-    })
-  return core.pipeTo(self, drainer)
-}
-
-/** @internal */
-export const emitCollect = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Channel.Channel<[Chunk.Chunk<OutElem>, OutDone], InElem, OutErr, InErr, void, InDone, Env> =>
-  core.flatMap(doneCollect(self), core.write)
-
-/** @internal */
-export const ensuring = dual<
-  <Z, Env1>(
-    finalizer: Effect.Effect<Z, never, Env1>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Z, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    finalizer: Effect.Effect<Z, never, Env1>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1 | Env>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, Z>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  finalizer: Effect.Effect<Z, never, Env1>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env1> =>
-  core.ensuringWith(self, () => finalizer))
-
-/** @internal */
-export const context = <Env>(): Channel.Channel<never, unknown, never, unknown, Context.Context<Env>, unknown, Env> =>
-  core.fromEffect(Effect.context<Env>())
-
-/** @internal */
-export const contextWith = <Env, OutDone>(
-  f: (env: Context.Context<Env>) => OutDone
-): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, Env> => map(context<Env>(), f)
-
-/** @internal */
-export const contextWithChannel = <
-  Env,
-  OutElem,
-  InElem,
-  OutErr,
-  InErr,
-  OutDone,
-  InDone,
-  Env1
->(
-  f: (env: Context.Context<Env>) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env1> => core.flatMap(context<Env>(), f)
-
-/** @internal */
-export const contextWithEffect = <Env, OutDone, OutErr, Env1>(
-  f: (env: Context.Context<Env>) => Effect.Effect<OutDone, OutErr, Env1>
-): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Env1> => mapEffect(context<Env>(), f)
-
-/** @internal */
-export const flatten = <
-  OutElem,
-  InElem,
-  OutErr,
-  InErr,
-  OutElem1,
-  InElem1,
-  OutErr1,
-  InErr1,
-  OutDone2,
-  InDone1,
-  Env1,
-  InDone,
-  Env
->(
-  self: Channel.Channel<
-    OutElem,
-    InElem,
-    OutErr,
-    InErr,
-    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>,
-    InDone,
-    Env
-  >
-): Channel.Channel<
-  OutElem | OutElem1,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  OutDone2,
-  InDone & InDone1,
-  Env | Env1
-> => core.flatMap(self, identity)
-
-/** @internal */
-export const foldChannel = dual<
-  <
-    OutErr,
-    OutElem1,
-    InElem1,
-    OutErr1,
-    InErr1,
-    OutDone1,
-    InDone1,
-    Env1,
-    OutDone,
-    OutElem2,
-    InElem2,
-    OutErr2,
-    InErr2,
-    OutDone2,
-    InDone2,
-    Env2
-  >(
-    options: {
-      readonly onFailure: (
-        error: OutErr
-      ) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-      readonly onSuccess: (
-        done: OutDone
-      ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
-    }
-  ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem2 | OutElem,
-    InElem & InElem1 & InElem2,
-    OutErr1 | OutErr2,
-    InErr & InErr1 & InErr2,
-    OutDone1 | OutDone2,
-    InDone & InDone1 & InDone2,
-    Env1 | Env2 | Env
-  >,
-  <
-    OutElem,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env,
-    OutElem1,
-    InElem1,
-    OutErr1,
-    InErr1,
-    OutDone1,
-    InDone1,
-    Env1,
-    OutElem2,
-    InElem2,
-    OutErr2,
-    InErr2,
-    OutDone2,
-    InDone2,
-    Env2
-  >(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    options: {
-      readonly onFailure: (
-        error: OutErr
-      ) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-      readonly onSuccess: (
-        done: OutDone
-      ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
-    }
-  ) => Channel.Channel<
-    OutElem1 | OutElem2 | OutElem,
-    InElem & InElem1 & InElem2,
-    OutErr1 | OutErr2,
-    InErr & InErr1 & InErr2,
-    OutDone1 | OutDone2,
-    InDone & InDone1 & InDone2,
-    Env1 | Env2 | Env
-  >
->(2, <
-  OutElem,
-  InElem,
-  OutErr,
-  InErr,
-  OutDone,
-  InDone,
-  Env,
-  OutElem1,
-  InElem1,
-  OutErr1,
-  InErr1,
-  OutDone1,
-  InDone1,
-  Env1,
-  OutElem2,
-  InElem2,
-  OutErr2,
-  InErr2,
-  OutDone2,
-  InDone2,
-  Env2
->(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  options: {
-    readonly onFailure: (error: OutErr) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-    readonly onSuccess: (done: OutDone) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
-  }
-): Channel.Channel<
-  OutElem | OutElem2 | OutElem1,
-  InElem & InElem1 & InElem2,
-  OutErr2 | OutErr1,
-  InErr & InErr1 & InErr2,
-  OutDone2 | OutDone1,
-  InDone & InDone1 & InDone2,
-  Env | Env1 | Env2
-> =>
-  core.foldCauseChannel(self, {
-    onFailure: (cause) => {
-      const either = Cause.failureOrCause(cause)
-      switch (either._tag) {
-        case "Left": {
-          return options.onFailure(either.left)
-        }
-        case "Right": {
-          return core.failCause(either.right)
-        }
-      }
-    },
-    onSuccess: options.onSuccess
-  }))
-
-/** @internal */
-export const fromEither = <R, L>(
-  either: Either.Either<R, L>
-): Channel.Channel<never, unknown, L, unknown, R, unknown> =>
-  core.suspend(() => Either.match(either, { onLeft: core.fail, onRight: core.succeed }))
-
-/** @internal */
-export const fromInput = <Err, Elem, Done>(
-  input: SingleProducerAsyncInput.AsyncInputConsumer<Err, Elem, Done>
-): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
-  unwrap(
-    input.takeWith(
-      core.failCause,
-      (elem) => core.flatMap(core.write(elem), () => fromInput(input)),
-      core.succeed
-    )
-  )
-
-/** @internal */
-export const fromPubSub = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
-  unwrapScoped(Effect.map(PubSub.subscribe(pubsub), fromQueue))
-
-/** @internal */
-export const fromPubSubScoped = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Effect.Effect<Channel.Channel<Elem, unknown, Err, unknown, Done, unknown>, never, Scope.Scope> =>
-  Effect.map(PubSub.subscribe(pubsub), fromQueue)
-
-/** @internal */
-export const fromOption = <A>(
-  option: Option.Option<A>
-): Channel.Channel<never, unknown, Option.Option<never>, unknown, A, unknown> =>
-  core.suspend(() =>
-    Option.match(option, {
-      onNone: () => core.fail(Option.none()),
-      onSome: core.succeed
-    })
-  )
-
-/** @internal */
-export const fromQueue = <Done, Err, Elem>(
-  queue: Queue.Dequeue<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> => core.suspend(() => fromQueueInternal(queue))
-
-/** @internal */
-const fromQueueInternal = <Done, Err, Elem>(
-  queue: Queue.Dequeue<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
-  pipe(
-    core.fromEffect(Queue.take(queue)),
-    core.flatMap(Either.match({
-      onLeft: Exit.match({
-        onFailure: core.failCause,
-        onSuccess: core.succeedNow
-      }),
-      onRight: (elem) =>
-        core.flatMap(
-          core.write(elem),
-          () => fromQueueInternal(queue)
-        )
-    }))
-  )
-
-/** @internal */
-export const identityChannel = <Elem, Err, Done>(): Channel.Channel<Elem, Elem, Err, Err, Done, Done> =>
-  core.readWith({
-    onInput: (input: Elem) => core.flatMap(core.write(input), () => identityChannel()),
-    onFailure: core.fail,
-    onDone: core.succeedNow
-  })
-
-/** @internal */
-export const interruptWhen = dual<
-  <OutDone1, OutErr1, Env1>(
-    effect: Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    effect: Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  effect: Effect.Effect<OutDone1, OutErr1, Env1>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone | OutDone1, InDone, Env1 | Env> =>
-  mergeWith(self, {
-    other: core.fromEffect(effect),
-    onSelfDone: (selfDone) => mergeDecision.Done(Effect.suspend(() => selfDone)),
-    onOtherDone: (effectDone) => mergeDecision.Done(Effect.suspend(() => effectDone))
-  }))
-
-/** @internal */
-export const interruptWhenDeferred = dual<
-  <OutDone1, OutErr1>(
-    deferred: Deferred.Deferred<OutDone1, OutErr1>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    deferred: Deferred.Deferred<OutDone1, OutErr1>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutErr1, OutDone1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  deferred: Deferred.Deferred<OutDone1, OutErr1>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone | OutDone1, InDone, Env> =>
-  interruptWhen(self, Deferred.await(deferred)))
-
-/** @internal */
-export const map = dual<
-  <OutDone, OutDone2>(
-    f: (out: OutDone) => OutDone2
-  ) => <OutElem, InElem, OutErr, InErr, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (out: OutDone) => OutDone2
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (out: OutDone) => OutDone2
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env> =>
-  core.flatMap(self, (a) => core.sync(() => f(a))))
-
-/** @internal */
-export const mapEffect = dual<
-  <OutDone, OutDone1, OutErr1, Env1>(
-    f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => <OutElem, InElem, OutErr, InErr, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1, InDone, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone1, InDone, Env | Env1> =>
-  core.flatMap(self, (z) => core.fromEffect(f(z))))
-
-/** @internal */
-export const mapError = dual<
-  <OutErr, OutErr2>(
-    f: (err: OutErr) => OutErr2
-  ) => <OutElem, InElem, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (err: OutErr) => OutErr2
-  ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (err: OutErr) => OutErr2
-): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env> => mapErrorCause(self, Cause.map(f)))
-
-/** @internal */
-export const mapErrorCause = dual<
-  <OutErr, OutErr2>(
-    f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>
-  ) => <OutElem, InElem, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>
-  ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>
-): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env> =>
-  core.catchAllCause(self, (cause) => core.failCause(f(cause))))
-
-/** @internal */
-export const mapOut = dual<
-  <OutElem, OutElem2>(
-    f: (o: OutElem) => OutElem2
-  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => OutElem2
-  ) => Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutElem) => OutElem2
-): Channel.Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env> => {
-  const reader: Channel.Channel<OutElem2, OutElem, OutErr, OutErr, OutDone, OutDone, Env> = core
-    .readWith({
-      onInput: (outElem) => core.flatMap(core.write(f(outElem)), () => reader),
-      onFailure: core.fail,
-      onDone: core.succeedNow
-    })
-  return core.pipeTo(self, reader)
-})
-
-/** @internal */
-export const mapOutEffect = dual<
-  <OutElem, OutElem1, OutErr1, Env1>(
-    f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-  ) => Channel.Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-): Channel.Channel<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1> => {
-  const reader: Channel.Channel<OutElem1, OutElem, OutErr | OutErr1, OutErr, OutDone, OutDone, Env | Env1> = core
-    .readWithCause({
-      onInput: (outElem) =>
-        pipe(
-          core.fromEffect(f(outElem)),
-          core.flatMap(core.write),
-          core.flatMap(() => reader)
-        ),
-      onFailure: core.failCause,
-      onDone: core.succeedNow
-    })
-  return core.pipeTo(self, reader)
-})
-
-/** @internal */
-export const mapOutEffectPar = dual<
-  <OutElem, OutElem1, OutErr1, Env1>(
-    f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
-    n: number
-  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
-    n: number
-  ) => Channel.Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>
->(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
-  n: number
-): Channel.Channel<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1> =>
-  unwrapScopedWith(
-    (scope) =>
-      Effect.gen(function*() {
-        const input = yield* singleProducerAsyncInput.make<InErr, InElem, InDone>()
-        const queueReader = fromInput(input)
-        const queue = yield* Queue.bounded<Effect.Effect<Either.Either<OutElem1, OutDone>, OutErr | OutErr1, Env1>>(n)
-        yield* Scope.addFinalizer(scope, Queue.shutdown(queue))
-        const errorSignal = yield* Deferred.make<never, OutErr1>()
-        const withPermits = n === Number.POSITIVE_INFINITY ?
-          ((_: number) => identity) :
-          (yield* Effect.makeSemaphore(n)).withPermits
-        const pull = yield* queueReader.pipe(core.pipeTo(self), toPullIn(scope))
-        yield* pull.pipe(
-          Effect.matchCauseEffect({
-            onFailure: (cause) => Queue.offer(queue, Effect.failCause(cause)),
-            onSuccess: Either.match({
-              onLeft: (outDone) =>
-                Effect.zipRight(
-                  Effect.interruptible(withPermits(n)(Effect.void)),
-                  Effect.asVoid(Queue.offer(queue, Effect.succeed(Either.left(outDone))))
-                ),
-              onRight: (outElem) =>
-                Effect.gen(function*() {
-                  const deferred = yield* Deferred.make<OutElem1, OutErr1>()
-                  const latch = yield* Deferred.make<void>()
-                  yield* Queue.offer(queue, Effect.map(Deferred.await(deferred), Either.right))
-                  yield* Deferred.succeed(latch, void 0).pipe(
-                    Effect.zipRight(
-                      Effect.uninterruptibleMask((restore) =>
-                        Effect.exit(restore(Deferred.await(errorSignal))).pipe(
-                          Effect.raceFirst(Effect.exit(restore(f(outElem)))),
-                          Effect.flatMap(identity)
-                        )
-                      ).pipe(
-                        Effect.tapErrorCause((cause) => Deferred.failCause(errorSignal, cause)),
-                        Effect.intoDeferred(deferred)
-                      )
-                    ),
-                    withPermits(1),
-                    Effect.forkIn(scope)
-                  )
-                  yield* Deferred.await(latch)
-                })
-            })
-          }),
-          Effect.forever,
-          Effect.interruptible,
-          Effect.forkIn(scope)
-        )
-        const consumer: Channel.Channel<OutElem1, unknown, OutErr | OutErr1, unknown, OutDone, unknown, Env1> = unwrap(
-          Effect.matchCause(Effect.flatten(Queue.take(queue)), {
-            onFailure: core.failCause,
-            onSuccess: Either.match({
-              onLeft: core.succeedNow,
-              onRight: (outElem) => core.flatMap(core.write(outElem), () => consumer)
-            })
-          })
-        )
-        return core.embedInput(consumer, input)
-      })
-  ))
-
-/** @internal */
-export const mergeAll = (
-  options: {
-    readonly concurrency: number | "unbounded"
-    readonly bufferSize?: number | undefined
-    readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
-  }
-) => {
-  return <
-    OutElem,
-    InElem1,
-    OutErr1,
-    InErr1,
-    InDone1,
-    Env1,
-    InElem,
-    OutErr,
-    InErr,
-    InDone,
-    Env
-  >(
-    channels: Channel.Channel<
-      Channel.Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
-      InElem,
-      OutErr,
-      InErr,
-      unknown,
-      InDone,
-      Env
-    >
-  ): Channel.Channel<
-    OutElem,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    unknown,
-    InDone & InDone1,
-    Env | Env1
-  > => mergeAllWith(options)(channels, constVoid)
-}
-
-/** @internal */
-export const mergeAllUnbounded = <
-  OutElem,
-  InElem1,
-  OutErr1,
-  InErr1,
-  InDone1,
-  Env1,
-  InElem,
-  OutErr,
-  InErr,
-  InDone,
-  Env
->(
-  channels: Channel.Channel<
-    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
-    InElem,
-    OutErr,
-    InErr,
-    unknown,
-    InDone,
-    Env
-  >
-): Channel.Channel<
-  OutElem,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  unknown,
-  InDone & InDone1,
-  Env | Env1
-> => mergeAllWith({ concurrency: "unbounded" })(channels, constVoid)
-
-/** @internal */
-export const mergeAllUnboundedWith = <
-  OutElem,
-  InElem1,
-  OutErr1,
-  InErr1,
-  OutDone,
-  InDone1,
-  Env1,
-  InElem,
-  OutErr,
-  InErr,
-  InDone,
-  Env
->(
-  channels: Channel.Channel<
-    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env
-  >,
-  f: (o1: OutDone, o2: OutDone) => OutDone
-): Channel.Channel<
-  OutElem,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  OutDone,
-  InDone & InDone1,
-  Env | Env1
-> => mergeAllWith({ concurrency: "unbounded" })(channels, f)
-
-/** @internal */
-export const mergeAllWith = (
-  {
-    bufferSize = 16,
-    concurrency,
-    mergeStrategy = mergeStrategy_.BackPressure()
-  }: {
-    readonly concurrency: number | "unbounded"
-    readonly bufferSize?: number | undefined
-    readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
-  }
-) =>
-<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
-  channels: Channel.Channel<
-    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env
-  >,
-  f: (o1: OutDone, o2: OutDone) => OutDone
-): Channel.Channel<
-  OutElem,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  OutDone,
-  InDone & InDone1,
-  Env | Env1
-> =>
-  unwrapScopedWith(
-    (scope) =>
-      Effect.gen(function*() {
-        const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency
-        const input = yield* singleProducerAsyncInput.make<
-          InErr & InErr1,
-          InElem & InElem1,
-          InDone & InDone1
-        >()
-        const queueReader = fromInput(input)
-        const queue = yield* Queue.bounded<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr | OutErr1, Env>>(
-          bufferSize
-        )
-        yield* Scope.addFinalizer(scope, Queue.shutdown(queue))
-        const cancelers = yield* Queue.unbounded<Deferred.Deferred<void>>()
-        yield* Scope.addFinalizer(scope, Queue.shutdown(cancelers))
-        const lastDone = yield* Ref.make<Option.Option<OutDone>>(Option.none())
-        const errorSignal = yield* Deferred.make<void>()
-        const withPermits = (yield* Effect.makeSemaphore(concurrencyN)).withPermits
-        const pull = yield* toPullIn(core.pipeTo(queueReader, channels), scope)
-
-        function evaluatePull(
-          pull: Effect.Effect<
-            Either.Either<OutElem, OutDone>,
-            OutErr | OutErr1,
-            Env | Env1
-          >
-        ) {
-          return pull.pipe(
-            Effect.flatMap(Either.match({
-              onLeft: (done) => Effect.succeed(Option.some(done)),
-              onRight: (outElem) =>
-                Effect.as(
-                  Queue.offer(queue, Effect.succeed(Either.right(outElem))),
-                  Option.none()
-                )
-            })),
-            Effect.repeat({ until: (_): _ is Option.Some<OutDone> => Option.isSome(_) }),
-            Effect.flatMap((outDone) =>
-              Ref.update(
-                lastDone,
-                Option.match({
-                  onNone: () => Option.some(outDone.value),
-                  onSome: (lastDone) => Option.some(f(lastDone, outDone.value))
-                })
-              )
-            ),
-            Effect.catchAllCause((cause) =>
-              Cause.isInterrupted(cause)
-                ? Effect.failCause(cause)
-                : Queue.offer(queue, Effect.failCause(cause)).pipe(
-                  Effect.zipRight(Deferred.succeed(errorSignal, void 0)),
-                  Effect.asVoid
-                )
-            )
-          )
-        }
-
-        yield* pull.pipe(
-          Effect.matchCauseEffect({
-            onFailure: (cause) =>
-              Queue.offer(queue, Effect.failCause(cause)).pipe(
-                Effect.zipRight(Effect.succeed(false))
-              ),
-            onSuccess: Either.match({
-              onLeft: (outDone) =>
-                Effect.raceWith(
-                  Effect.interruptible(Deferred.await(errorSignal)),
-                  Effect.interruptible(withPermits(concurrencyN)(Effect.void)),
-                  {
-                    onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
-                    onOtherDone: (_, failureAwait) =>
-                      Effect.zipRight(
-                        Fiber.interrupt(failureAwait),
-                        Ref.get(lastDone).pipe(
-                          Effect.flatMap(Option.match({
-                            onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
-                            onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
-                          })),
-                          Effect.as(false)
-                        )
-                      )
-                  }
-                ),
-              onRight: (channel) =>
-                mergeStrategy_.match(mergeStrategy, {
-                  onBackPressure: () =>
-                    Effect.gen(function*() {
-                      const latch = yield* Deferred.make<void>()
-                      const raceEffects = Effect.scopedWith((scope) =>
-                        toPullIn(core.pipeTo(queueReader, channel), scope).pipe(
-                          Effect.flatMap((pull) =>
-                            Effect.race(
-                              Effect.exit(evaluatePull(pull)),
-                              Effect.exit(Effect.interruptible(Deferred.await(errorSignal)))
-                            )
-                          ),
-                          Effect.flatMap(identity)
-                        )
-                      )
-                      yield* Deferred.succeed(latch, void 0).pipe(
-                        Effect.zipRight(raceEffects),
-                        withPermits(1),
-                        Effect.forkIn(scope)
-                      )
-                      yield* Deferred.await(latch)
-                      const errored = yield* Deferred.isDone(errorSignal)
-                      return !errored
-                    }),
-                  onBufferSliding: () =>
-                    Effect.gen(function*() {
-                      const canceler = yield* Deferred.make<void>()
-                      const latch = yield* Deferred.make<void>()
-                      const size = yield* Queue.size(cancelers)
-                      yield* Queue.take(cancelers).pipe(
-                        Effect.flatMap((canceler) => Deferred.succeed(canceler, void 0)),
-                        Effect.when(() => size >= concurrencyN)
-                      )
-                      yield* Queue.offer(cancelers, canceler)
-                      const raceEffects = Effect.scopedWith((scope) =>
-                        toPullIn(core.pipeTo(queueReader, channel), scope).pipe(
-                          Effect.flatMap((pull) =>
-                            Effect.exit(evaluatePull(pull)).pipe(
-                              Effect.race(Effect.exit(Effect.interruptible(Deferred.await(errorSignal)))),
-                              Effect.race(Effect.exit(Effect.interruptible(Deferred.await(canceler))))
-                            )
-                          ),
-                          Effect.flatMap(identity)
-                        )
-                      )
-                      yield* Deferred.succeed(latch, void 0).pipe(
-                        Effect.zipRight(raceEffects),
-                        withPermits(1),
-                        Effect.forkIn(scope)
-                      )
-                      yield* Deferred.await(latch)
-                      const errored = yield* Deferred.isDone(errorSignal)
-                      return !errored
-                    })
-                })
-            })
-          }),
-          Effect.repeat({ while: (_) => _ }),
-          Effect.forkIn(scope)
-        )
-
-        const consumer: Channel.Channel<OutElem, unknown, OutErr | OutErr1, unknown, OutDone, unknown, Env | Env1> =
-          pipe(
-            Queue.take(queue),
-            Effect.flatten,
-            Effect.matchCause({
-              onFailure: core.failCause,
-              onSuccess: Either.match({
-                onLeft: core.succeedNow,
-                onRight: (outElem) => core.flatMap(core.write(outElem), () => consumer)
-              })
-            }),
-            unwrap
-          )
-
-        return core.embedInput(consumer, input)
-      })
-  )
-
-/** @internal */
-export const mergeMap = dual<
-  <OutElem, OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>(
-    f: (outElem: OutElem) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-    options: {
-      readonly concurrency: number | "unbounded"
-      readonly bufferSize?: number | undefined
-      readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
-    }
-  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    unknown,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (outElem: OutElem) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-    options: {
-      readonly concurrency: number | "unbounded"
-      readonly bufferSize?: number | undefined
-      readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
-    }
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    unknown,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (outElem: OutElem) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-  options: {
-    readonly concurrency: number | "unbounded"
-    readonly bufferSize?: number | undefined
-    readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
-  }
-): Channel.Channel<
-  OutElem1,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  unknown,
-  InDone & InDone1,
-  Env | Env1
-> => mergeAll(options)(mapOut(self, f)))
-
-/** @internal */
-export const mergeOut = dual<
-  (
-    n: number
-  ) => <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<
-      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-      InElem,
-      OutErr,
-      InErr,
-      OutDone,
-      InDone,
-      Env
-    >
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    unknown,
-    InDone & InDone1,
-    Env | Env1
-  >,
-  <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<
-      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-      InElem,
-      OutErr,
-      InErr,
-      OutDone,
-      InDone,
-      Env
-    >,
-    n: number
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    unknown,
-    InDone & InDone1,
-    Env | Env1
-  >
->(2, <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<
-    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env
-  >,
-  n: number
-): Channel.Channel<
-  OutElem1,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  unknown,
-  InDone & InDone1,
-  Env | Env1
-> => mergeAll({ concurrency: n })(mapOut(self, identity)))
-
-/** @internal */
-export const mergeOutWith = dual<
-  <OutDone1>(
-    n: number,
-    f: (o1: OutDone1, o2: OutDone1) => OutDone1
-  ) => <OutElem1, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
-    self: Channel.Channel<
-      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-      InElem,
-      OutErr,
-      InErr,
-      OutDone1,
-      InDone,
-      Env
-    >
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    OutDone1,
-    InDone & InDone1,
-    Env | Env1
-  >,
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
-    self: Channel.Channel<
-      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-      InElem,
-      OutErr,
-      InErr,
-      OutDone1,
-      InDone,
-      Env
-    >,
-    n: number,
-    f: (o1: OutDone1, o2: OutDone1) => OutDone1
-  ) => Channel.Channel<
-    OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    OutDone1,
-    InDone & InDone1,
-    Env | Env1
-  >
->(3, <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
-  self: Channel.Channel<
-    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone1,
-    InDone,
-    Env
-  >,
-  n: number,
-  f: (o1: OutDone1, o2: OutDone1) => OutDone1
-): Channel.Channel<
-  OutElem1,
-  InElem & InElem1,
-  OutErr | OutErr1,
-  InErr & InErr1,
-  OutDone1,
-  InDone & InDone1,
-  Env | Env1
-> => mergeAllWith({ concurrency: n })(mapOut(self, identity), f))
-
-/** @internal */
-export const mergeWith = dual<
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutDone, OutErr, OutErr2, OutDone2, OutErr3, OutDone3>(
-    options: {
-      readonly other: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-      readonly onSelfDone: (
-        exit: Exit.Exit<OutDone, OutErr>
-      ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
-      readonly onOtherDone: (
-        ex: Exit.Exit<OutDone1, OutErr1>
-      ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
-    }
-  ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr2 | OutErr3,
-    InErr & InErr1,
-    OutDone2 | OutDone3,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <
-    OutElem,
-    InElem,
-    OutErr,
-    InErr,
-    OutDone,
-    InDone,
-    Env,
-    OutElem1,
-    InElem1,
-    OutErr1,
-    InErr1,
-    OutDone1,
-    InDone1,
-    Env1,
-    OutErr2,
-    OutDone2,
-    OutErr3,
-    OutDone3
-  >(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    options: {
-      readonly other: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-      readonly onSelfDone: (
-        exit: Exit.Exit<OutDone, OutErr>
-      ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
-      readonly onOtherDone: (
-        ex: Exit.Exit<OutDone1, OutErr1>
-      ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
-    }
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr2 | OutErr3,
-    InErr & InErr1,
-    OutDone2 | OutDone3,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(2, <
-  OutElem,
-  InElem,
-  OutErr,
-  InErr,
-  OutDone,
-  InDone,
-  Env,
-  OutElem1,
-  InElem1,
-  OutErr1,
-  InErr1,
-  OutDone1,
-  InDone1,
-  Env1,
-  OutErr2,
-  OutDone2,
-  OutErr3,
-  OutDone3
->(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  options: {
-    readonly other: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
-    readonly onSelfDone: (
-      exit: Exit.Exit<OutDone, OutErr>
-    ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
-    readonly onOtherDone: (
-      ex: Exit.Exit<OutDone1, OutErr1>
-    ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
-  }
-): Channel.Channel<
-  OutElem | OutElem1,
-  InElem & InElem1,
-  OutErr2 | OutErr3,
-  InErr & InErr1,
-  OutDone2 | OutDone3,
-  InDone & InDone1,
-  Env1 | Env
-> => {
-  function merge(scope: Scope.Scope) {
-    return Effect.gen(function*() {
-      type State = MergeState.MergeState<
-        Env | Env1,
-        OutErr,
-        OutErr1,
-        OutErr2 | OutErr3,
-        OutElem | OutElem1,
-        OutDone,
-        OutDone1,
-        OutDone2 | OutDone3
-      >
-
-      const input = yield* singleProducerAsyncInput.make<
-        InErr & InErr1,
-        InElem & InElem1,
-        InDone & InDone1
-      >()
-      const queueReader = fromInput(input)
-      const pullL = yield* toPullIn(core.pipeTo(queueReader, self), scope)
-      const pullR = yield* toPullIn(core.pipeTo(queueReader, options.other), scope)
-
-      function handleSide<Err, Done, Err2, Done2>(
-        exit: Exit.Exit<Either.Either<OutElem | OutElem1, Done>, Err>,
-        fiber: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done2>, Err2>,
-        pull: Effect.Effect<Either.Either<OutElem | OutElem1, Done>, Err, Env | Env1>
-      ) {
-        return (
-          done: (
-            ex: Exit.Exit<Done, Err>
-          ) => MergeDecision.MergeDecision<
-            Env | Env1,
-            Err2,
-            Done2,
-            OutErr2 | OutErr3,
-            OutDone2 | OutDone3
-          >,
-          both: (
-            f1: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done>, Err>,
-            f2: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done2>, Err2>
-          ) => State,
-          single: (
-            f: (
-              ex: Exit.Exit<Done2, Err2>
-            ) => Effect.Effect<OutDone2 | OutDone3, OutErr2 | OutErr3, Env | Env1>
-          ) => State
-        ): Effect.Effect<
-          Channel.Channel<
-            OutElem | OutElem1,
-            unknown,
-            OutErr2 | OutErr3,
-            unknown,
-            OutDone2 | OutDone3,
-            unknown,
-            Env | Env1
-          >,
-          never,
-          Env | Env1
-        > => {
-          function onDecision(
-            decision: MergeDecision.MergeDecision<
-              Env | Env1,
-              Err2,
-              Done2,
-              OutErr2 | OutErr3,
-              OutDone2 | OutDone3
-            >
-          ): Effect.Effect<
-            Channel.Channel<
-              OutElem | OutElem1,
-              unknown,
-              OutErr2 | OutErr3,
-              unknown,
-              OutDone2 | OutDone3,
-              unknown,
-              Env | Env1
-            >
-          > {
-            const op = decision as mergeDecision.Primitive
-            if (op._tag === MergeDecisionOpCodes.OP_DONE) {
-              return Effect.succeed(
-                core.fromEffect(
-                  Effect.zipRight(
-                    Fiber.interrupt(fiber),
-                    op.effect
-                  )
-                )
-              )
-            }
-            return Effect.map(
-              Fiber.await(fiber),
-              Exit.match({
-                onFailure: (cause) => core.fromEffect(op.f(Exit.failCause(cause))),
-                onSuccess: Either.match({
-                  onLeft: (done) => core.fromEffect(op.f(Exit.succeed(done))),
-                  onRight: (elem) => zipRight(core.write(elem), go(single(op.f)))
-                })
-              })
-            )
-          }
-
-          return Exit.match(exit, {
-            onFailure: (cause) => onDecision(done(Exit.failCause(cause))),
-            onSuccess: Either.match({
-              onLeft: (z) => onDecision(done(Exit.succeed(z))),
-              onRight: (elem) =>
-                Effect.succeed(
-                  core.flatMap(core.write(elem), () =>
-                    core.flatMap(
-                      core.fromEffect(Effect.forkIn(Effect.interruptible(pull), scope)),
-                      (leftFiber) => go(both(leftFiber, fiber))
-                    ))
-                )
-            })
-          })
-        }
-      }
-
-      function go(
-        state: State
-      ): Channel.Channel<
-        OutElem | OutElem1,
-        unknown,
-        OutErr2 | OutErr3,
-        unknown,
-        OutDone2 | OutDone3,
-        unknown,
-        Env | Env1
-      > {
-        switch (state._tag) {
-          case MergeStateOpCodes.OP_BOTH_RUNNING: {
-            const leftJoin = Effect.interruptible(Fiber.join(state.left))
-            const rightJoin = Effect.interruptible(Fiber.join(state.right))
-            return unwrap(
-              Effect.raceWith(leftJoin, rightJoin, {
-                onSelfDone: (leftExit, rf) =>
-                  Effect.zipRight(
-                    Fiber.interrupt(rf),
-                    handleSide(leftExit, state.right, pullL)(
-                      options.onSelfDone,
-                      mergeState.BothRunning,
-                      (f) => mergeState.LeftDone(f)
-                    )
-                  ),
-                onOtherDone: (rightExit, lf) =>
-                  Effect.zipRight(
-                    Fiber.interrupt(lf),
-                    handleSide(rightExit, state.left, pullR)(
-                      options.onOtherDone as (
-                        ex: Exit.Exit<OutDone1, InErr1 | OutErr1>
-                      ) => MergeDecision.MergeDecision<
-                        Env1 | Env,
-                        OutErr,
-                        OutDone,
-                        OutErr2 | OutErr3,
-                        OutDone2 | OutDone3
-                      >,
-                      (left, right) => mergeState.BothRunning(right, left),
-                      (f) => mergeState.RightDone(f)
-                    )
-                  )
-              })
-            )
-          }
-          case MergeStateOpCodes.OP_LEFT_DONE: {
-            return unwrap(
-              Effect.map(
-                Effect.exit(pullR),
-                Exit.match({
-                  onFailure: (cause) => core.fromEffect(state.f(Exit.failCause(cause))),
-                  onSuccess: Either.match({
-                    onLeft: (done) => core.fromEffect(state.f(Exit.succeed(done))),
-                    onRight: (elem) =>
-                      core.flatMap(
-                        core.write(elem),
-                        () => go(mergeState.LeftDone(state.f))
-                      )
-                  })
-                })
-              )
-            )
-          }
-          case MergeStateOpCodes.OP_RIGHT_DONE: {
-            return unwrap(
-              Effect.map(
-                Effect.exit(pullL),
-                Exit.match({
-                  onFailure: (cause) => core.fromEffect(state.f(Exit.failCause(cause))),
-                  onSuccess: Either.match({
-                    onLeft: (done) => core.fromEffect(state.f(Exit.succeed(done))),
-                    onRight: (elem) =>
-                      core.flatMap(
-                        core.write(elem),
-                        () => go(mergeState.RightDone(state.f))
-                      )
-                  })
-                })
-              )
-            )
-          }
-        }
-      }
-
-      return core.fromEffect(
-        Effect.withFiberRuntime<
-          MergeState.MergeState<
-            Env | Env1,
-            OutErr,
-            OutErr1,
-            OutErr2 | OutErr3,
-            OutElem | OutElem1,
-            OutDone,
-            OutDone1,
-            OutDone2 | OutDone3
-          >,
-          never,
-          Env | Env1
-        >((parent) => {
-          const inherit = Effect.withFiberRuntime<void, never, never>((state) => {
-            ;(state as any).transferChildren((parent as any).scope())
-            return Effect.void
-          })
-          const leftFiber = Effect.interruptible(pullL).pipe(
-            Effect.ensuring(inherit),
-            Effect.forkIn(scope)
-          )
-          const rightFiber = Effect.interruptible(pullR).pipe(
-            Effect.ensuring(inherit),
-            Effect.forkIn(scope)
-          )
-          return Effect.zipWith(
-            leftFiber,
-            rightFiber,
-            (left, right): State =>
-              mergeState.BothRunning<
-                Env | Env1,
-                OutErr,
-                OutErr1,
-                OutErr2 | OutErr3,
-                OutElem | OutElem1,
-                OutDone,
-                OutDone1,
-                OutDone2 | OutDone3
-              >(left, right)
-          )
-        })
-      ).pipe(
-        core.flatMap(go),
-        core.embedInput(input)
-      )
-    })
-  }
-  return unwrapScopedWith(merge)
-})
-
-/** @internal */
-export const never: Channel.Channel<never, unknown, never, unknown, never, unknown> = core.fromEffect(
-  Effect.never
-)
-
-/** @internal */
-export const orDie = dual<
-  <E>(
-    error: LazyArg<E>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    error: LazyArg<E>
-  ) => Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  error: LazyArg<E>
-): Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env> => orDieWith(self, error))
-
-/** @internal */
-export const orDieWith = dual<
-  <OutErr>(
-    f: (e: OutErr) => unknown
-  ) => <OutElem, InElem, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (e: OutErr) => unknown
-  ) => Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (e: OutErr) => unknown
-): Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env> =>
-  catchAll(self, (e) => core.failCauseSync(() => Cause.die(f(e)))) as Channel.Channel<
-    OutElem,
-    InElem,
-    never,
-    InErr,
-    OutDone,
-    InDone,
-    Env
-  >)
-
-/** @internal */
-export const orElse = dual<
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    that: LazyArg<Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone1 | OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: LazyArg<Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone1 | OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(
-  2,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: LazyArg<Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>
-  ): Channel.Channel<
-    OutElem | OutElem1,
-    InElem & InElem1,
-    OutErr1,
-    InErr & InErr1,
-    OutDone | OutDone1,
-    InDone & InDone1,
-    Env | Env1
-  > => catchAll(self, that)
-)
-
-/** @internal */
-export const pipeToOrFail = dual<
-  <OutElem2, OutElem, OutErr2, OutDone2, OutDone, Env2>(
-    that: Channel.Channel<OutElem2, OutElem, OutErr2, never, OutDone2, OutDone, Env2>
-  ) => <InElem, OutErr, InErr, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem2, InElem, OutErr2 | OutErr, InErr, OutDone2, InDone, Env2 | Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem2, OutElem, OutErr2, never, OutDone2, OutDone, Env2>
-  ) => Channel.Channel<OutElem2, InElem, OutErr2 | OutErr, InErr, OutDone2, InDone, Env2 | Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  that: Channel.Channel<OutElem2, OutElem, OutErr2, never, OutDone2, OutDone, Env2>
-): Channel.Channel<OutElem2, InElem, OutErr | OutErr2, InErr, OutDone2, InDone, Env | Env2> =>
-  core.suspend(() => {
-    let channelException: Channel.ChannelException<OutErr | OutErr2> | undefined = undefined
-
-    const reader: Channel.Channel<OutElem, OutElem, never, OutErr, OutDone, OutDone, Env> = core
-      .readWith({
-        onInput: (outElem) => core.flatMap(core.write(outElem), () => reader),
-        onFailure: (outErr) => {
-          channelException = ChannelException(outErr)
-          return core.failCause(Cause.die(channelException))
-        },
-        onDone: core.succeedNow
-      })
-
-    const writer: Channel.Channel<
-      OutElem2,
-      OutElem2,
-      OutErr2,
-      OutErr2,
-      OutDone2,
-      OutDone2,
-      Env2
-    > = core.readWithCause({
-      onInput: (outElem) => pipe(core.write(outElem), core.flatMap(() => writer)),
-      onFailure: (cause) =>
-        Cause.isDieType(cause) &&
-          isChannelException(cause.defect) &&
-          Equal.equals(cause.defect, channelException)
-          ? core.fail(cause.defect.error as OutErr2)
-          : core.failCause(cause),
-      onDone: core.succeedNow
-    })
-
-    return core.pipeTo(core.pipeTo(core.pipeTo(self, reader), that), writer)
-  }))
-
-/** @internal */
-export const provideService = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    service: Types.NoInfer<S>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, I, S>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    tag: Context.Tag<I, S>,
-    service: Types.NoInfer<S>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>>
->(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, I, S>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  tag: Context.Tag<I, S>,
-  service: Types.NoInfer<S>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, I>> => {
-  return core.flatMap(
-    context<any>(),
-    (context) => core.provideContext(self, Context.add(context, tag, service))
-  )
-})
-
-/** @internal */
-export const provideLayer = dual<
-  <Env, OutErr2, Env0>(
-    layer: Layer.Layer<Env, OutErr2, Env0>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2, Env0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    layer: Layer.Layer<Env, OutErr2, Env0>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2, Env0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  layer: Layer.Layer<Env, OutErr2, Env0>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0> =>
-  unwrapScopedWith((scope) =>
-    Effect.map(Layer.buildWithScope(layer, scope), (context) => core.provideContext(self, context))
-  ))
-
-/** @internal */
-export const mapInputContext = dual<
-  <Env0, Env>(
-    f: (env: Context.Context<Env0>) => Context.Context<Env>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (env: Context.Context<Env0>) => Context.Context<Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (env: Context.Context<Env0>) => Context.Context<Env>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0> =>
-  contextWithChannel((context: Context.Context<Env0>) => core.provideContext(self, f(context))))
-
-/** @internal */
-export const provideSomeLayer = dual<
-  <R2, OutErr2, Env0>(
-    layer: Layer.Layer<R2, OutErr2, Env0>
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, R>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, R2, OutErr2, Env0>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
-    layer: Layer.Layer<R2, OutErr2, Env0>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, R2, OutErr2, Env0>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
-  layer: Layer.Layer<R2, OutErr2, Env0>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, R2>> =>
-  // @ts-expect-error
-  provideLayer(self, Layer.merge(Layer.context<Exclude<R, R2>>(), layer)))
-
-/** @internal */
-export const read = <In>(): Channel.Channel<never, In, Option.Option<never>, unknown, In, unknown> =>
-  core.readOrFail<Option.Option<never>, In>(Option.none())
-
-/** @internal */
-export const repeated = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> => core.flatMap(self, () => repeated(self))
-
-/** @internal */
-export const run = <OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => Effect.scopedWith((scope) => executor.runIn(self, scope))
-
-/** @internal */
-export const runCollect = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Env> => run(core.collectElements(self))
-
-/** @internal */
-export const runDrain = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env> => run(drain(self))
-
-/** @internal */
-export const runScoped = <OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<OutDone, OutErr, Env | Scope.Scope> => Effect.scopeWith((scope) => executor.runIn(self, scope))
-
-/** @internal */
-export const scoped = <A, E, R>(
-  effect: Effect.Effect<A, E, R>
-): Channel.Channel<A, unknown, E, unknown, unknown, unknown, Exclude<R, Scope.Scope>> =>
-  unwrap(
-    Effect.uninterruptibleMask((restore) =>
-      Effect.map(Scope.make(), (scope) =>
-        core.acquireReleaseOut(
-          Effect.tapErrorCause(
-            restore(Scope.extend(effect, scope)),
-            (cause) => Scope.close(scope, Exit.failCause(cause))
-          ),
-          (_, exit) => Scope.close(scope, exit)
-        ))
-    )
-  )
-
-/** @internal */
-export const scopedWith = <A, E, R>(
-  f: (scope: Scope.Scope) => Effect.Effect<A, E, R>
-): Channel.Channel<A, unknown, E, unknown, unknown, unknown, R> =>
-  unwrapScoped(Effect.map(Effect.scope, (scope) => core.flatMap(core.fromEffect(f(scope)), core.write)))
-
-/** @internal */
-export const service = <I, S>(
-  tag: Context.Tag<I, S>
-): Channel.Channel<never, unknown, never, unknown, S, unknown, I> => core.fromEffect(tag)
-
-/** @internal */
-export const serviceWith = <I, S>(tag: Context.Tag<I, S>) =>
-<OutDone>(
-  f: (resource: Types.NoInfer<S>) => OutDone
-): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, I> => map(service(tag), f)
-
-/** @internal */
-export const serviceWithChannel =
-  <I, S>(tag: Context.Tag<I, S>) =>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    f: (resource: Types.NoInfer<S>) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> => core.flatMap(service(tag), f)
-
-/** @internal */
-export const serviceWithEffect = <I, S>(tag: Context.Tag<I, S>) =>
-<Env, OutErr, OutDone>(
-  f: (resource: Types.NoInfer<S>) => Effect.Effect<OutDone, OutErr, Env>
-): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | I> => mapEffect(service(tag), f)
-
-/** @internal */
-export const splitLines = <Err, Done>(): Channel.Channel<
-  Chunk.Chunk<string>,
-  Chunk.Chunk<string>,
-  Err,
-  Err,
-  Done,
-  Done,
-  never
-> =>
-  core.suspend(() => {
-    let stringBuilder = ""
-    let midCRLF = false
-    const splitLinesChunk = (chunk: Chunk.Chunk<string>): Chunk.Chunk<string> => {
-      const chunkBuilder: Array<string> = []
-      Chunk.map(chunk, (str) => {
-        if (str.length !== 0) {
-          let from = 0
-          let indexOfCR = str.indexOf("\r")
-          let indexOfLF = str.indexOf("\n")
-          if (midCRLF) {
-            if (indexOfLF === 0) {
-              chunkBuilder.push(stringBuilder)
-              stringBuilder = ""
-              from = 1
-              indexOfLF = str.indexOf("\n", from)
-            } else {
-              stringBuilder = stringBuilder + "\r"
-            }
-            midCRLF = false
-          }
-          while (indexOfCR !== -1 || indexOfLF !== -1) {
-            if (indexOfCR === -1 || (indexOfLF !== -1 && indexOfLF < indexOfCR)) {
-              if (stringBuilder.length === 0) {
-                chunkBuilder.push(str.substring(from, indexOfLF))
-              } else {
-                chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF))
-                stringBuilder = ""
-              }
-              from = indexOfLF + 1
-              indexOfLF = str.indexOf("\n", from)
-            } else {
-              if (str.length === indexOfCR + 1) {
-                midCRLF = true
-                indexOfCR = -1
-              } else {
-                if (indexOfLF === indexOfCR + 1) {
-                  if (stringBuilder.length === 0) {
-                    chunkBuilder.push(str.substring(from, indexOfCR))
-                  } else {
-                    stringBuilder = stringBuilder + str.substring(from, indexOfCR)
-                    chunkBuilder.push(stringBuilder)
-                    stringBuilder = ""
-                  }
-                  from = indexOfCR + 2
-                  indexOfCR = str.indexOf("\r", from)
-                  indexOfLF = str.indexOf("\n", from)
-                } else {
-                  indexOfCR = str.indexOf("\r", indexOfCR + 1)
-                }
-              }
-            }
-          }
-          if (midCRLF) {
-            stringBuilder = stringBuilder + str.substring(from, str.length - 1)
-          } else {
-            stringBuilder = stringBuilder + str.substring(from, str.length)
-          }
-        }
-      })
-      return Chunk.unsafeFromArray(chunkBuilder)
-    }
-    const loop: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, Err, Err, Done, Done, never> = core
-      .readWithCause({
-        onInput: (input: Chunk.Chunk<string>) => {
-          const out = splitLinesChunk(input)
-          return Chunk.isEmpty(out)
-            ? loop
-            : core.flatMap(core.write(out), () => loop)
-        },
-        onFailure: (cause) =>
-          stringBuilder.length === 0
-            ? core.failCause(cause)
-            : core.flatMap(core.write(Chunk.of(stringBuilder)), () => core.failCause(cause)),
-        onDone: (done) =>
-          stringBuilder.length === 0
-            ? core.succeed(done)
-            : core.flatMap(core.write(Chunk.of(stringBuilder)), () => core.succeed(done))
-      })
-    return loop
-  })
-
-/** @internal */
-export const toPubSub = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<never, Elem, never, Err, unknown, Done> => toQueue(pubsub)
-
-/** @internal */
-export const toPull = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>, never, Env | Scope.Scope> =>
-  Effect.flatMap(Effect.scope, (scope) => toPullIn(self, scope))
-
-/** @internal */
-export const toPullIn = dual<
-  (scope: Scope.Scope) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Effect.Effect<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>, never, Env>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    scope: Scope.Scope
-  ) => Effect.Effect<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>, never, Env>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  scope: Scope.Scope
-) =>
-  Effect.zip(
-    Effect.sync(() => new executor.ChannelExecutor(self, void 0, identity)),
-    Effect.runtime<Env>()
-  ).pipe(
-    Effect.tap(([executor, runtime]) =>
-      Scope.addFinalizerExit(scope, (exit) => {
-        const finalizer = executor.close(exit)
-        return finalizer !== undefined
-          ? Effect.provide(finalizer, runtime)
-          : Effect.void
-      })
-    ),
-    Effect.uninterruptible,
-    Effect.map(([executor]) =>
-      Effect.suspend(() =>
-        interpretToPull(
-          executor.run() as ChannelState.ChannelState<OutErr, Env>,
-          executor
-        )
-      )
-    )
-  ))
-
-/** @internal */
-const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  channelState: ChannelState.ChannelState<OutErr, Env>,
-  exec: executor.ChannelExecutor<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env> => {
-  const state = channelState as ChannelState.Primitive
-  switch (state._tag) {
-    case ChannelStateOpCodes.OP_DONE: {
-      return Exit.match(exec.getDone(), {
-        onFailure: Effect.failCause,
-        onSuccess: (done): Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env> =>
-          Effect.succeed(Either.left(done))
-      })
-    }
-    case ChannelStateOpCodes.OP_EMIT: {
-      return Effect.succeed(Either.right(exec.getEmit()))
-    }
-    case ChannelStateOpCodes.OP_FROM_EFFECT: {
-      return pipe(
-        state.effect as Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>,
-        Effect.flatMap(() => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
-      )
-    }
-    case ChannelStateOpCodes.OP_READ: {
-      return executor.readUpstream(
-        state,
-        () => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
-        (cause) => Effect.failCause(cause) as Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>
-      )
-    }
-  }
-}
-
-/** @internal */
-export const toQueue = <Done, Err, Elem>(
-  queue: Queue.Enqueue<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<never, Elem, never, Err, unknown, Done> => core.suspend(() => toQueueInternal(queue))
-
-/** @internal */
-const toQueueInternal = <Err, Done, Elem>(
-  queue: Queue.Enqueue<Either.Either<Elem, Exit.Exit<Done, Err>>>
-): Channel.Channel<never, Elem, never, Err, unknown, Done> => {
-  return core.readWithCause({
-    onInput: (elem) =>
-      core.flatMap(
-        core.fromEffect(Queue.offer(queue, Either.right(elem))),
-        () => toQueueInternal(queue)
-      ),
-    onFailure: (cause) => core.fromEffect(Queue.offer(queue, Either.left(Exit.failCause(cause)))),
-    onDone: (done) => core.fromEffect(Queue.offer(queue, Either.left(Exit.succeed(done))))
-  })
-}
-
-/** @internal */
-export const unwrap = <OutElem, InElem, OutErr, InErr, OutDone, InDone, R2, E, R>(
-  channel: Effect.Effect<Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>, E, R>
-): Channel.Channel<OutElem, InElem, E | OutErr, InErr, OutDone, InDone, R | R2> => flatten(core.fromEffect(channel))
-
-/** @internal */
-export const unwrapScoped = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E, R>(
-  self: Effect.Effect<Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, E, R>
-): Channel.Channel<OutElem, InElem, E | OutErr, InErr, OutDone, InDone, Env | Exclude<R, Scope.Scope>> =>
-  core.concatAllWith(
-    scoped(self),
-    (d, _) => d,
-    (d, _) => d
-  )
-
-/** @internal */
-export const unwrapScopedWith = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E, R>(
-  f: (scope: Scope.Scope) => Effect.Effect<Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, E, R>
-): Channel.Channel<OutElem, InElem, E | OutErr, InErr, OutDone, InDone, R | Env> =>
-  core.concatAllWith(
-    scopedWith(f),
-    (d, _) => d,
-    (d, _) => d
-  )
-
-/** @internal */
-export const updateService = dual<
-  <I, S>(
-    tag: Context.Tag<I, S>,
-    f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
-  ) => <OutElem, OutErr, InErr, OutDone, InDone, R>(
-    self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>
-  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, I | R>,
-  <OutElem, OutErr, InErr, OutDone, InDone, R, I, S>(
-    self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
-    tag: Context.Tag<I, S>,
-    f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
-  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, I | R>
->(3, <OutElem, OutErr, InErr, OutDone, InDone, R, I, S>(
-  self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
-  tag: Context.Tag<I, S>,
-  f: (resource: Types.NoInfer<S>) => Types.NoInfer<S>
-): Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | I> =>
-  mapInputContext(self, (context: Context.Context<R>) =>
-    Context.merge(
-      context,
-      Context.make(tag, f(Context.unsafeGet(context, tag)))
-    )))
-
-/** @internal */
-export const withSpan: {
-  (
-    name: string,
-    options?: Tracer.SpanOptions
-  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    name: string,
-    options?: Tracer.SpanOptions
-  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
-} = function() {
-  const dataFirst = typeof arguments[0] !== "string"
-  const name = dataFirst ? arguments[1] : arguments[0]
-  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
-  const acquire = Effect.all([
-    Effect.makeSpan(name, options),
-    Effect.context(),
-    Effect.clock,
-    FiberRef.get(FiberRef.currentTracerTimingEnabled)
-  ])
-  if (dataFirst) {
-    const self = arguments[0]
-    return acquireUseRelease(
-      acquire,
-      ([span, context]) => core.provideContext(self, Context.add(context, tracer.spanTag, span)),
-      ([span, , clock, timingEnabled], exit) => coreEffect.endSpan(span, exit, clock, timingEnabled)
-    )
-  }
-  return (self: Channel.Channel<any>) =>
-    acquireUseRelease(
-      acquire,
-      ([span, context]) => core.provideContext(self, Context.add(context, tracer.spanTag, span)),
-      ([span, , clock, timingEnabled], exit) => coreEffect.endSpan(span, exit, clock, timingEnabled)
-    )
-} as any
-
-/** @internal */
-export const writeAll = <OutElem>(
-  ...outs: Array<OutElem>
-): Channel.Channel<OutElem> => writeChunk(Chunk.fromIterable(outs))
-
-/** @internal */
-export const writeChunk = <OutElem>(
-  outs: Chunk.Chunk<OutElem>
-): Channel.Channel<OutElem> => writeChunkWriter(0, outs.length, outs)
-
-/** @internal */
-const writeChunkWriter = <OutElem>(
-  idx: number,
-  len: number,
-  chunk: Chunk.Chunk<OutElem>
-): Channel.Channel<OutElem> => {
-  return idx === len
-    ? core.void
-    : pipe(
-      core.write(pipe(chunk, Chunk.unsafeGet(idx))),
-      core.flatMap(() => writeChunkWriter(idx + 1, len, chunk))
-    )
-}
-
-/** @internal */
-export const zip = dual<
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    readonly [OutDone, OutDone1],
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    readonly [OutDone, OutDone1],
-    InDone & InDone1,
-    Env1 | Env
-  >
->(
-  (args) => core.isChannel(args[1]),
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ): Channel.Channel<
-    OutElem | OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    readonly [OutDone, OutDone1],
-    InDone & InDone1,
-    Env | Env1
-  > =>
-    options?.concurrent ?
-      mergeWith(self, {
-        other: that,
-        onSelfDone: (exit1) => mergeDecision.Await((exit2) => Effect.suspend(() => Exit.zip(exit1, exit2))),
-        onOtherDone: (exit2) => mergeDecision.Await((exit1) => Effect.suspend(() => Exit.zip(exit1, exit2)))
-      }) :
-      core.flatMap(self, (a) => map(that, (b) => [a, b] as const))
-)
-
-/** @internal */
-export const zipLeft = dual<
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    OutDone,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(
-  (args) => core.isChannel(args[1]),
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ): Channel.Channel<
-    OutElem | OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    OutDone,
-    InDone & InDone1,
-    Env | Env1
-  > =>
-    options?.concurrent ?
-      map(zip(self, that, { concurrent: true }), (tuple) => tuple[0]) :
-      core.flatMap(self, (z) => as(that, z))
-)
-
-/** @internal */
-export const zipRight = dual<
-  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    OutDone1,
-    InDone & InDone1,
-    Env1 | Env
-  >,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ) => Channel.Channel<
-    OutElem1 | OutElem,
-    InElem & InElem1,
-    OutErr1 | OutErr,
-    InErr & InErr1,
-    OutDone1,
-    InDone & InDone1,
-    Env1 | Env
-  >
->(
-  (args) => core.isChannel(args[1]),
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
-    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ): Channel.Channel<
-    OutElem | OutElem1,
-    InElem & InElem1,
-    OutErr | OutErr1,
-    InErr & InErr1,
-    OutDone1,
-    InDone & InDone1,
-    Env | Env1
-  > =>
-    options?.concurrent ?
-      map(zip(self, that, { concurrent: true }), (tuple) => tuple[1]) :
-      core.flatMap(self, () => that)
-)
-
-/** @internal */
-export const ChannelExceptionTypeId: Channel.ChannelExceptionTypeId = Symbol.for(
-  "effect/Channel/ChannelException"
-) as Channel.ChannelExceptionTypeId
-
-/** @internal */
-export const ChannelException = <E>(error: E): Channel.ChannelException<E> => ({
-  _tag: "ChannelException",
-  [ChannelExceptionTypeId]: ChannelExceptionTypeId,
-  error
-})
-
-/** @internal */
-export const isChannelException = (u: unknown): u is Channel.ChannelException<unknown> =>
-  hasProperty(u, ChannelExceptionTypeId)