From c6d5930a065cb1b1c6e5aa5bd41eda1374012287 Mon Sep 17 00:00:00 2001
From: Giulio Canti <giulio.canti@gmail.com>
Date: Tue, 6 Feb 2024 18:54:05 +0100
Subject: [PATCH] =?UTF-8?q?change=20`Channel`=20type=20parameters=20order?=
 =?UTF-8?q?=20from=20`Channel<out=20Env,=20in=20InEr=E2=80=A6=20(#2063)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .changeset/old-rice-sniff.md                  |    5 +
 packages/effect/mod.ts                        |   23 +-
 packages/effect/src/Cause.ts                  |   10 +-
 packages/effect/src/Channel.ts                | 1504 +++++++--------
 packages/effect/src/Sink.ts                   |    4 +-
 packages/effect/src/Stream.ts                 |   12 +-
 packages/effect/src/internal/channel.ts       | 1679 ++++++++---------
 .../src/internal/channel/channelExecutor.ts   |   48 +-
 .../src/internal/channel/continuation.ts      |   12 +-
 packages/effect/src/internal/core-stream.ts   |  626 +++---
 packages/effect/src/internal/groupBy.ts       |    2 +-
 packages/effect/src/internal/sink.ts          |  102 +-
 packages/effect/src/internal/stream.ts        |  358 ++--
 packages/effect/test/Channel/reading.test.ts  |   28 +-
 packages/experimental/src/MsgPack.ts          |  198 +-
 packages/experimental/src/Socket.ts           |   47 +-
 packages/experimental/src/Socket/Node.ts      |   10 +-
 packages/platform-node-shared/src/NodeSink.ts |    2 +-
 .../platform-node-shared/src/NodeStream.ts    |    4 +-
 .../platform-node-shared/src/internal/sink.ts |    2 +-
 .../src/internal/stream.ts                    |    6 +-
 packages/platform/src/Http/Multipart.ts       |    2 +-
 packages/platform/src/internal/fileSystem.ts  |    2 +-
 .../platform/src/internal/http/multipart.ts   |   27 +-
 packages/platform/src/internal/worker.ts      |    4 +-
 25 files changed, 2299 insertions(+), 2418 deletions(-)
 create mode 100644 .changeset/old-rice-sniff.md

diff --git a/.changeset/old-rice-sniff.md b/.changeset/old-rice-sniff.md
new file mode 100644
index 0000000000..b86059da55
--- /dev/null
+++ b/.changeset/old-rice-sniff.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+change `Channel` type parameters order from `Channel<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone>` to `Channel<OutElem, InElem = unknown, OutErr = never, InErr = unknown, OutDone = void, InDone = unknown, Env = never>`
diff --git a/packages/effect/mod.ts b/packages/effect/mod.ts
index 79325229d8..36203e774f 100644
--- a/packages/effect/mod.ts
+++ b/packages/effect/mod.ts
@@ -13,7 +13,8 @@ const enabled = {
   swapFiberSetParams: false,
   swapRequestParams: false,
   swapResourceParams: false,
-  swapTExitParams: true,
+  swapTExitParams: false,
+  swapChannelParams: false,
   cleanupSTM: false,
   cleanupEffect: false,
   cleanupStream: false,
@@ -104,6 +105,23 @@ const swapRequestParams = swapParamsEA("Request")
 const swapResourceParams = swapParamsEA("Resource")
 const swapTExitParams = swapParamsEA("TExit")
 
+// from: Channel<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone>
+//           <in out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone>
+// to:   Channel<OutElem, InElem = unknown, OutErr = never, InErr = unknown, OutDone = void, InDone = unknown, Env = never>
+const swapChannelParams = (ast: cs.ASTPath<cs.TSTypeReference>) => {
+  const is = filter(ast, "VarianceStruct")
+  if (
+    is(ast.value.typeName) &&
+    ast.value.typeParameters &&
+    ast.value.typeParameters.params.length === 7
+  ) {
+    const params = ast.value.typeParameters.params
+    const newParams = [params[5], params[2], params[4], params[1], params[6], params[3], params[0]]
+    popNever(newParams)
+    ast.value.typeParameters.params = newParams
+  }
+}
+
 const swapSTMParams = swapParamsREA("STM")
 const swapSTMGenParams = swapParamsREA("STMGen")
 const swapLayerParams = swapParamsREA("Layer")
@@ -169,6 +187,9 @@ export default function transformer(file: cs.FileInfo, api: cs.API) {
     if (enabled.swapTExitParams) {
       swapTExitParams(ast)
     }
+    if (enabled.swapChannelParams) {
+      swapChannelParams(ast)
+    }
     if (enabled.cleanupEffect) {
       cleanupEffect(ast)
     }
diff --git a/packages/effect/src/Cause.ts b/packages/effect/src/Cause.ts
index 7be69e246b..255675e532 100644
--- a/packages/effect/src/Cause.ts
+++ b/packages/effect/src/Cause.ts
@@ -193,15 +193,7 @@ export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
   readonly [Effect.EffectTypeId]: Effect.Effect.VarianceStruct<never, this, never>
   readonly [Stream.StreamTypeId]: Effect.Effect.VarianceStruct<never, this, never>
   readonly [Sink.SinkTypeId]: Sink.Sink.VarianceStruct<never, this, unknown, never, never>
-  readonly [Channel.ChannelTypeId]: Channel.Channel.VarianceStruct<
-    never,
-    unknown,
-    unknown,
-    unknown,
-    this,
-    never,
-    never
-  >
+  readonly [Channel.ChannelTypeId]: Channel.Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>
 }
 
 /**
diff --git a/packages/effect/src/Channel.ts b/packages/effect/src/Channel.ts
index 16030cdc85..3c8617842f 100644
--- a/packages/effect/src/Channel.ts
+++ b/packages/effect/src/Channel.ts
@@ -71,8 +71,26 @@ export type ChannelTypeId = typeof ChannelTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Channel<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone>
-  extends Channel.Variance<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, Pipeable
+// export interface Channel<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone>
+export interface Channel<
+  out OutElem,
+  in InElem = unknown,
+  out OutErr = never,
+  in InErr = unknown,
+  out OutDone = void,
+  in InDone = unknown,
+  out Env = never
+> extends
+  Channel.Variance<
+    OutElem,
+    InElem,
+    OutErr,
+    InErr,
+    OutDone,
+    InDone,
+    Env
+  >,
+  Pipeable
 {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: ChannelUnify<this>
@@ -86,15 +104,15 @@ export interface Channel<out Env, in InErr, in InElem, in InDone, out OutErr, ou
 export interface ChannelUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
   Channel?: () => A[Unify.typeSymbol] extends
     | Channel<
-      infer Env,
-      infer InErr,
+      infer OutElem,
       infer InElem,
-      infer InDone,
       infer OutErr,
-      infer OutElem,
-      infer OutDone
+      infer InErr,
+      infer OutDone,
+      infer InDone,
+      infer Env
     >
-    | infer _ ? Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    | infer _ ? Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
     : never
 }
 
@@ -111,7 +129,7 @@ export interface ChannelUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @category models
  */
 declare module "./Effect.js" {
-  interface Effect<A, E, R> extends Channel<R, unknown, unknown, unknown, E, never, A> {}
+  interface Effect<A, E, R> extends Channel<never, unknown, E, unknown, A, unknown, R> {}
   interface EffectUnifyIgnore {
     Channel?: true
   }
@@ -125,14 +143,14 @@ export declare namespace Channel {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
-    readonly [ChannelTypeId]: VarianceStruct<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  export interface Variance<out OutElem, in InElem, out OutErr, in InErr, out OutDone, in InDone, out Env> {
+    readonly [ChannelTypeId]: VarianceStruct<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   }
   /**
    * @since 2.0.0
    * @category models
    */
-  export interface VarianceStruct<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
+  export interface VarianceStruct<out OutElem, in InElem, out OutErr, in InErr, out OutDone, in InDone, out Env> {
     _Env: Types.Covariant<Env>
     _InErr: Types.Contravariant<InErr>
     _InElem: Types.Contravariant<InElem>
@@ -172,20 +190,25 @@ export interface ChannelException<out E> {
  * @since 2.0.0
  * @category constructors
  */
-export const acquireUseRelease: <Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone, Acquired>(
+export const acquireUseRelease: <Acquired, OutErr, Env, OutElem1, InElem, InErr, OutDone, InDone>(
   acquire: Effect.Effect<Acquired, OutErr, Env>,
-  use: (a: Acquired) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>,
+  use: (a: Acquired) => Channel<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env>,
   release: (a: Acquired, exit: Exit.Exit<OutDone, OutErr>) => Effect.Effect<any, never, Env>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone> = channel.acquireUseRelease
+) => Channel<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env> = channel.acquireUseRelease
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const acquireReleaseOut: <Z, E, R, R2>(
-  self: Effect.Effect<Z, E, R>,
-  release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>
-) => Channel<R | R2, unknown, unknown, unknown, E, Z, void> = core.acquireReleaseOut
+export const acquireReleaseOut: {
+  <Z, R2>(
+    release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>
+  ): <E, R>(self: Effect.Effect<Z, E, R>) => Channel<Z, unknown, E, unknown, void, unknown, R2 | R>
+  <Z, E, R, R2>(
+    self: Effect.Effect<Z, E, R>,
+    release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>
+  ): Channel<Z, unknown, E, unknown, void, unknown, R | R2>
+} = core.acquireReleaseOut
 
 /**
  * Returns a new channel that is the same as this one, except the terminal
@@ -200,22 +223,22 @@ export const acquireReleaseOut: <Z, E, R, R2>(
 export const as: {
   <OutDone2>(
     value: OutDone2
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     value: OutDone2
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
 } = channel.as
 
 /**
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, void> = channel.asUnit
+export const asUnit: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+) => Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> = channel.asUnit
 
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel
@@ -225,21 +248,17 @@ export const asUnit: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category constructors
  */
-export const buffer: <InErr, InElem, InDone>(
-  options: {
-    readonly empty: InElem
-    readonly isEmpty: Predicate<InElem>
-    readonly ref: Ref.Ref<InElem>
-  }
-) => Channel<never, InErr, InElem, InDone, InErr, InElem, InDone> = channel.buffer
+export const buffer: <InElem, InErr, InDone>(
+  options: { readonly empty: InElem; readonly isEmpty: Predicate<InElem>; readonly ref: Ref.Ref<InElem> }
+) => Channel<InElem, InElem, InErr, InErr, InDone, InDone, never> = channel.buffer
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const bufferChunk: <InErr, InElem, InDone>(
+export const bufferChunk: <InElem, InErr, InDone>(
   ref: Ref.Ref<Chunk.Chunk<InElem>>
-) => Channel<never, InErr, Chunk.Chunk<InElem>, InDone, InErr, Chunk.Chunk<InElem>, InDone> = channel.bufferChunk
+) => Channel<Chunk.Chunk<InElem>, Chunk.Chunk<InElem>, InErr, InErr, InDone, InDone> = channel.bufferChunk
 
 /**
  * Returns a new channel that is the same as this one, except if this channel
@@ -250,30 +269,30 @@ export const bufferChunk: <InErr, InElem, InDone>(
  * @category error handling
  */
 export const catchAll: {
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    f: (error: OutErr) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-  ): <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutErr, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    f: (error: OutErr) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
+  ): <OutElem, InElem, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (error: OutErr) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (error: OutErr) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.catchAll
 
@@ -286,30 +305,30 @@ export const catchAll: {
  * @category error handling
  */
 export const catchAllCause: {
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    f: (cause: Cause.Cause<OutErr>) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-  ): <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutErr, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
+  ): <OutElem, InElem, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (cause: Cause.Cause<OutErr>) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >
 } = core.catchAllCause
 
@@ -319,9 +338,9 @@ export const catchAllCause: {
  * @since 2.0.0
  * @category constructors
  */
-export const concatAll: <Env, InErr, InElem, InDone, OutErr, OutElem>(
-  channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any>, any>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any> = core.concatAll
+export const concatAll: <OutElem, InElem, OutErr, InErr, InDone, Env>(
+  channels: Channel<Channel<OutElem, InElem, OutErr, InErr, any, InDone, Env>, InElem, OutErr, InErr, any, InDone, Env>
+) => Channel<OutElem, InElem, OutErr, InErr, any, InDone, Env> = core.concatAll
 
 /**
  * Concat sequentially a channel of channels.
@@ -330,33 +349,33 @@ export const concatAll: <Env, InErr, InElem, InDone, OutErr, OutElem>(
  * @category constructors
  */
 export const concatAllWith: <
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
   OutElem,
-  OutDone,
-  OutDone2,
-  OutDone3,
-  Env2,
-  InErr2,
   InElem2,
+  OutErr2,
+  InErr2,
+  OutDone,
   InDone2,
-  OutErr2
+  Env2,
+  InElem,
+  OutErr,
+  InErr,
+  OutDone2,
+  InDone,
+  Env,
+  OutDone3
 >(
   channels: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem, OutDone>,
-    OutDone2
+    InErr,
+    OutDone2,
+    InDone,
+    Env
   >,
   f: (o: OutDone, o1: OutDone) => OutDone,
   g: (o: OutDone, o2: OutDone2) => OutDone3
-) => Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem, OutDone3> =
+) => Channel<OutElem, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env> =
   core.concatAllWith
 
 /**
@@ -369,15 +388,15 @@ export const concatAllWith: <
  * @category utils
  */
 export const concatMap: {
-  <OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>(
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
   ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env2 | Env, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr2 | OutErr, OutElem2, unknown>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => 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, _>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>
-  ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem2, unknown>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+  ): Channel<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, unknown, InDone & InDone2, Env | Env2>
 } = channel.concatMap
 
 /**
@@ -392,35 +411,35 @@ export const concatMap: {
  * @category utils
  */
 export const concatMapWith: {
-  <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone2, OutDone3>(
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3
   ): <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
-  ) => Channel<Env2 | Env, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr2 | OutErr, OutElem2, OutDone3>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
+  ) => Channel<OutElem2, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env>
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    OutElem2,
-    OutDone,
+    InErr,
     OutDone2,
-    OutDone3,
-    Env2,
-    InErr2,
+    InDone,
+    Env,
+    OutElem2,
     InElem2,
+    OutErr2,
+    InErr2,
+    OutDone,
     InDone2,
-    OutErr2
+    Env2,
+    OutDone3
   >(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3
-  ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem2, OutDone3>
+  ): Channel<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, OutDone3, InDone & InDone2, Env | Env2>
 } = core.concatMapWith
 
 /**
@@ -435,8 +454,8 @@ export const concatMapWith: {
  * @category utils
  */
 export const concatMapWithCustom: {
-  <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone2, OutDone3>(
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3,
     onPull: (
@@ -444,34 +463,34 @@ export const concatMapWithCustom: {
     ) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>,
     onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision
   ): <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
-  ) => Channel<Env2 | Env, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr2 | OutErr, OutElem2, OutDone3>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
+  ) => Channel<OutElem2, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env>
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    OutElem2,
-    OutDone,
+    InErr,
     OutDone2,
-    OutDone3,
-    Env2,
-    InErr2,
+    InDone,
+    Env,
+    OutElem2,
     InElem2,
+    OutErr2,
+    InErr2,
+    OutDone,
     InDone2,
-    OutErr2
+    Env2,
+    OutDone3
   >(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-    f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
+    f: (o: OutElem) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3,
     onPull: (
       upstreamPullRequest: UpstreamPullRequest.UpstreamPullRequest<OutElem>
     ) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>,
     onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision
-  ): Channel<Env | Env2, InErr & InErr2, InElem & InElem2, InDone & InDone2, OutErr | OutErr2, OutElem2, OutDone3>
+  ): Channel<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, OutDone3, InDone & InDone2, Env | Env2>
 } = core.concatMapWithCustom
 
 /**
@@ -482,15 +501,15 @@ export const concatMapWithCustom: {
  * @category utils
  */
 export const collect: {
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(
+  <OutElem, OutElem2>(
     pf: (o: OutElem) => Option.Option<OutElem2>
-  ): (
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, unknown, never, unknown, void, unknown, never>
+  ) => Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     pf: (o: OutElem) => Option.Option<OutElem2>
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
+  ): Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
 } = channel.collect
 
 /**
@@ -501,17 +520,17 @@ export const collect: {
  * @since 2.0.0
  * @category utils
  */
-export const concatOut: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+export const concatOut: <OutElem, InElem, OutErr, InErr, InDone, Env, OutDone>(
   self: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown> = channel.concatOut
+) => Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env> = channel.concatOut
 
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -523,13 +542,13 @@ export const concatOut: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 export const mapInput: {
   <InDone0, InDone>(
     f: (a: InDone0) => InDone
-  ): <Env, InErr, InElem, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
-  <Env, InErr, InElem, OutErr, OutElem, OutDone, InDone0, InDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (a: InDone0) => InDone
-  ): Channel<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env>
 } = channel.mapInput
 
 /**
@@ -540,15 +559,15 @@ export const mapInput: {
  * @category utils
  */
 export const mapInputEffect: {
-  <Env1, InErr, InDone0, InDone>(
+  <InDone0, InDone, InErr, Env1>(
     f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-  ): <Env, InElem, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
-  <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr, InDone0, InDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, OutDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InDone0, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-  ): Channel<Env | Env1, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env | Env1>
 } = channel.mapInputEffect
 
 /**
@@ -561,13 +580,13 @@ export const mapInputEffect: {
 export const mapInputError: {
   <InErr0, InErr>(
     f: (a: InErr0) => InErr
-  ): <Env, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InElem, InDone, OutErr, OutElem, OutDone, InErr0, InErr>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (a: InErr0) => InErr
-  ): Channel<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env>
 } = channel.mapInputError
 
 /**
@@ -578,15 +597,15 @@ export const mapInputError: {
  * @category utils
  */
 export const mapInputErrorEffect: {
-  <Env1, InErr0, InErr, InDone>(
+  <InErr0, InDone, InErr, Env1>(
     f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-  ): <Env, InElem, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr0, InErr, InDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, OutDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InErr0, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-  ): Channel<Env | Env1, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env | Env1>
 } = channel.mapInputErrorEffect
 
 /**
@@ -599,13 +618,13 @@ export const mapInputErrorEffect: {
 export const mapInputIn: {
   <InElem0, InElem>(
     f: (a: InElem0) => InElem
-  ): <Env, InErr, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
-  <Env, InErr, InDone, OutErr, OutElem, OutDone, InElem0, InElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (a: InElem0) => InElem
-  ): Channel<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env>
 } = channel.mapInputIn
 
 /**
@@ -616,15 +635,15 @@ export const mapInputIn: {
  * @category utils
  */
 export const mapInputInEffect: {
-  <Env1, InErr, InElem0, InElem>(
+  <InElem0, InElem, InErr, Env1>(
     f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-  ): <Env, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
-  <Env, InDone, OutErr, OutElem, OutDone, Env1, InErr, InElem0, InElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, OutErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, InElem0, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-  ): Channel<Env | Env1, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env | Env1>
 } = channel.mapInputInEffect
 
 /**
@@ -639,9 +658,9 @@ export const mapInputInEffect: {
  * @since 2.0.0
  * @category utils
  */
-export const doneCollect: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env, InErr, InElem, InDone, OutErr, never, [Chunk.Chunk<OutElem>, OutDone]> = channel.doneCollect
+export const doneCollect: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+) => Channel<never, InElem, OutErr, InErr, [Chunk.Chunk<OutElem>, OutDone], InDone, Env> = channel.doneCollect
 
 /**
  * Returns a new channel which reads all the elements from upstream's output
@@ -650,9 +669,9 @@ export const doneCollect: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
  * @since 2.0.0
  * @category utils
  */
-export const drain: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env, InErr, InElem, InDone, OutErr, never, OutDone> = channel.drain
+export const drain: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+) => Channel<never, InElem, OutErr, InErr, OutDone, InDone, Env> = channel.drain
 
 /**
  * Returns a new channel which connects the given `AsyncInputProducer` as
@@ -664,13 +683,13 @@ export const drain: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 export const embedInput: {
   <InErr, InElem, InDone>(
     input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>
-  ): <Env, OutErr, OutElem, OutDone>(
-    self: Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, OutErr, OutElem, OutDone, InErr, InElem, InDone>(
-    self: Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>,
+  ): <OutElem, OutErr, OutDone, Env>(
+    self: Channel<OutElem, unknown, OutErr, unknown, OutDone, unknown, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  <OutElem, OutErr, OutDone, Env, InErr, InElem, InDone>(
+    self: Channel<OutElem, unknown, OutErr, unknown, OutDone, unknown, Env>,
     input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
 } = core.embedInput
 
 /**
@@ -680,9 +699,9 @@ export const embedInput: {
  * @since 2.0.0
  * @category utils
  */
-export const emitCollect: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env, InErr, InElem, InDone, OutErr, [Chunk.Chunk<OutElem>, OutDone], void> = channel.emitCollect
+export const emitCollect: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+) => Channel<[Chunk.Chunk<OutElem>, OutDone], InElem, OutErr, InErr, void, InDone, Env> = channel.emitCollect
 
 /**
  * Returns a new channel with an attached finalizer. The finalizer is
@@ -693,15 +712,15 @@ export const emitCollect: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
  * @category utils
  */
 export const ensuring: {
-  <Env1, Z>(
+  <Z, Env1>(
     finalizer: Effect.Effect<Z, never, Env1>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, Z>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Z, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     finalizer: Effect.Effect<Z, never, Env1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env1>
 } = channel.ensuring
 
 /**
@@ -713,15 +732,15 @@ export const ensuring: {
  * @category utils
  */
 export const ensuringWith: {
-  <Env2, OutErr, OutDone>(
+  <OutDone, OutErr, Env2>(
     finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
-  ): <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env2 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutElem, Env2, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env2 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
-  ): Channel<Env | Env2, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env2>
 } = core.ensuringWith
 
 /**
@@ -730,7 +749,7 @@ export const ensuringWith: {
  * @since 2.0.0
  * @category context
  */
-export const context: <Env>() => Channel<Env, unknown, unknown, unknown, never, never, Context.Context<Env>> =
+export const context: <Env>() => Channel<never, unknown, never, unknown, Context.Context<Env>, unknown, Env> =
   channel.context
 
 /**
@@ -741,7 +760,7 @@ export const context: <Env>() => Channel<Env, unknown, unknown, unknown, never,
  */
 export const contextWith: <Env, OutDone>(
   f: (env: Context.Context<Env>) => OutDone
-) => Channel<Env, unknown, unknown, unknown, never, never, OutDone> = channel.contextWith
+) => Channel<never, unknown, never, unknown, OutDone, unknown, Env> = channel.contextWith
 
 /**
  * Accesses the context of the channel in the context of a channel.
@@ -749,9 +768,9 @@ export const contextWith: <Env, OutDone>(
  * @since 2.0.0
  * @category context
  */
-export const contextWithChannel: <Env, Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  f: (env: Context.Context<Env>) => Channel<Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env | Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone> = channel.contextWithChannel
+export const contextWithChannel: <Env, OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1>(
+  f: (env: Context.Context<Env>) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1>
+) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env1> = channel.contextWithChannel
 
 /**
  * Accesses the context of the channel in the context of an effect.
@@ -759,9 +778,9 @@ export const contextWithChannel: <Env, Env1, InErr, InElem, InDone, OutErr, OutE
  * @since 2.0.0
  * @category context
  */
-export const contextWithEffect: <Env, Env1, OutErr, OutDone>(
+export const contextWithEffect: <Env, OutDone, OutErr, Env1>(
   f: (env: Context.Context<Env>) => Effect.Effect<OutDone, OutErr, Env1>
-) => Channel<Env | Env1, unknown, unknown, unknown, OutErr, never, OutDone> = channel.contextWithEffect
+) => Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Env1> = channel.contextWithEffect
 
 /**
  * Constructs a channel that fails immediately with the specified error.
@@ -769,7 +788,7 @@ export const contextWithEffect: <Env, Env1, OutErr, OutDone>(
  * @since 2.0.0
  * @category constructors
  */
-export const fail: <E>(error: E) => Channel<never, unknown, unknown, unknown, E, never, never> = core.fail
+export const fail: <E>(error: E) => Channel<never, unknown, E, unknown, never, unknown> = core.fail
 
 /**
  * Constructs a channel that succeeds immediately with the specified lazily
@@ -778,8 +797,7 @@ export const fail: <E>(error: E) => Channel<never, unknown, unknown, unknown, E,
  * @since 2.0.0
  * @category constructors
  */
-export const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, unknown, unknown, unknown, E, never, never> =
-  core.failSync
+export const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, unknown, E, unknown, never, unknown> = core.failSync
 
 /**
  * Constructs a channel that fails immediately with the specified `Cause`.
@@ -787,7 +805,7 @@ export const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, unknown, unkn
  * @since 2.0.0
  * @category constructors
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unknown, unknown, unknown, E, never, never> =
+export const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unknown, E, unknown, never, unknown> =
   core.failCause
 
 /**
@@ -799,7 +817,7 @@ export const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unknown, un
  */
 export const failCauseSync: <E>(
   evaluate: LazyArg<Cause.Cause<E>>
-) => Channel<never, unknown, unknown, unknown, E, never, never> = core.failCauseSync
+) => Channel<never, unknown, E, unknown, never, unknown> = core.failCauseSync
 
 /**
  * Returns a new channel, which sequentially combines this channel, together
@@ -812,30 +830,30 @@ export const failCauseSync: <E>(
  * @category sequencing
  */
 export const flatMap: {
-  <OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
-    f: (d: OutDone) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutDone, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>(
+    f: (d: OutDone) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>
+  ): <OutElem, InElem, OutErr, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone2
+    InErr & InErr1,
+    OutDone2,
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (d: OutDone) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (d: OutDone) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone2
+    InErr & InErr1,
+    OutDone2,
+    InDone & InDone1,
+    Env | Env1
   >
 } = core.flatMap
 
@@ -848,37 +866,37 @@ export const flatMap: {
  * @category sequencing
  */
 export const flatten: <
-  Env,
-  InErr,
+  OutElem,
   InElem,
-  InDone,
   OutErr,
-  OutElem,
-  Env1,
-  InErr1,
+  InErr,
+  OutElem1,
   InElem1,
-  InDone1,
   OutErr1,
-  OutElem1,
-  OutDone2
+  InErr1,
+  OutDone2,
+  InDone1,
+  Env1,
+  InDone,
+  Env
 >(
   self: Channel<
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
+    InErr,
+    Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>,
+    InDone,
+    Env
   >
 ) => Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem | OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem | OutElem1,
-  OutDone2
+  InErr & InErr1,
+  OutDone2,
+  InDone & InDone1,
+  Env1 | Env
 > = channel.flatten
 
 /**
@@ -889,74 +907,74 @@ export const flatten: <
  */
 export const foldChannel: {
   <
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
-    InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
     OutErr,
-    OutErr1,
-    OutErr2,
     OutElem1,
-    OutElem2,
-    OutDone,
+    InElem1,
+    OutErr1,
+    InErr1,
     OutDone1,
-    OutDone2
+    InDone1,
+    Env1,
+    OutDone,
+    OutElem2,
+    InElem2,
+    OutErr2,
+    InErr2,
+    OutDone2,
+    InDone2,
+    Env2
   >(
     options: {
-      readonly onFailure: (error: OutErr) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-      readonly onSuccess: (done: OutDone) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone2>
+      readonly onFailure: (error: OutErr) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
+      readonly onSuccess: (done: OutDone) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
     }
   ): <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr1 | OutErr2,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone1 | OutDone2
+    InErr & InErr1 & InErr2,
+    OutDone1 | OutDone2,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
+    Env,
+    OutElem1,
     InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
-    OutErr,
     OutErr1,
-    OutErr2,
-    OutElem1,
-    OutElem2,
-    OutDone,
+    InErr1,
     OutDone1,
-    OutDone2
+    InDone1,
+    Env1,
+    OutElem2,
+    InElem2,
+    OutErr2,
+    InErr2,
+    OutDone2,
+    InDone2,
+    Env2
   >(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
-      readonly onFailure: (error: OutErr) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-      readonly onSuccess: (done: OutDone) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone2>
+      readonly onFailure: (error: OutErr) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
+      readonly onSuccess: (done: OutDone) => Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
     }
   ): Channel<
-    Env | Env1 | Env2,
-    InErr & InErr1 & InErr2,
+    OutElem | OutElem1 | OutElem2,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr1 | OutErr2,
-    OutElem | OutElem1 | OutElem2,
-    OutDone1 | OutDone2
+    InErr & InErr1 & InErr2,
+    OutDone1 | OutDone2,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
   >
 } = channel.foldChannel
 
@@ -968,78 +986,78 @@ export const foldChannel: {
  */
 export const foldCauseChannel: {
   <
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
-    InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
     OutErr,
-    OutErr2,
-    OutErr3,
     OutElem1,
-    OutElem2,
-    OutDone,
+    InElem1,
+    OutErr2,
+    InErr1,
     OutDone2,
-    OutDone3
+    InDone1,
+    Env1,
+    OutDone,
+    OutElem2,
+    InElem2,
+    OutErr3,
+    InErr2,
+    OutDone3,
+    InDone2,
+    Env2
   >(
     options: {
       readonly onFailure: (
         c: Cause.Cause<OutErr>
-      ) => Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>
-      readonly onSuccess: (o: OutDone) => Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>
+      ) => Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>
+      readonly onSuccess: (o: OutDone) => Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>
     }
   ): <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1 & InErr2,
+    OutDone2 | OutDone3,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
+    Env,
+    OutElem1,
     InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
-    OutErr,
     OutErr2,
-    OutErr3,
-    OutElem1,
-    OutElem2,
-    OutDone,
+    InErr1,
     OutDone2,
-    OutDone3
+    InDone1,
+    Env1,
+    OutElem2,
+    InElem2,
+    OutErr3,
+    InErr2,
+    OutDone3,
+    InDone2,
+    Env2
   >(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
       readonly onFailure: (
         c: Cause.Cause<OutErr>
-      ) => Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>
-      readonly onSuccess: (o: OutDone) => Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>
+      ) => Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>
+      readonly onSuccess: (o: OutDone) => Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>
     }
   ): Channel<
-    Env | Env1 | Env2,
-    InErr & InErr1 & InErr2,
+    OutElem | OutElem1 | OutElem2,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr2 | OutErr3,
-    OutElem | OutElem1 | OutElem2,
-    OutDone2 | OutDone3
+    InErr & InErr1 & InErr2,
+    OutDone2 | OutDone3,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
   >
 } = core.foldCauseChannel
 
@@ -1051,7 +1069,7 @@ export const foldCauseChannel: {
  */
 export const fromEffect: <A, E, R>(
   effect: Effect.Effect<A, E, R>
-) => Channel<R, unknown, unknown, unknown, E, never, A> = core.fromEffect
+) => Channel<never, unknown, E, unknown, A, unknown, R> = core.fromEffect
 
 /**
  * Constructs a channel from an `Either`.
@@ -1059,7 +1077,7 @@ export const fromEffect: <A, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, unknown, unknown, unknown, E, never, A> =
+export const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, unknown, E, unknown, A, unknown> =
   channel.fromEither
 
 /**
@@ -1070,7 +1088,7 @@ export const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, u
  */
 export const fromInput: <Err, Elem, Done>(
   input: SingleProducerAsyncInput.AsyncInputConsumer<Err, Elem, Done>
-) => Channel<never, unknown, unknown, unknown, Err, Elem, Done> = channel.fromInput
+) => Channel<Elem, unknown, Err, unknown, Done, unknown> = channel.fromInput
 
 /**
  * Construct a `Channel` from a `PubSub`.
@@ -1078,9 +1096,9 @@ export const fromInput: <Err, Elem, Done>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromPubSub: <Err, Done, Elem>(
+export const fromPubSub: <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-) => Channel<never, unknown, unknown, unknown, Err, Elem, Done> = channel.fromPubSub
+) => Channel<Elem, unknown, Err, unknown, Done, unknown> = channel.fromPubSub
 
 /**
  * Construct a `Channel` from a `PubSub` within a scoped effect.
@@ -1088,10 +1106,9 @@ export const fromPubSub: <Err, Done, Elem>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromPubSubScoped: <Err, Done, Elem>(
+export const fromPubSubScoped: <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-) => Effect.Effect<Channel<never, unknown, unknown, unknown, Err, Elem, Done>, never, Scope.Scope> =
-  channel.fromPubSubScoped
+) => Effect.Effect<Channel<Elem, unknown, Err, unknown, Done, unknown>, never, Scope.Scope> = channel.fromPubSubScoped
 
 /**
  * Construct a `Channel` from an `Option`.
@@ -1101,7 +1118,7 @@ export const fromPubSubScoped: <Err, Done, Elem>(
  */
 export const fromOption: <A>(
   option: Option.Option<A>
-) => Channel<never, unknown, unknown, unknown, Option.Option<never>, never, A> = channel.fromOption
+) => Channel<never, unknown, Option.Option<never>, unknown, A, unknown> = channel.fromOption
 
 /**
  * Construct a `Channel` from a `Queue`.
@@ -1109,15 +1126,15 @@ export const fromOption: <A>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromQueue: <Err, Elem, Done>(
+export const fromQueue: <Done, Err, Elem>(
   queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-) => Channel<never, unknown, unknown, unknown, Err, Elem, Done> = channel.fromQueue
+) => Channel<Elem, unknown, Err, unknown, Done, unknown> = channel.fromQueue
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const identity: <Err, Elem, Done>() => Channel<never, Err, Elem, Done, Err, Elem, Done> = channel.identityChannel
+export const identity: <Elem, Err, Done>() => Channel<Elem, Elem, Err, Err, Done, Done> = channel.identityChannel
 
 /**
  * Returns a new channel, which is the same as this one, except it will be
@@ -1132,15 +1149,15 @@ export const identity: <Err, Elem, Done>() => Channel<never, Err, Elem, Done, Er
  * @category utils
  */
 export const interruptWhen: {
-  <Env1, OutErr1, OutDone1>(
+  <OutDone1, OutErr1, Env1>(
     effect: Effect.Effect<OutDone1, OutErr1, Env1>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, OutErr1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     effect: Effect.Effect<OutDone1, OutErr1, Env1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone | OutDone1>
+  ): Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone | OutDone1, InDone, Env | Env1>
 } = channel.interruptWhen
 
 /**
@@ -1155,15 +1172,15 @@ export const interruptWhen: {
  * @category utils
  */
 export const interruptWhenDeferred: {
-  <OutErr1, OutDone1>(
+  <OutDone1, OutErr1>(
     deferred: Deferred.Deferred<OutDone1, OutErr1>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutErr1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     deferred: Deferred.Deferred<OutDone1, OutErr1>
-  ): Channel<Env, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone | OutDone1>
+  ): Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone | OutDone1, InDone, Env>
 } = channel.interruptWhenDeferred
 
 /**
@@ -1177,13 +1194,13 @@ export const interruptWhenDeferred: {
 export const map: {
   <OutDone, OutDone2>(
     f: (out: OutDone) => OutDone2
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (out: OutDone) => OutDone2
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
 } = channel.map
 
 /**
@@ -1195,15 +1212,15 @@ export const map: {
  * @category mapping
  */
 export const mapEffect: {
-  <Env1, OutErr1, OutDone, OutDone1>(
+  <OutDone, OutDone1, OutErr1, Env1>(
     f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, Env1, OutErr1, OutDone, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutDone1, OutErr1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone1>
+  ): Channel<OutElem, InElem, OutErr | OutErr1, InErr, OutDone1, InDone, Env | Env1>
 } = channel.mapEffect
 
 /**
@@ -1217,13 +1234,13 @@ export const mapEffect: {
 export const mapError: {
   <OutErr, OutErr2>(
     f: (err: OutErr) => OutErr2
-  ): <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (err: OutErr) => OutErr2
-  ): Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
 } = channel.mapError
 
 /**
@@ -1236,13 +1253,13 @@ export const mapError: {
 export const mapErrorCause: {
   <OutErr, OutErr2>(
     f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>
-  ): <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>
-  ): Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>
 } = channel.mapErrorCause
 
 /**
@@ -1254,13 +1271,13 @@ export const mapErrorCause: {
 export const mapOut: {
   <OutElem, OutElem2>(
     f: (o: OutElem) => OutElem2
-  ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (o: OutElem) => OutElem2
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
+  ): Channel<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>
 } = channel.mapOut
 
 /**
@@ -1271,15 +1288,15 @@ export const mapOut: {
  * @category mapping
  */
 export const mapOutEffect: {
-  <OutElem, Env1, OutErr1, OutElem1>(
+  <OutElem, OutElem1, OutErr1, Env1>(
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-  ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone>
+  ): Channel<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1>
 } = channel.mapOutEffect
 
 /**
@@ -1291,17 +1308,17 @@ export const mapOutEffect: {
  * @category mapping
  */
 export const mapOutEffectPar: {
-  <OutElem, Env1, OutErr1, OutElem1>(
+  <OutElem, OutElem1, OutErr1, Env1>(
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
     n: number
-  ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem1, InElem, OutErr1 | OutErr, InErr, OutDone, InDone, Env1 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, OutErr1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
     n: number
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone>
+  ): Channel<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1>
 } = channel.mapOutEffectPar
 
 /**
@@ -1314,34 +1331,34 @@ export const mergeAll: (
     readonly bufferSize?: number | undefined
     readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
   }
-) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem>(
+) => <OutElem, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
   channels: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>,
-    unknown
+    InErr,
+    unknown,
+    InDone,
+    Env
   >
-) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, unknown> =
+) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env> =
   channel.mergeAll
 
 /**
  * @since 2.0.0
  * @category utils
  */
-export const mergeAllUnbounded: <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem>(
+export const mergeAllUnbounded: <OutElem, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
   channels: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>,
-    unknown
+    InErr,
+    unknown,
+    InDone,
+    Env
   >
-) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, unknown> =
+) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env> =
   channel.mergeAllUnbounded
 
 /**
@@ -1349,30 +1366,30 @@ export const mergeAllUnbounded: <Env, Env1, InErr, InErr1, InElem, InElem1, InDo
  * @category utils
  */
 export const mergeAllUnboundedWith: <
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
+  OutElem,
   InElem1,
-  InDone,
+  OutErr1,
+  InErr1,
+  OutDone,
   InDone1,
+  Env1,
+  InElem,
   OutErr,
-  OutErr1,
-  OutElem,
-  OutDone
+  InErr,
+  InDone,
+  Env
 >(
   channels: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >,
   f: (o1: OutDone, o2: OutDone) => OutDone
-) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone> =
+) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone, InDone & InDone1, Env1 | Env> =
   channel.mergeAllUnboundedWith
 
 /**
@@ -1385,18 +1402,18 @@ export const mergeAllWith: (
     readonly bufferSize?: number | undefined
     readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
   }
-) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem, OutDone>(
+) => <OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
   channels: Channel<
-    Env,
-    InErr,
+    Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >,
   f: (o1: OutDone, o2: OutDone) => OutDone
-) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone> =
+) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone, InDone & InDone1, Env1 | Env> =
   channel.mergeAllWith
 
 /**
@@ -1411,25 +1428,25 @@ export const mergeAllWith: (
  * @category mapping
  */
 export const mergeMap: {
-  <OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(
-    f: (outElem: OutElem) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
+  <OutElem, OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>(
+    f: (outElem: OutElem) => Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
     options: {
       readonly concurrency: number | "unbounded"
       readonly bufferSize?: number | undefined
       readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
     }
-  ): <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1, unknown>
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (outElem: OutElem) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
+  ): <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => 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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (outElem: OutElem) => Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
     options: {
       readonly concurrency: number | "unbounded"
       readonly bufferSize?: number | undefined
       readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
     }
-  ): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown>
+  ): Channel<OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, unknown, InDone & InDone1, Env | Env1>
 } = channel.mergeMap
 
 /**
@@ -1442,29 +1459,29 @@ export const mergeMap: {
 export const mergeOut: {
   (
     n: number
-  ): <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(
+  ): <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel<
-      Env,
-      InErr,
+      Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
-      OutDone
+      InErr,
+      OutDone,
+      InDone,
+      Env
     >
-  ) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown>
-  <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(
+  ) => Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env>
+  <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel<
-      Env,
-      InErr,
+      Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
-      OutDone
+      InErr,
+      OutDone,
+      InDone,
+      Env
     >,
     n: number
-  ): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown>
+  ): Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env>
 } = channel.mergeOut
 
 /**
@@ -1480,30 +1497,30 @@ export const mergeOutWith: {
   <OutDone1>(
     n: number,
     f: (o1: OutDone1, o2: OutDone1) => OutDone1
-  ): <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1>(
+  ): <OutElem1, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
     self: Channel<
-      Env,
-      InErr,
+      Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-      OutDone1
+      InErr,
+      OutDone1,
+      InDone,
+      Env
     >
-  ) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, OutDone1>
-  <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
+  ) => Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone1, InDone & InDone1, Env1 | Env>
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
     self: Channel<
-      Env,
-      InErr,
+      Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-      OutDone1
+      InErr,
+      OutDone1,
+      InDone,
+      Env
     >,
     n: number,
     f: (o1: OutDone1, o2: OutDone1) => OutDone1
-  ): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, OutDone1>
+  ): Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone1, InDone & InDone1, Env1 | Env>
 } = channel.mergeOutWith
 
 /**
@@ -1516,9 +1533,9 @@ export const mergeOutWith: {
  * @category utils
  */
 export const mergeWith: {
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutErr2, OutErr3, OutElem1, OutDone, OutDone1, OutDone2, OutDone3>(
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutDone, OutErr, OutErr2, OutDone2, OutErr3, OutDone3>(
     options: {
-      readonly other: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      readonly other: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
       readonly onSelfDone: (
         exit: Exit.Exit<OutDone, OutErr>
       ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
@@ -1527,39 +1544,39 @@ export const mergeWith: {
       ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
     }
   ): <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1,
+    OutDone2 | OutDone3,
+    InDone & InDone1,
+    Env1 | Env
   >
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    InErr1,
+    Env,
+    OutElem1,
     InElem1,
-    InDone1,
-    OutErr,
     OutErr1,
-    OutErr2,
-    OutErr3,
-    OutElem1,
-    OutDone,
+    InErr1,
     OutDone1,
+    InDone1,
+    Env1,
+    OutErr2,
     OutDone2,
+    OutErr3,
     OutDone3
   >(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
-      readonly other: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      readonly other: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
       readonly onSelfDone: (
         exit: Exit.Exit<OutDone, OutErr>
       ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
@@ -1568,13 +1585,13 @@ export const mergeWith: {
       ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
     }
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr2 | OutErr3,
-    OutElem | OutElem1,
-    OutDone2 | OutDone3
+    InErr & InErr1,
+    OutDone2 | OutDone3,
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.mergeWith
 
@@ -1584,7 +1601,7 @@ export const mergeWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const never: Channel<never, unknown, unknown, unknown, never, never, never> = channel.never
+export const never: Channel<never, unknown, never, unknown, never, unknown> = channel.never
 
 /**
  * Translates channel failure into death of the fiber, making all failures
@@ -1596,13 +1613,13 @@ export const never: Channel<never, unknown, unknown, unknown, never, never, neve
 export const orDie: {
   <E>(
     error: LazyArg<E>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, E>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     error: LazyArg<E>
-  ): Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>
+  ): Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
 } = channel.orDie
 
 /**
@@ -1615,13 +1632,13 @@ export const orDie: {
 export const orDieWith: {
   <OutErr>(
     f: (e: OutErr) => unknown
-  ): <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (e: OutErr) => unknown
-  ): Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>
+  ): Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>
 } = channel.orDieWith
 
 /**
@@ -1633,30 +1650,30 @@ export const orDieWith: {
  * @category error handling
  */
 export const orElse: {
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: LazyArg<Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: LazyArg<Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: LazyArg<Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: LazyArg<Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.orElse
 
@@ -1670,15 +1687,15 @@ export const orElse: {
  * @category utils
  */
 export const pipeTo: {
-  <Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    that: Channel<Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ): <Env, InErr, InElem, InDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env2 | Env, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
-  <Env, InErr, InElem, InDone, Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel<Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ): Channel<Env | Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
+  <OutElem2, OutElem, OutErr2, OutErr, OutDone2, OutDone, Env2>(
+    that: Channel<OutElem2, OutElem, OutErr2, OutErr, OutDone2, OutDone, Env2>
+  ): <InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: Channel<OutElem2, OutElem, OutErr2, OutErr, OutDone2, OutDone, Env2>
+  ): Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env | Env2>
 } = core.pipeTo
 
 /**
@@ -1690,15 +1707,15 @@ export const pipeTo: {
  * @category utils
  */
 export const pipeToOrFail: {
-  <Env2, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    that: Channel<Env2, never, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ): <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env2 | Env, InErr, InElem, InDone, OutErr2 | OutErr, OutElem2, OutDone2>
-  <Env, InErr, InElem, InDone, OutErr, Env2, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel<Env2, never, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ): Channel<Env | Env2, InErr, InElem, InDone, OutErr | OutErr2, OutElem2, OutDone2>
+  <OutElem2, OutElem, OutErr2, OutDone2, OutDone, Env2>(
+    that: Channel<OutElem2, OutElem, OutErr2, never, OutDone2, OutDone, Env2>
+  ): <InElem, OutErr, InErr, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem2, InElem, OutErr2 | OutErr, InErr, OutDone2, InDone, Env2 | Env>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: Channel<OutElem2, OutElem, OutErr2, never, OutDone2, OutDone, Env2>
+  ): Channel<OutElem2, InElem, OutErr | OutErr2, InErr, OutDone2, InDone, Env | Env2>
 } = channel.pipeToOrFail
 
 /**
@@ -1711,13 +1728,13 @@ export const pipeToOrFail: {
 export const provideContext: {
   <Env>(
     env: Context.Context<Env>
-  ): <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, never>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     env: Context.Context<Env>
-  ): Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, never>
 } = core.provideContext
 
 /**
@@ -1727,15 +1744,15 @@ export const provideContext: {
  * @category context
  */
 export const provideLayer: {
-  <Env0, Env, OutErr2>(
+  <Env, OutErr2, Env0>(
     layer: Layer.Layer<Env, OutErr2, Env0>
-  ): <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env0, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env, OutErr2>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutErr2, Env0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     layer: Layer.Layer<Env, OutErr2, Env0>
-  ): Channel<Env0, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0>
 } = channel.provideLayer
 
 /**
@@ -1748,13 +1765,13 @@ export const provideLayer: {
 export const mapInputContext: {
   <Env0, Env>(
     f: (env: Context.Context<Env0>) => Context.Context<Env>
-  ): <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     f: (env: Context.Context<Env0>) => Context.Context<Env>
-  ): Channel<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0>
 } = channel.mapInputContext
 
 /**
@@ -1765,15 +1782,15 @@ export const mapInputContext: {
  * @category context
  */
 export const provideSomeLayer: {
-  <Env0, Env2, OutErr2>(
+  <Env2, OutErr2, Env0>(
     layer: Layer.Layer<Env2, OutErr2, Env0>
-  ): <R, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<R, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>
-  <R, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env2, OutErr2>(
-    self: Channel<R, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, R>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>
+  ) => Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
     layer: Layer.Layer<Env2, OutErr2, Env0>
-  ): Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
 } = channel.provideSomeLayer
 
 /**
@@ -1787,62 +1804,62 @@ export const provideService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, T extends Context.Tag<any, any>>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, T extends Context.Tag<any, any>>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     tag: T,
     service: Context.Tag.Service<T>
-  ): Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>
 } = channel.provideService
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const read: <In>() => Channel<never, unknown, In, unknown, Option.Option<never>, never, In> = channel.read
+export const read: <In>() => Channel<never, In, Option.Option<never>, unknown, In, unknown> = channel.read
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const readOrFail: <In, E>(error: E) => Channel<never, unknown, In, unknown, E, never, In> = core.readOrFail
+export const readOrFail: <E, In = unknown>(error: E) => Channel<never, In, E, unknown, In, unknown> = core.readOrFail
 
 /**
  * @since 2.0.0
  * @category constructors
  */
 export const readWith: <
-  Env,
-  InErr,
   InElem,
-  InDone,
-  OutErr,
   OutElem,
+  OutErr,
+  InErr,
   OutDone,
-  Env2,
-  OutErr2,
+  InDone,
+  Env,
   OutElem2,
+  OutErr2,
   OutDone2,
-  Env3,
-  OutErr3,
+  Env2,
   OutElem3,
-  OutDone3
+  OutErr3,
+  OutDone3,
+  Env3
 >(
   options: {
-    readonly onInput: (input: InElem) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-    readonly onFailure: (error: InErr) => Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
-    readonly onDone: (done: InDone) => Channel<Env3, InErr, InElem, InDone, OutErr3, OutElem3, OutDone3>
+    readonly onInput: (input: InElem) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+    readonly onFailure: (error: InErr) => Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
+    readonly onDone: (done: InDone) => Channel<OutElem3, InElem, OutErr3, InErr, OutDone3, InDone, Env3>
   }
 ) => Channel<
-  Env | Env2 | Env3,
-  InErr,
+  OutElem | OutElem2 | OutElem3,
   InElem,
-  InDone,
   OutErr | OutErr2 | OutErr3,
-  OutElem | OutElem2 | OutElem3,
-  OutDone | OutDone2 | OutDone3
+  InErr,
+  OutDone | OutDone2 | OutDone3,
+  InDone,
+  Env | Env2 | Env3
 > = core.readWith
 
 /**
@@ -1850,35 +1867,35 @@ export const readWith: <
  * @category constructors
  */
 export const readWithCause: <
-  Env,
-  InErr,
   InElem,
-  InDone,
-  OutErr,
   OutElem,
+  OutErr,
+  InErr,
   OutDone,
-  Env2,
-  OutErr2,
+  InDone,
+  Env,
   OutElem2,
+  OutErr2,
   OutDone2,
-  Env3,
-  OutErr3,
+  Env2,
   OutElem3,
-  OutDone3
+  OutErr3,
+  OutDone3,
+  Env3
 >(
   options: {
-    readonly onInput: (input: InElem) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-    readonly onFailure: (cause: Cause.Cause<InErr>) => Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
-    readonly onDone: (done: InDone) => Channel<Env3, InErr, InElem, InDone, OutErr3, OutElem3, OutDone3>
+    readonly onInput: (input: InElem) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+    readonly onFailure: (cause: Cause.Cause<InErr>) => Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
+    readonly onDone: (done: InDone) => Channel<OutElem3, InElem, OutErr3, InErr, OutDone3, InDone, Env3>
   }
 ) => Channel<
-  Env | Env2 | Env3,
-  InErr,
+  OutElem | OutElem2 | OutElem3,
   InElem,
-  InDone,
   OutErr | OutErr2 | OutErr3,
-  OutElem | OutElem2 | OutElem3,
-  OutDone | OutDone2 | OutDone3
+  InErr,
+  OutDone | OutDone2 | OutDone3,
+  InDone,
+  Env | Env2 | Env3
 > = core.readWithCause
 
 /**
@@ -1887,9 +1904,9 @@ export const readWithCause: <
  * @since 2.0.0
  * @category utils
  */
-export const repeated: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> = channel.repeated
+export const repeated: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> = channel.repeated
 
 /**
  * Runs a channel until the end is received.
@@ -1897,8 +1914,8 @@ export const repeated: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const run: <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
+export const run: <OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ) => Effect.Effect<OutDone, OutErr, Env> = channel.run
 
 /**
@@ -1910,8 +1927,8 @@ export const run: <Env, InErr, InDone, OutErr, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const runCollect: <Env, InErr, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, unknown, InDone, OutErr, OutElem, OutDone>
+export const runCollect: <OutElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
 ) => Effect.Effect<[Chunk.Chunk<OutElem>, OutDone], OutErr, Env> = channel.runCollect
 
 /**
@@ -1920,8 +1937,8 @@ export const runCollect: <Env, InErr, InDone, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const runDrain: <Env, InErr, InDone, OutElem, OutErr, OutDone>(
-  self: Channel<Env, InErr, unknown, InDone, OutErr, OutElem, OutDone>
+export const runDrain: <OutElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
 ) => Effect.Effect<OutDone, OutErr, Env> = channel.runDrain
 
 /**
@@ -1932,7 +1949,7 @@ export const runDrain: <Env, InErr, InDone, OutElem, OutErr, OutDone>(
  */
 export const scoped: <A, E, R>(
   effect: Effect.Effect<A, E, R>
-) => Channel<Exclude<R, Scope.Scope>, unknown, unknown, unknown, E, A, unknown> = channel.scoped
+) => Channel<A, unknown, E, unknown, unknown, unknown, Exclude<R, Scope.Scope>> = channel.scoped
 
 /**
  * Constructs a channel that succeeds immediately with the specified value.
@@ -1940,7 +1957,7 @@ export const scoped: <A, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const succeed: <A>(value: A) => Channel<never, unknown, unknown, unknown, never, never, A> = core.succeed
+export const succeed: <A>(value: A) => Channel<never, unknown, never, unknown, A, unknown> = core.succeed
 
 /**
  * Lazily constructs a channel from the given side effect.
@@ -1948,9 +1965,9 @@ export const succeed: <A>(value: A) => Channel<never, unknown, unknown, unknown,
  * @since 2.0.0
  * @category constructors
  */
-export const suspend: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  evaluate: LazyArg<Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> = core.suspend
+export const suspend: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  evaluate: LazyArg<Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>>
+) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> = core.suspend
 
 /**
  * Constructs a channel that succeeds immediately with the specified lazy value.
@@ -1960,7 +1977,7 @@ export const suspend: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  */
 export const sync: <OutDone>(
   evaluate: LazyArg<OutDone>
-) => Channel<never, unknown, unknown, unknown, never, never, OutDone> = core.sync
+) => Channel<never, unknown, never, unknown, OutDone, unknown> = core.sync
 
 /**
  * Converts a `Channel` to a `PubSub`.
@@ -1968,9 +1985,9 @@ export const sync: <OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const toPubSub: <Err, Done, Elem>(
+export const toPubSub: <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-) => Channel<never, Err, Elem, Done, never, never, unknown> = channel.toPubSub
+) => Channel<never, Elem, never, Err, unknown, Done> = channel.toPubSub
 
 /**
  * Returns a scoped `Effect` that can be used to repeatedly pull elements from
@@ -1981,8 +1998,8 @@ export const toPubSub: <Err, Done, Elem>(
  * @since 2.0.0
  * @category destructors
  */
-export const toPull: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+export const toPull: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
 ) => Effect.Effect<Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env>, never, Scope.Scope | Env> =
   channel.toPull
 
@@ -1992,17 +2009,17 @@ export const toPull: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const toQueue: <Err, Done, Elem>(
+export const toQueue: <Done, Err, Elem>(
   queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-) => Channel<never, Err, Elem, Done, never, never, unknown> = channel.toQueue
+) => Channel<never, Elem, never, Err, unknown, Done> = channel.toQueue
 
 /** Converts this channel to a `Sink`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export const toSink: <Env, InErr, InElem, OutErr, OutElem, OutDone>(
-  self: Channel<Env, InErr, Chunk.Chunk<InElem>, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>
+export const toSink: <OutElem, InElem, OutErr, InErr, OutDone, Env>(
+  self: Channel<Chunk.Chunk<OutElem>, Chunk.Chunk<InElem>, OutErr, InErr, OutDone, unknown, Env>
 ) => Sink.Sink<Env, OutErr, InElem, OutElem, OutDone> = sink.channelToSink
 
 /**
@@ -2011,15 +2028,15 @@ export const toSink: <Env, InErr, InElem, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const toStream: <Env, OutErr, OutElem, OutDone>(
-  self: Channel<Env, unknown, unknown, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>
+export const toStream: <OutElem, OutErr, OutDone, Env>(
+  self: Channel<Chunk.Chunk<OutElem>, unknown, OutErr, unknown, OutDone, unknown, Env>
 ) => Stream.Stream<OutElem, OutErr, Env> = stream.channelToStream
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const unit: Channel<never, unknown, unknown, unknown, never, never, void> = core.unit
+export const unit: Channel<never> = core.unit
 
 /**
  * Makes a channel from an effect that returns a channel in case of success.
@@ -2027,9 +2044,9 @@ export const unit: Channel<never, unknown, unknown, unknown, never, never, void>
  * @since 2.0.0
  * @category constructors
  */
-export const unwrap: <R2, InErr, InElem, InDone, OutErr, OutElem, OutDone, E, R>(
-  channel: Effect.Effect<Channel<R2, InErr, InElem, InDone, OutErr, OutElem, OutDone>, E, R>
-) => Channel<R | R2, InErr, InElem, InDone, E | OutErr, OutElem, OutDone> = channel.unwrap
+export const unwrap: <OutElem, InElem, OutErr, InErr, OutDone, InDone, R2, E, R>(
+  channel: Effect.Effect<Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>, E, R>
+) => Channel<OutElem, InElem, E | OutErr, InErr, OutDone, InDone, R | R2> = channel.unwrap
 
 /**
  * Makes a channel from a managed that returns a channel in case of success.
@@ -2037,9 +2054,9 @@ export const unwrap: <R2, InErr, InElem, InDone, OutErr, OutElem, OutDone, E, R>
  * @since 2.0.0
  * @category constructors
  */
-export const unwrapScoped: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, E, R>(
-  self: Effect.Effect<Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, E, R>
-) => Channel<Env | Exclude<R, Scope.Scope>, InErr, InElem, InDone, E | OutErr, OutElem, OutDone> = channel.unwrapScoped
+export const unwrapScoped: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, E, R>(
+  self: Effect.Effect<Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, E, R>
+) => Channel<OutElem, InElem, E | OutErr, InErr, OutDone, InDone, Env | Exclude<R, Scope.Scope>> = channel.unwrapScoped
 
 /**
  * Updates a service in the context of this channel.
@@ -2051,14 +2068,14 @@ export const updateService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ): <R, InErr, InDone, OutElem, OutErr, OutDone>(
-    self: Channel<R, InErr, unknown, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<T | R, InErr, unknown, InDone, OutErr, OutElem, OutDone>
-  <R, InErr, InDone, OutElem, OutErr, OutDone, T extends Context.Tag<any, any>>(
-    self: Channel<R, InErr, unknown, InDone, OutErr, OutElem, OutDone>,
+  ): <OutElem, OutErr, InErr, OutDone, InDone, R>(
+    self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>
+  ) => Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, T | R>
+  <OutElem, OutErr, InErr, OutDone, InDone, R, T extends Context.Tag<any, any>>(
+    self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
     tag: T,
     f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ): Channel<R | T, InErr, unknown, InDone, OutErr, OutElem, OutDone>
+  ): Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | T>
 } = channel.updateService
 
 /**
@@ -2076,12 +2093,12 @@ export const withSpan: {
       readonly parent?: Tracer.ParentSpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
-    }
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    } | undefined
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     name: string,
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
@@ -2089,8 +2106,8 @@ export const withSpan: {
       readonly parent?: Tracer.ParentSpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
-    }
-  ): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    } | undefined
+  ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
 } = channel.withSpan
 
 /**
@@ -2099,8 +2116,7 @@ export const withSpan: {
  * @since 2.0.0
  * @category constructors
  */
-export const write: <OutElem>(out: OutElem) => Channel<never, unknown, unknown, unknown, never, OutElem, void> =
-  core.write
+export const write: <OutElem>(out: OutElem) => Channel<OutElem> = core.write
 
 /**
  * Writes a sequence of values to the channel.
@@ -2110,7 +2126,7 @@ export const write: <OutElem>(out: OutElem) => Channel<never, unknown, unknown,
  */
 export const writeAll: <OutElems extends Array<any>>(
   ...outs: OutElems
-) => Channel<never, unknown, unknown, unknown, never, OutElems[number], void> = channel.writeAll
+) => Channel<OutElems[number]> = channel.writeAll
 
 /**
  * Writes a `Chunk` of values to the channel.
@@ -2120,7 +2136,7 @@ export const writeAll: <OutElems extends Array<any>>(
  */
 export const writeChunk: <OutElem>(
   outs: Chunk.Chunk<OutElem>
-) => Channel<never, unknown, unknown, unknown, never, OutElem, void> = channel.writeChunk
+) => Channel<OutElem> = channel.writeChunk
 
 /**
  * Returns a new channel that is the sequential composition of this channel
@@ -2131,36 +2147,32 @@ export const writeChunk: <OutElem>(
  * @category zipping
  */
 export const zip: {
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
+    options?: { readonly concurrent?: boolean | undefined } | undefined
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    readonly [OutDone, OutDone1]
+    InErr & InErr1,
+    readonly [OutDone, OutDone1],
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
+    options?: { readonly concurrent?: boolean | undefined } | undefined
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    readonly [OutDone, OutDone1]
+    InErr & InErr1,
+    readonly [OutDone, OutDone1],
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.zip
 
@@ -2173,36 +2185,32 @@ export const zip: {
  * @category zipping
  */
 export const zipLeft: {
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
-  ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
+    options?: { readonly concurrent?: boolean | undefined } | undefined
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone
+    InErr & InErr1,
+    OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-    options?: {
-      readonly concurrent?: boolean | undefined
-    }
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
+    options?: { readonly concurrent?: boolean | undefined } | undefined
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone
+    InErr & InErr1,
+    OutDone,
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.zipLeft
 
@@ -2216,35 +2224,35 @@ export const zipLeft: {
  */
 export const zipRight: {
   <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
   ): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env1 | Env
   >
   <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+    self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    that: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
   ): Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >
 } = channel.zipRight
 
diff --git a/packages/effect/src/Sink.ts b/packages/effect/src/Sink.ts
index f371b0c086..7fb2b07cd3 100644
--- a/packages/effect/src/Sink.ts
+++ b/packages/effect/src/Sink.ts
@@ -981,7 +981,7 @@ export const flatMap: {
  * @category constructors
  */
 export const fromChannel: <R, E, In, L, Z>(
-  channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
+  channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R>
 ) => Sink<R, E, In, L, Z> = internal.fromChannel
 
 /**
@@ -992,7 +992,7 @@ export const fromChannel: <R, E, In, L, Z>(
  */
 export const toChannel: <R, E, In, L, Z>(
   self: Sink<R, E, In, L, Z>
-) => Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z> = internal.toChannel
+) => Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R> = internal.toChannel
 
 /**
  * Creates a single-value sink produced from an effect.
diff --git a/packages/effect/src/Stream.ts b/packages/effect/src/Stream.ts
index 1d1ca393d6..d4a76893f7 100644
--- a/packages/effect/src/Stream.ts
+++ b/packages/effect/src/Stream.ts
@@ -1424,7 +1424,7 @@ export const fromAsyncIterable: <A, E>(iterable: AsyncIterable<A>, onError: (e:
  * @category constructors
  */
 export const fromChannel: <A, E, R>(
-  channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
+  channel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>
 ) => Stream<A, E, R> = internal.fromChannel
 
 /**
@@ -1435,7 +1435,7 @@ export const fromChannel: <A, E, R>(
  */
 export const toChannel: <A, E, R>(
   stream: Stream<A, E, R>
-) => Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> = internal.toChannel
+) => Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R> = internal.toChannel
 
 /**
  * Creates a stream from a `Chunk` of values.
@@ -2522,11 +2522,11 @@ export const pipeThrough: {
  */
 export const pipeThroughChannel: {
   <R2, E, E2, A, A2>(
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R2 | R>
   <R, R2, E, E2, A, A2>(
     self: Stream<A, E, R>,
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): Stream<A2, E2, R | R2>
 } = internal.pipeThroughChannel
 
@@ -2539,11 +2539,11 @@ export const pipeThroughChannel: {
  */
 export const pipeThroughChannelOrFail: {
   <R2, E, E2, A, A2>(
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): <R>(self: Stream<A, E, R>) => Stream<A2, E | E2, R2 | R>
   <R, R2, E, E2, A, A2>(
     self: Stream<A, E, R>,
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): Stream<A2, E | E2, R | R2>
 } = internal.pipeThroughChannelOrFail
 
diff --git a/packages/effect/src/internal/channel.ts b/packages/effect/src/internal/channel.ts
index 08ac577962..6b3e504ca1 100644
--- a/packages/effect/src/internal/channel.ts
+++ b/packages/effect/src/internal/channel.ts
@@ -35,11 +35,11 @@ import * as ChannelStateOpCodes from "./opCodes/channelState.js"
 import * as tracer from "./tracer.js"
 
 /** @internal */
-export const acquireUseRelease = <Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone, Acquired>(
+export const acquireUseRelease = <Acquired, OutErr, Env, OutElem1, InElem, InErr, OutDone, InDone>(
   acquire: Effect.Effect<Acquired, OutErr, Env>,
-  use: (a: Acquired) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>,
+  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<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone> =>
+): Channel.Channel<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env> =>
   core.flatMap(
     core.fromEffect(
       Ref.make<
@@ -65,37 +65,37 @@ export const acquireUseRelease = <Env, InErr, InElem, InDone, OutErr, OutElem1,
 export const as = dual<
   <OutDone2>(
     value: OutDone2
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2> => map(self, () => value))
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env> => map(self, () => value))
 
 /** @internal */
-export const asUnit = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, void> => map(self, constVoid)
+export const asUnit = <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 = <InErr, InElem, InDone>(
+export const buffer = <InElem, InErr, InDone>(
   options: {
     readonly empty: InElem
     readonly isEmpty: Predicate<InElem>
     readonly ref: Ref.Ref<InElem>
   }
-): Channel.Channel<never, InErr, InElem, InDone, InErr, InElem, InDone> =>
-  core.suspend<never, InErr, InElem, InDone, InErr, InElem, InDone>(() => {
+): 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<never, InErr, InElem, InDone, InErr, InElem, InDone> =>
+    ): Channel.Channel<InElem, InElem, InErr, InErr, InDone, InDone> =>
       unwrap(
         Ref.modify(ref, (inElem) =>
           isEmpty(inElem) ?
@@ -123,10 +123,10 @@ export const buffer = <InErr, InElem, InDone>(
   })
 
 /** @internal */
-export const bufferChunk = <InErr, InElem, InDone>(
+export const bufferChunk = <InElem, InErr, InDone>(
   ref: Ref.Ref<Chunk.Chunk<InElem>>
-): Channel.Channel<never, InErr, Chunk.Chunk<InElem>, InDone, InErr, Chunk.Chunk<InElem>, InDone> =>
-  buffer<InErr, Chunk.Chunk<InElem>, InDone>({
+): Channel.Channel<Chunk.Chunk<InElem>, Chunk.Chunk<InElem>, InErr, InErr, InDone, InDone> =>
+  buffer({
     empty: Chunk.empty(),
     isEmpty: Chunk.isEmpty,
     ref
@@ -134,44 +134,44 @@ export const bufferChunk = <InErr, InElem, InDone>(
 
 /** @internal */
 export const catchAll = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    f: (error: OutErr) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-  ) => <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (error: OutErr) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   2,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (error: OutErr) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <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<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   > =>
     core.catchAllCause(self, (cause) =>
       Either.match(Cause.failureOrCause(cause), {
@@ -182,60 +182,60 @@ export const catchAll = dual<
 
 /** @internal */
 export const concatMap = dual<
-  <OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>(
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
   ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    unknown
+    InErr & InErr2,
+    unknown,
+    InDone & InDone2,
+    Env2 | Env
   >,
   <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    unknown
+    InErr & InErr2,
+    unknown,
+    InDone & InDone2,
+    Env2 | Env
   >
 >(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+  f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
 ): Channel.Channel<
-  Env | Env2,
-  InErr & InErr2,
+  OutElem2,
   InElem & InElem2,
-  InDone & InDone2,
   OutErr | OutErr2,
-  OutElem2,
-  unknown
+  InErr & InErr2,
+  unknown,
+  InDone & InDone2,
+  Env | Env2
 > => core.concatMapWith(self, f, () => void 0, () => void 0))
 
 /** @internal */
 export const collect = dual<
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(
+  <OutElem, OutElem2>(
     pf: (o: OutElem) => Option.Option<OutElem2>
-  ) => (
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone> => {
-  const collector: Channel.Channel<Env, OutErr, OutElem, OutDone, OutErr, OutElem2, OutDone> = core
+): 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), {
@@ -249,34 +249,34 @@ export const collect = dual<
 })
 
 /** @internal */
-export const concatOut = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
+export const concatOut = <OutElem, InElem, OutErr, InErr, InDone, Env, OutDone>(
   self: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown> => core.concatAll(self)
+): Channel.Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env> => core.concatAll(self)
 
 /** @internal */
 export const mapInput = dual<
   <InDone0, InDone>(
     f: (a: InDone0) => InDone
-  ) => <Env, InErr, InElem, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>,
-  <Env, InErr, InElem, OutErr, OutElem, OutDone, InDone0, InDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
->(2, <Env, InErr, InElem, OutErr, OutElem, OutDone, InDone0, InDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<never, InErr, InElem, InDone0, InErr, InElem, InDone> = core.readWith({
+): 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))
@@ -286,20 +286,20 @@ export const mapInput = dual<
 
 /** @internal */
 export const mapInputEffect = dual<
-  <Env1, InErr, InDone0, InDone>(
+  <InDone0, InDone, InErr, Env1>(
     f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
-  ) => <Env, InElem, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>,
-  <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr, InDone0, InDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
->(2, <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr, InDone0, InDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr, InElem, InDone0, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<Env1, InErr, InElem, InDone0, InErr, InElem, InDone> = core.readWith({
+): 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))
@@ -311,18 +311,18 @@ export const mapInputEffect = dual<
 export const mapInputError = dual<
   <InErr0, InErr>(
     f: (a: InErr0) => InErr
-  ) => <Env, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InElem, InDone, OutErr, OutElem, OutDone, InErr0, InErr>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
->(2, <Env, InElem, InDone, OutErr, OutElem, OutDone, InErr0, InErr>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<never, InErr0, InElem, InDone, InErr, InElem, InDone> = core.readWith({
+): 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
@@ -332,20 +332,20 @@ export const mapInputError = dual<
 
 /** @internal */
 export const mapInputErrorEffect = dual<
-  <Env1, InErr0, InErr, InDone>(
+  <InErr0, InDone, InErr, Env1>(
     f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
-  ) => <Env, InElem, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr0, InErr, InDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
->(2, <Env, InElem, OutErr, OutElem, OutDone, Env1, InErr0, InErr, InDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr0, InElem, InDone, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<Env1, InErr0, InElem, InDone, InErr, InElem, InDone> = core.readWith({
+): 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
@@ -357,18 +357,18 @@ export const mapInputErrorEffect = dual<
 export const mapInputIn = dual<
   <InElem0, InElem>(
     f: (a: InElem0) => InElem
-  ) => <Env, InErr, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>,
-  <Env, InErr, InDone, OutErr, OutElem, OutDone, InElem0, InElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
->(2, <Env, InErr, InDone, OutErr, OutElem, OutDone, InElem0, InElem>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<never, InErr, InElem0, InDone, InErr, InElem, InDone> = core.readWith({
+): 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
@@ -378,20 +378,20 @@ export const mapInputIn = dual<
 
 /** @internal */
 export const mapInputInEffect = dual<
-  <Env1, InErr, InElem0, InElem>(
+  <InElem0, InElem, InErr, Env1>(
     f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
-  ) => <Env, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>,
-  <Env, InDone, OutErr, OutElem, OutDone, Env1, InErr, InElem0, InElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
->(2, <Env, InDone, OutErr, OutElem, OutDone, Env1, InErr, InElem0, InElem>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr, InElem0, InDone, OutErr, OutElem, OutDone> => {
-  const reader: Channel.Channel<Env1, InErr, InElem0, InDone, InErr, InElem, InDone> = core.readWith({
+): 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
@@ -400,17 +400,9 @@ export const mapInputInEffect = dual<
 })
 
 /** @internal */
-export const doneCollect = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  never,
-  [Chunk.Chunk<OutElem>, OutDone]
-> =>
+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(
@@ -422,7 +414,7 @@ export const doneCollect = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone
 /** @internal */
 const doneCollectReader = <Env, OutErr, OutElem, OutDone>(
   builder: Array<OutElem>
-): Channel.Channel<Env, OutErr, OutElem, OutDone, OutErr, never, OutDone> => {
+): Channel.Channel<never, OutElem, OutErr, OutErr, OutDone, OutDone, Env> => {
   return core.readWith({
     onInput: (outElem) =>
       core.flatMap(
@@ -437,10 +429,10 @@ const doneCollectReader = <Env, OutErr, OutElem, OutDone>(
 }
 
 /** @internal */
-export const drain = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, never, OutDone> => {
-  const drainer: Channel.Channel<Env, OutErr, OutElem, OutDone, OutErr, never, OutDone> = core
+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,
@@ -450,214 +442,207 @@ export const drain = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 }
 
 /** @internal */
-export const emitCollect = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, [Chunk.Chunk<OutElem>, OutDone], void> =>
+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<
-  <Env1, Z>(
+  <Z, Env1>(
     finalizer: Effect.Effect<Z, never, Env1>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, Z>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env1 | Env>
 >(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, Z>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   finalizer: Effect.Effect<Z, never, Env1>
-): Channel.Channel<Env | Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone> =>
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env1> =>
   core.ensuringWith(self, () => finalizer))
 
 /** @internal */
-export const context = <Env>(): Channel.Channel<
-  Env,
-  unknown,
-  unknown,
-  unknown,
-  never,
-  never,
-  Context.Context<Env>
-> => core.fromEffect(Effect.context<Env>())
+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<Env, unknown, unknown, unknown, never, never, OutDone> => map(context<Env>(), f)
+): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, Env> => map(context<Env>(), f)
 
 /** @internal */
 export const contextWithChannel = <
   Env,
-  Env1,
-  InErr,
+  OutElem,
   InElem,
-  InDone,
   OutErr,
-  OutElem,
-  OutDone
+  InErr,
+  OutDone,
+  InDone,
+  Env1
 >(
-  f: (env: Context.Context<Env>) => Channel.Channel<Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<Env | Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone> => core.flatMap(context<Env>(), f)
+  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, Env1, OutErr, OutDone>(
+export const contextWithEffect = <Env, OutDone, OutErr, Env1>(
   f: (env: Context.Context<Env>) => Effect.Effect<OutDone, OutErr, Env1>
-): Channel.Channel<Env | Env1, unknown, unknown, unknown, OutErr, never, OutDone> => mapEffect(context<Env>(), f)
+): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Env1> => mapEffect(context<Env>(), f)
 
 /** @internal */
 export const flatten = <
-  Env,
-  InErr,
+  OutElem,
   InElem,
-  InDone,
   OutErr,
-  OutElem,
-  Env1,
-  InErr1,
+  InErr,
+  OutElem1,
   InElem1,
-  InDone1,
   OutErr1,
-  OutElem1,
-  OutDone2
+  InErr1,
+  OutDone2,
+  InDone1,
+  Env1,
+  InDone,
+  Env
 >(
   self: Channel.Channel<
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
+    InErr,
+    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>,
+    InDone,
+    Env
   >
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem | OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem | OutElem1,
-  OutDone2
+  InErr & InErr1,
+  OutDone2,
+  InDone & InDone1,
+  Env | Env1
 > => core.flatMap(self, identity)
 
 /** @internal */
 export const foldChannel = dual<
   <
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
-    InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
     OutErr,
-    OutErr1,
-    OutErr2,
     OutElem1,
-    OutElem2,
-    OutDone,
+    InElem1,
+    OutErr1,
+    InErr1,
     OutDone1,
-    OutDone2
+    InDone1,
+    Env1,
+    OutDone,
+    OutElem2,
+    InElem2,
+    OutErr2,
+    InErr2,
+    OutDone2,
+    InDone2,
+    Env2
   >(
     options: {
       readonly onFailure: (
         error: OutErr
-      ) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      ) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
       readonly onSuccess: (
         done: OutDone
-      ) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone2>
+      ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
     }
   ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr1 | OutErr2,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone1 | OutDone2
+    InErr & InErr1 & InErr2,
+    OutDone1 | OutDone2,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
+    Env,
+    OutElem1,
     InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
-    OutErr,
     OutErr1,
-    OutErr2,
-    OutElem1,
-    OutElem2,
-    OutDone,
+    InErr1,
     OutDone1,
-    OutDone2
+    InDone1,
+    Env1,
+    OutElem2,
+    InElem2,
+    OutErr2,
+    InErr2,
+    OutDone2,
+    InDone2,
+    Env2
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
       readonly onFailure: (
         error: OutErr
-      ) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      ) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
       readonly onSuccess: (
         done: OutDone
-      ) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone2>
+      ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>
     }
   ) => Channel.Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr1 | OutErr2,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone1 | OutDone2
+    InErr & InErr1 & InErr2,
+    OutDone1 | OutDone2,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >
 >(2, <
-  Env,
-  InErr,
+  OutElem,
   InElem,
+  OutErr,
+  InErr,
+  OutDone,
   InDone,
-  OutElem,
-  Env1,
-  Env2,
-  InErr1,
-  InErr2,
+  Env,
+  OutElem1,
   InElem1,
-  InElem2,
-  InDone1,
-  InDone2,
-  OutErr,
   OutErr1,
-  OutErr2,
-  OutElem1,
-  OutElem2,
-  OutDone,
+  InErr1,
   OutDone1,
-  OutDone2
+  InDone1,
+  Env1,
+  OutElem2,
+  InElem2,
+  OutErr2,
+  InErr2,
+  OutDone2,
+  InDone2,
+  Env2
 >(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   options: {
-    readonly onFailure: (error: OutErr) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-    readonly onSuccess: (done: OutDone) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone2>
+    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<
-  Env | Env1 | Env2,
-  InErr & InErr1 & InErr2,
+  OutElem | OutElem2 | OutElem1,
   InElem & InElem1 & InElem2,
-  InDone & InDone1 & InDone2,
   OutErr2 | OutErr1,
-  OutElem | OutElem2 | OutElem1,
-  OutDone2 | OutDone1
+  InErr & InErr1 & InErr2,
+  OutDone2 | OutDone1,
+  InDone & InDone1 & InDone2,
+  Env | Env1 | Env2
 > =>
   core.foldCauseChannel(self, {
     onFailure: (cause) => {
@@ -677,13 +662,13 @@ export const foldChannel = dual<
 /** @internal */
 export const fromEither = <E, A>(
   either: Either.Either<E, A>
-): Channel.Channel<never, unknown, unknown, unknown, E, never, A> =>
+): Channel.Channel<never, unknown, E, unknown, A, 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<never, unknown, unknown, unknown, Err, Elem, Done> =>
+): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
   unwrap(
     input.takeWith(
       core.failCause,
@@ -693,21 +678,21 @@ export const fromInput = <Err, Elem, Done>(
   )
 
 /** @internal */
-export const fromPubSub = <Err, Done, Elem>(
+export const fromPubSub = <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, unknown, unknown, unknown, Err, Elem, Done> =>
+): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
   unwrapScoped(Effect.map(PubSub.subscribe(pubsub), fromQueue))
 
 /** @internal */
-export const fromPubSubScoped = <Err, Done, Elem>(
+export const fromPubSubScoped = <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Effect.Effect<Channel.Channel<never, unknown, unknown, unknown, Err, Elem, Done>, never, Scope.Scope> =>
+): 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, unknown, unknown, Option.Option<never>, never, A> =>
+): Channel.Channel<never, unknown, Option.Option<never>, unknown, A, unknown> =>
   core.suspend(() =>
     Option.match(option, {
       onNone: () => core.fail(Option.none()),
@@ -716,14 +701,14 @@ export const fromOption = <A>(
   )
 
 /** @internal */
-export const fromQueue = <Err, Elem, Done>(
+export const fromQueue = <Done, Err, Elem>(
   queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, unknown, unknown, unknown, Err, Elem, Done> => core.suspend(() => fromQueueInternal(queue))
+): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> => core.suspend(() => fromQueueInternal(queue))
 
 /** @internal */
-const fromQueueInternal = <Err, Elem, Done>(
+const fromQueueInternal = <Done, Err, Elem>(
   queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, unknown, unknown, unknown, Err, Elem, Done> =>
+): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
   pipe(
     core.fromEffect(Queue.take(queue)),
     core.flatMap(Either.match({
@@ -734,42 +719,34 @@ const fromQueueInternal = <Err, Elem, Done>(
       onRight: (elem) =>
         core.flatMap(
           core.write(elem),
-          () => fromQueueInternal<Err, Elem, Done>(queue)
+          () => fromQueueInternal(queue)
         )
     }))
   )
 
 /** @internal */
-export const identityChannel = <Err, Elem, Done>(): Channel.Channel<never, Err, Elem, Done, Err, Elem, Done> =>
+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<Err, Elem, Done>()),
+    onInput: (input: Elem) => core.flatMap(core.write(input), () => identityChannel()),
     onFailure: core.fail,
     onDone: core.succeedNow
   })
 
 /** @internal */
 export const interruptWhen = dual<
-  <Env1, OutErr1, OutDone1>(
+  <OutDone1, OutErr1, Env1>(
     effect: Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, OutErr1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, OutErr1, OutDone1>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<
-  Env1 | Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr | OutErr1,
-  OutElem,
-  OutDone | OutDone1
-> =>
+): 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)),
@@ -778,104 +755,104 @@ export const interruptWhen = dual<
 
 /** @internal */
 export const interruptWhenDeferred = dual<
-  <OutErr1, OutDone1>(
+  <OutDone1, OutErr1>(
     deferred: Deferred.Deferred<OutDone1, OutErr1>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutErr1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1 | OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr1 | OutErr, InErr, OutDone1 | OutDone, InDone, Env>
 >(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutErr1, OutDone1>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   deferred: Deferred.Deferred<OutDone1, OutErr1>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone | OutDone1> =>
+): 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
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
 >(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   f: (out: OutDone) => OutDone2
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2> =>
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env> =>
   core.flatMap(self, (a) => core.sync(() => f(a))))
 
 /** @internal */
 export const mapEffect = dual<
-  <Env1, OutErr1, OutDone, OutDone1>(
+  <OutDone, OutDone1, OutErr1, Env1>(
     f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, Env1, OutErr1, OutDone, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem, OutDone1>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, Env1, OutErr1, OutDone, OutDone1>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone1> =>
+): 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
-  ) => <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
->(2, <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone> => mapErrorCause(self, Cause.map(f)))
+): 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>
-  ) => <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>
->(2, <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr, OutErr2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone> =>
+): 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
-  ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>
->(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone> => {
-  const reader: Channel.Channel<Env, OutErr, OutElem, OutDone, OutErr, OutElem2, OutDone> = core
+): 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,
@@ -886,20 +863,20 @@ export const mapOut = dual<
 
 /** @internal */
 export const mapOutEffect = dual<
-  <OutElem, Env1, OutErr1, OutElem1>(
+  <OutElem, OutElem1, OutErr1, Env1>(
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>
->(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone> => {
-  const reader: Channel.Channel<Env | Env1, OutErr, OutElem, OutDone, OutErr | OutErr1, OutElem1, OutDone> = core
+): 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(
@@ -915,22 +892,22 @@ export const mapOutEffect = dual<
 
 /** @internal */
 export const mapOutEffectPar = dual<
-  <OutElem, Env1, OutErr1, OutElem1>(
+  <OutElem, OutElem1, OutErr1, Env1>(
     f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>,
     n: number
-  ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>
->(3, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, OutErr1, OutElem1>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone> =>
+): Channel.Channel<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1> =>
   pipe(
     Effect.gen(function*($) {
       const queue = yield* $(
@@ -1000,15 +977,7 @@ export const mapOutEffectPar = dual<
       return queue
     }),
     Effect.map((queue) => {
-      const consumer: Channel.Channel<
-        Env1,
-        unknown,
-        unknown,
-        unknown,
-        OutErr | OutErr1,
-        OutElem1,
-        OutDone
-      > = unwrap(
+      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({
@@ -1031,104 +1000,104 @@ export const mergeAll = (
   }
 ) => {
   return <
-    Env,
-    Env1,
-    InErr,
-    InErr1,
-    InElem,
+    OutElem,
     InElem1,
-    InDone,
+    OutErr1,
+    InErr1,
     InDone1,
+    Env1,
+    InElem,
     OutErr,
-    OutErr1,
-    OutElem
+    InErr,
+    InDone,
+    Env
   >(
     channels: Channel.Channel<
-      Env,
-      InErr,
+      Channel.Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>,
-      unknown
+      InErr,
+      unknown,
+      InDone,
+      Env
     >
   ): Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem,
-    unknown
+    InErr & InErr1,
+    unknown,
+    InDone & InDone1,
+    Env | Env1
   > => mergeAllWith(options)(channels, constVoid)
 }
 
 /** @internal */
 export const mergeAllUnbounded = <
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
+  OutElem,
   InElem1,
-  InDone,
+  OutErr1,
+  InErr1,
   InDone1,
+  Env1,
+  InElem,
   OutErr,
-  OutErr1,
-  OutElem
+  InErr,
+  InDone,
+  Env
 >(
   channels: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>,
-    unknown
+    InErr,
+    unknown,
+    InDone,
+    Env
   >
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem,
-  unknown
+  InErr & InErr1,
+  unknown,
+  InDone & InDone1,
+  Env | Env1
 > => mergeAllWith({ concurrency: "unbounded" })(channels, constVoid)
 
 /** @internal */
 export const mergeAllUnboundedWith = <
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
+  OutElem,
   InElem1,
-  InDone,
+  OutErr1,
+  InErr1,
+  OutDone,
   InDone1,
+  Env1,
+  InElem,
   OutErr,
-  OutErr1,
-  OutElem,
-  OutDone
+  InErr,
+  InDone,
+  Env
 >(
   channels: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >,
   f: (o1: OutDone, o2: OutDone) => OutDone
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem,
-  OutDone
+  InErr & InErr1,
+  OutDone,
+  InDone & InDone1,
+  Env | Env1
 > => mergeAllWith({ concurrency: "unbounded" })(channels, f)
 
 /** @internal */
@@ -1143,38 +1112,25 @@ export const mergeAllWith = (
     readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined
   }
 ) =>
-<
-  Env,
-  Env1,
-  InErr,
-  InErr1,
-  InElem,
-  InElem1,
-  InDone,
-  InDone1,
-  OutErr,
-  OutErr1,
-  OutElem,
-  OutDone
->(
+<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
   channels: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >,
   f: (o1: OutDone, o2: OutDone) => OutDone
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem,
-  OutDone
+  InErr & InErr1,
+  OutDone,
+  InDone & InDone1,
+  Env | Env1
 > =>
   pipe(
     Effect.gen(function*($) {
@@ -1335,15 +1291,7 @@ export const mergeAllWith = (
       return [queue, input] as const
     }),
     Effect.map(([queue, input]) => {
-      const consumer: Channel.Channel<
-        Env | Env1,
-        unknown,
-        unknown,
-        unknown,
-        OutErr | OutErr1,
-        OutElem,
-        OutDone
-      > = pipe(
+      const consumer: Channel.Channel<OutElem, unknown, OutErr | OutErr1, unknown, OutDone, unknown, Env | Env1> = pipe(
         Queue.take(queue),
         Effect.flatten,
         Effect.matchCause({
@@ -1362,121 +1310,121 @@ export const mergeAllWith = (
 
 /** @internal */
 export const mergeMap = dual<
-  <OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(
-    f: (outElem: OutElem) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
+  <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
     }
-  ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => <InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1,
-    unknown
+    InErr & InErr1,
+    unknown,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (outElem: OutElem) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1,
-    unknown
+    InErr & InErr1,
+    unknown,
+    InDone & InDone1,
+    Env1 | Env
   >
->(3, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  f: (outElem: OutElem) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
+>(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<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem1,
-  unknown
+  InErr & InErr1,
+  unknown,
+  InDone & InDone1,
+  Env | Env1
 > => mergeAll(options)(mapOut(self, f)))
 
 /** @internal */
 export const mergeOut = dual<
   (
     n: number
-  ) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(
+  ) => <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<
-      Env,
-      InErr,
+      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
-      OutDone
+      InErr,
+      OutDone,
+      InDone,
+      Env
     >
   ) => Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem1,
-    unknown
+    InErr & InErr1,
+    unknown,
+    InDone & InDone1,
+    Env | Env1
   >,
-  <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(
+  <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<
-      Env,
-      InErr,
+      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
-      OutDone
+      InErr,
+      OutDone,
+      InDone,
+      Env
     >,
     n: number
   ) => Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem1,
-    unknown
+    InErr & InErr1,
+    unknown,
+    InDone & InDone1,
+    Env | Env1
   >
->(2, <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(
+>(2, <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>,
-    OutDone
+    InErr,
+    OutDone,
+    InDone,
+    Env
   >,
   n: number
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem1,
-  unknown
+  InErr & InErr1,
+  unknown,
+  InDone & InDone1,
+  Env | Env1
 > => mergeAll({ concurrency: n })(mapOut(self, identity)))
 
 /** @internal */
@@ -1484,73 +1432,73 @@ export const mergeOutWith = dual<
   <OutDone1>(
     n: number,
     f: (o1: OutDone1, o2: OutDone1) => OutDone1
-  ) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1>(
+  ) => <OutElem1, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
     self: Channel.Channel<
-      Env,
-      InErr,
+      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-      OutDone1
+      InErr,
+      OutDone1,
+      InDone,
+      Env
     >
   ) => Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem1,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >,
-  <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
     self: Channel.Channel<
-      Env,
-      InErr,
+      Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
       InElem,
-      InDone,
       OutErr,
-      Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-      OutDone1
+      InErr,
+      OutDone1,
+      InDone,
+      Env
     >,
     n: number,
     f: (o1: OutDone1, o2: OutDone1) => OutDone1
   ) => Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem1,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env | Env1
   >
->(3, <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
+>(3, <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(
   self: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
-    OutDone1
+    InErr,
+    OutDone1,
+    InDone,
+    Env
   >,
   n: number,
   f: (o1: OutDone1, o2: OutDone1) => OutDone1
 ): Channel.Channel<
-  Env | Env1,
-  InErr & InErr1,
+  OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr | OutErr1,
-  OutElem1,
-  OutDone1
+  InErr & InErr1,
+  OutDone1,
+  InDone & InDone1,
+  Env | Env1
 > => mergeAllWith({ concurrency: n })(mapOut(self, identity), f))
 
 /** @internal */
 export const mergeWith = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutErr2, OutErr3, OutElem1, OutDone, OutDone1, OutDone2, OutDone3>(
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutDone, OutErr, OutErr2, OutDone2, OutErr3, OutDone3>(
     options: {
-      readonly other: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      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>
@@ -1559,39 +1507,39 @@ export const mergeWith = dual<
       ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
     }
   ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1,
+    OutDone2 | OutDone3,
+    InDone & InDone1,
+    Env1 | Env
   >,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    InErr1,
+    Env,
+    OutElem1,
     InElem1,
-    InDone1,
-    OutErr,
     OutErr1,
-    OutErr2,
-    OutErr3,
-    OutElem1,
-    OutDone,
+    InErr1,
     OutDone1,
+    InDone1,
+    Env1,
+    OutErr2,
     OutDone2,
+    OutErr3,
     OutDone3
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
-      readonly other: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+      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>
@@ -1600,37 +1548,37 @@ export const mergeWith = dual<
       ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
     }
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1,
+    OutDone2 | OutDone3,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(2, <
-  Env,
-  InErr,
+  OutElem,
   InElem,
+  OutErr,
+  InErr,
+  OutDone,
   InDone,
-  OutElem,
-  Env1,
-  InErr1,
+  Env,
+  OutElem1,
   InElem1,
-  InDone1,
-  OutErr,
   OutErr1,
-  OutErr2,
-  OutErr3,
-  OutElem1,
-  OutDone,
+  InErr1,
   OutDone1,
+  InDone1,
+  Env1,
+  OutErr2,
   OutDone2,
+  OutErr3,
   OutDone3
 >(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   options: {
-    readonly other: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+    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>
@@ -1639,13 +1587,13 @@ export const mergeWith = dual<
     ) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>
   }
 ): Channel.Channel<
-  Env1 | Env,
-  InErr & InErr1,
+  OutElem | OutElem1,
   InElem & InElem1,
-  InDone & InDone1,
   OutErr2 | OutErr3,
-  OutElem | OutElem1,
-  OutDone2 | OutDone3
+  InErr & InErr1,
+  OutDone2 | OutDone3,
+  InDone & InDone1,
+  Env1 | Env
 > =>
   unwrapScoped(
     Effect.flatMap(
@@ -1699,13 +1647,13 @@ export const mergeWith = dual<
               ) => State
             ): Effect.Effect<
               Channel.Channel<
-                Env | Env1,
+                OutElem | OutElem1,
                 unknown,
+                OutErr2 | OutErr3,
                 unknown,
+                OutDone2 | OutDone3,
                 unknown,
-                OutErr2 | OutErr3,
-                OutElem | OutElem1,
-                OutDone2 | OutDone3
+                Env | Env1
               >,
               never,
               Env | Env1
@@ -1720,13 +1668,13 @@ export const mergeWith = dual<
                 >
               ): Effect.Effect<
                 Channel.Channel<
-                  Env | Env1,
+                  OutElem | OutElem1,
                   unknown,
+                  OutErr2 | OutErr3,
                   unknown,
+                  OutDone2 | OutDone3,
                   unknown,
-                  OutErr2 | OutErr3,
-                  OutElem | OutElem1,
-                  OutDone2 | OutDone3
+                  Env | Env1
                 >
               > => {
                 const op = decision as mergeDecision.Primitive
@@ -1771,13 +1719,13 @@ export const mergeWith = dual<
             const go = (
               state: State
             ): Channel.Channel<
-              Env | Env1,
+              OutElem | OutElem1,
               unknown,
+              OutErr2 | OutErr3,
               unknown,
+              OutDone2 | OutDone3,
               unknown,
-              OutErr2 | OutErr3,
-              OutElem | OutElem1,
-              OutDone2 | OutDone3
+              Env | Env1
             > => {
               switch (state._tag) {
                 case MergeStateOpCodes.OP_BOTH_RUNNING: {
@@ -1881,7 +1829,7 @@ export const mergeWith = dual<
   ))
 
 /** @internal */
-export const never: Channel.Channel<never, unknown, unknown, unknown, never, never, never> = core.fromEffect(
+export const never: Channel.Channel<never, unknown, never, unknown, never, unknown> = core.fromEffect(
   Effect.never
 )
 
@@ -1889,99 +1837,99 @@ export const never: Channel.Channel<never, unknown, unknown, unknown, never, nev
 export const orDie = dual<
   <E>(
     error: LazyArg<E>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, E>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, never, OutElem, OutDone>
->(2, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, E>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, never, OutElem, OutDone> => orDieWith(self, error))
+): Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env> => orDieWith(self, error))
 
 /** @internal */
 export const orDieWith = dual<
   <OutErr>(
     f: (e: OutErr) => unknown
-  ) => <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env, InErr, InElem, InDone, never, OutElem, OutDone>
->(2, <Env, InErr, InElem, InDone, OutElem, OutDone, OutErr>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env, InErr, InElem, InDone, never, OutElem, OutDone> =>
+): Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env> =>
   catchAll(self, (e) => {
     throw f(e)
-  }) as Channel.Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>)
+  }) as Channel.Channel<OutElem, InElem, never, InErr, OutDone, InDone, Env>)
 
 /** @internal */
 export const orElse = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: LazyArg<Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: LazyArg<Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>>
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    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<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: LazyArg<Channel.Channel<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<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   > => catchAll(self, that)
 )
 
 /** @internal */
 export const pipeToOrFail = dual<
-  <Env2, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    that: Channel.Channel<Env2, never, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ) => <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr2 | OutErr, OutElem2, OutDone2>,
-  <Env, InErr, InElem, InDone, OutErr, Env2, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env2, never, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr2 | OutErr, OutElem2, OutDone2>
->(2, <Env, InErr, InElem, InDone, OutErr, Env2, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  that: Channel.Channel<Env2, never, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr | OutErr2, OutElem2, OutDone2> =>
+  <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<Env, OutErr, OutElem, OutDone, never, OutElem, OutDone> = core
+    const reader: Channel.Channel<OutElem, OutElem, never, OutErr, OutDone, OutDone, Env> = core
       .readWith({
         onInput: (outElem) => core.flatMap(core.write(outElem), () => reader),
         onFailure: (outErr) => {
@@ -1992,13 +1940,13 @@ export const pipeToOrFail = dual<
       })
 
     const writer: Channel.Channel<
-      Env2,
-      OutErr2,
       OutElem2,
-      OutDone2,
-      OutErr2,
       OutElem2,
-      OutDone2
+      OutErr2,
+      OutErr2,
+      OutDone2,
+      OutDone2,
+      Env2
     > = core.readWithCause({
       onInput: (outElem) => pipe(core.write(outElem), core.flatMap(() => writer)),
       onFailure: (cause) =>
@@ -2018,19 +1966,19 @@ export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, T extends Context.Tag<any, any>>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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, Context.Tag.Identifier<T>>>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, T extends Context.Tag<any, any>>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     tag: T,
     service: Context.Tag.Service<T>
-  ) => Channel.Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone>
->(3, <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, T extends Context.Tag<any, any>>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>
+>(3, <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, T extends Context.Tag<any, any>>(
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
   tag: T,
   service: Context.Tag.Service<T>
-): Channel.Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>> => {
   return core.flatMap(
     context<any>(),
     (context) => core.provideContext(self, Context.add(context, tag, service))
@@ -2039,91 +1987,84 @@ export const provideService = dual<
 
 /** @internal */
 export const provideLayer = dual<
-  <Env0, Env, OutErr2>(
+  <Env, OutErr2, Env0>(
     layer: Layer.Layer<Env, OutErr2, Env0>
-  ) => <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env0, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>,
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env, OutErr2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env0, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>
->(2, <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env, OutErr2>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env0, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone> =>
+): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0> =>
   unwrapScoped(Effect.map(Layer.build(layer), (env) => core.provideContext(self, env))))
 
 /** @internal */
 export const mapInputContext = dual<
   <Env0, Env>(
     f: (env: Context.Context<Env0>) => Context.Context<Env>
-  ) => <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone>
->(2, <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => 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<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone> =>
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0> =>
   contextWithChannel((context: Context.Context<Env0>) => core.provideContext(self, f(context))))
 
 /** @internal */
 export const provideSomeLayer = dual<
-  <Env0, Env2, OutErr2>(
+  <Env2, OutErr2, Env0>(
     layer: Layer.Layer<Env2, OutErr2, Env0>
-  ) => <R, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<R, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>,
-  <R, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env2, OutErr2>(
-    self: Channel.Channel<R, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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, Env2>>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
     layer: Layer.Layer<Env2, OutErr2, Env0>
-  ) => Channel.Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr2 | OutErr, OutElem, OutDone>
->(2, <R, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env0, Env2, OutErr2>(
-  self: Channel.Channel<R, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
+>(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
   layer: Layer.Layer<Env2, OutErr2, Env0>
-): Channel.Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone> =>
+): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>> =>
   // @ts-expect-error
   provideLayer(self, Layer.merge(Layer.context<Exclude<R, Env2>>(), layer)))
 
 /** @internal */
-export const read = <In>(): Channel.Channel<
-  never,
-  unknown,
-  In,
-  unknown,
-  Option.Option<never>,
-  never,
-  In
-> => core.readOrFail<In, Option.Option<never>>(Option.none())
+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 = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> => core.flatMap(self, () => repeated(self))
+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 = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
+export const run = <OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env> => Effect.scoped(executor.runScoped(self))
 
 /** @internal */
-export const runCollect = <Env, InErr, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, OutElem, OutDone>
+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> => executor.run(core.collectElements(self))
 
 /** @internal */
-export const runDrain = <Env, InErr, InDone, OutElem, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, OutElem, OutDone>
+export const runDrain = <OutElem, OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env> => executor.run(drain(self))
 
 /** @internal */
 export const scoped = <A, E, R>(
   effect: Effect.Effect<A, E, R>
-): Channel.Channel<Exclude<R, Scope.Scope>, unknown, unknown, unknown, E, A, unknown> =>
+): Channel.Channel<A, unknown, E, unknown, unknown, unknown, Exclude<R, Scope.Scope>> =>
   unwrap(
     Effect.uninterruptibleMask((restore) =>
       Effect.map(Scope.make(), (scope) =>
@@ -2140,38 +2081,38 @@ export const scoped = <A, E, R>(
 /** @internal */
 export const service = <T extends Context.Tag<any, any>>(
   tag: T
-): Channel.Channel<Context.Tag.Identifier<T>, unknown, unknown, unknown, never, never, Context.Tag.Service<T>> =>
+): Channel.Channel<never, unknown, never, unknown, Context.Tag.Service<T>, unknown, Context.Tag.Identifier<T>> =>
   core.fromEffect(tag)
 
 /** @internal */
 export const serviceWith = <T extends Context.Tag<any, any>>(tag: T) =>
 <OutDone>(
   f: (resource: Context.Tag.Service<T>) => OutDone
-): Channel.Channel<Context.Tag.Identifier<T>, unknown, unknown, unknown, never, never, OutDone> => map(service(tag), f)
+): Channel.Channel<never, unknown, never, unknown, OutDone, unknown, Context.Tag.Identifier<T>> => map(service(tag), f)
 
 /** @internal */
 export const serviceWithChannel =
   <T extends Context.Tag<any, any>>(tag: T) =>
   <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    f: (resource: Context.Tag.Service<T>) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ): Channel.Channel<Env | Context.Tag.Identifier<T>, InErr, InElem, InDone, OutErr, OutElem, OutDone> =>
+    f: (resource: Context.Tag.Service<T>) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Context.Tag.Identifier<T>> =>
     core.flatMap(service(tag), f)
 
 /** @internal */
 export const serviceWithEffect = <T extends Context.Tag<any, any>>(tag: T) =>
 <Env, OutErr, OutDone>(
   f: (resource: Context.Tag.Service<T>) => Effect.Effect<OutDone, OutErr, Env>
-): Channel.Channel<Env | Context.Tag.Identifier<T>, unknown, unknown, unknown, OutErr, never, OutDone> =>
+): Channel.Channel<never, unknown, OutErr, unknown, OutDone, unknown, Env | Context.Tag.Identifier<T>> =>
   mapEffect(service(tag), f)
 
 /** @internal */
-export const toPubSub = <Err, Done, Elem>(
+export const toPubSub = <Done, Err, Elem>(
   pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, Err, Elem, Done, never, never, unknown> => toQueue(pubsub)
+): Channel.Channel<never, Elem, never, Err, unknown, Done> => toQueue(pubsub)
 
 /** @internal */
-export const toPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+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<OutDone, OutElem>, OutErr, Env>, never, Env | Scope.Scope> =>
   Effect.map(
     Effect.acquireRelease(
@@ -2187,7 +2128,7 @@ export const toPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 /** @internal */
 const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
   channelState: ChannelState.ChannelState<Env, OutErr>,
-  exec: executor.ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  exec: executor.ChannelExecutor<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env> => {
   const state = channelState as ChannelState.Primitive
   switch (state._tag) {
@@ -2218,14 +2159,14 @@ const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 }
 
 /** @internal */
-export const toQueue = <Err, Done, Elem>(
+export const toQueue = <Done, Err, Elem>(
   queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, Err, Elem, Done, never, never, unknown> => core.suspend(() => toQueueInternal(queue))
+): Channel.Channel<never, Elem, never, Err, unknown, Done> => core.suspend(() => toQueueInternal(queue))
 
 /** @internal */
 const toQueueInternal = <Err, Done, Elem>(
   queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
-): Channel.Channel<never, Err, Elem, Done, never, never, unknown> => {
+): Channel.Channel<never, Elem, never, Err, unknown, Done> => {
   return core.readWithCause({
     onInput: (elem) =>
       core.flatMap(
@@ -2238,14 +2179,14 @@ const toQueueInternal = <Err, Done, Elem>(
 }
 
 /** @internal */
-export const unwrap = <R2, InErr, InElem, InDone, OutErr, OutElem, OutDone, E, R>(
-  channel: Effect.Effect<Channel.Channel<R2, InErr, InElem, InDone, OutErr, OutElem, OutDone>, E, R>
-): Channel.Channel<R | R2, InErr, InElem, InDone, E | OutErr, OutElem, OutDone> => flatten(core.fromEffect(channel))
+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 = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, E, R>(
-  self: Effect.Effect<Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, E, R>
-): Channel.Channel<Env | Exclude<R, Scope.Scope>, InErr, InElem, InDone, E | OutErr, OutElem, OutDone> =>
+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,
@@ -2257,19 +2198,19 @@ export const updateService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => <R, InErr, InDone, OutElem, OutErr, OutDone>(
-    self: Channel.Channel<R, InErr, unknown, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<T | R, InErr, unknown, InDone, OutErr, OutElem, OutDone>,
-  <R, InErr, InDone, OutElem, OutErr, OutDone, T extends Context.Tag<any, any>>(
-    self: Channel.Channel<R, InErr, unknown, InDone, OutErr, OutElem, OutDone>,
+  ) => <OutElem, OutErr, InErr, OutDone, InDone, R>(
+    self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>
+  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, T | R>,
+  <OutElem, OutErr, InErr, OutDone, InDone, R, T extends Context.Tag<any, any>>(
+    self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
     tag: T,
     f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-  ) => Channel.Channel<T | R, InErr, unknown, InDone, OutErr, OutElem, OutDone>
->(3, <R, InErr, InDone, OutElem, OutErr, OutDone, T extends Context.Tag<any, any>>(
-  self: Channel.Channel<R, InErr, unknown, InDone, OutErr, OutElem, OutDone>,
+  ) => Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, T | R>
+>(3, <OutElem, OutErr, InErr, OutDone, InDone, R, T extends Context.Tag<any, any>>(
+  self: Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R>,
   tag: T,
   f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>
-): Channel.Channel<R | T, InErr, unknown, InDone, OutErr, OutElem, OutDone> =>
+): Channel.Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | T> =>
   mapInputContext(self, (context: Context.Context<R>) =>
     Context.merge(
       context,
@@ -2287,11 +2228,11 @@ export const withSpan = dual<
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Exclude<Env, Tracer.ParentSpan>, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <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?: {
       readonly attributes?: Record<string, unknown> | undefined
@@ -2300,7 +2241,7 @@ export const withSpan = dual<
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
-  ) => Channel.Channel<Exclude<Env, Tracer.ParentSpan>, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
 >(3, (self, name, options) =>
   unwrapScoped(
     Effect.flatMap(
@@ -2316,19 +2257,19 @@ export const withSpan = dual<
 /** @internal */
 export const writeAll = <OutElem>(
   ...outs: Array<OutElem>
-): Channel.Channel<never, unknown, unknown, unknown, never, OutElem, void> => writeChunk(Chunk.fromIterable(outs))
+): Channel.Channel<OutElem> => writeChunk(Chunk.fromIterable(outs))
 
 /** @internal */
 export const writeChunk = <OutElem>(
   outs: Chunk.Chunk<OutElem>
-): Channel.Channel<never, unknown, unknown, unknown, never, OutElem, void> => writeChunkWriter(0, outs.length, outs)
+): Channel.Channel<OutElem> => writeChunkWriter(0, outs.length, outs)
 
 /** @internal */
 const writeChunkWriter = <OutElem>(
   idx: number,
   len: number,
   chunk: Chunk.Chunk<OutElem>
-): Channel.Channel<never, unknown, unknown, unknown, never, OutElem, void> => {
+): Channel.Channel<OutElem> => {
   return idx === len
     ? core.unit
     : pipe(
@@ -2339,53 +2280,53 @@ const writeChunkWriter = <OutElem>(
 
 /** @internal */
 export const zip = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    readonly [OutDone, OutDone1]
+    InErr & InErr1,
+    readonly [OutDone, OutDone1],
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    readonly [OutDone, OutDone1]
+    InErr & InErr1,
+    readonly [OutDone, OutDone1],
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   (args) => core.isChannel(args[1]),
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    readonly [OutDone, OutDone1]
+    InErr & InErr1,
+    readonly [OutDone, OutDone1],
+    InDone & InDone1,
+    Env | Env1
   > =>
     options?.concurrent ?
       mergeWith(self, {
@@ -2398,53 +2339,53 @@ export const zip = dual<
 
 /** @internal */
 export const zipLeft = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone
+    InErr & InErr1,
+    OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone
+    InErr & InErr1,
+    OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   (args) => core.isChannel(args[1]),
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone
+    InErr & InErr1,
+    OutDone,
+    InDone & InDone1,
+    Env | Env1
   > =>
     options?.concurrent ?
       map(zip(self, that, { concurrent: true }), (tuple) => tuple[0]) :
@@ -2453,53 +2394,53 @@ export const zipLeft = dual<
 
 /** @internal */
 export const zipRight = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    that: Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>,
     options?: {
       readonly concurrent?: boolean | undefined
     }
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   (args) => core.isChannel(args[1]),
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>,
+  <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<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone1
+    InErr & InErr1,
+    OutDone1,
+    InDone & InDone1,
+    Env | Env1
   > =>
     options?.concurrent ?
       map(zip(self, that, { concurrent: true }), (tuple) => tuple[1]) :
diff --git a/packages/effect/src/internal/channel/channelExecutor.ts b/packages/effect/src/internal/channel/channelExecutor.ts
index 57b1970edf..d10ae3387d 100644
--- a/packages/effect/src/internal/channel/channelExecutor.ts
+++ b/packages/effect/src/internal/channel/channelExecutor.ts
@@ -22,26 +22,10 @@ import * as Continuation from "./continuation.js"
 import * as Subexecutor from "./subexecutor.js"
 import * as upstreamPullRequest from "./upstreamPullRequest.js"
 
-export type ErasedChannel<R> = Channel.Channel<
-  R,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->
+export type ErasedChannel<R> = Channel.Channel<unknown, unknown, unknown, unknown, unknown, unknown, R>
 
 /** @internal */
-export type ErasedExecutor<R> = ChannelExecutor<
-  R,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->
+export type ErasedExecutor<R> = ChannelExecutor<unknown, unknown, unknown, unknown, unknown, unknown, R>
 
 /** @internal */
 export type ErasedContinuation<R> = Continuation.Continuation<
@@ -60,7 +44,15 @@ export type ErasedContinuation<R> = Continuation.Continuation<
 export type ErasedFinalizer<R> = (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R>
 
 /** @internal */
-export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
+export class ChannelExecutor<
+  out OutElem,
+  in InElem = unknown,
+  out OutErr = never,
+  in InErr = unknown,
+  out OutDone = void,
+  in InDone = unknown,
+  in out Env = never
+> {
   private _activeSubexecutor: Subexecutor.Subexecutor<Env> | undefined = undefined
 
   private _cancelled: Exit.Exit<OutErr, OutDone> | undefined = undefined
@@ -86,7 +78,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
   private _providedEnv: Context.Context<unknown> | undefined
 
   constructor(
-    initialChannel: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    initialChannel: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     providedEnv: Context.Context<unknown> | undefined,
     executeCloseLastSubstream: (effect: Effect.Effect<unknown, never, Env>) => Effect.Effect<unknown, never, Env>
   ) {
@@ -184,13 +176,13 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                 case ChannelOpCodes.OP_CONCAT_ALL: {
                   const executor: ErasedExecutor<Env> = new ChannelExecutor(
                     this._currentChannel.value() as Channel.Channel<
-                      Env,
-                      unknown,
-                      unknown,
+                      never,
                       unknown,
                       never,
+                      unknown,
                       never,
-                      never
+                      unknown,
+                      Env
                     >,
                     this._providedEnv,
                     (effect) =>
@@ -278,7 +270,7 @@ export class ChannelExecutor<in out Env, in InErr, in InElem, in InDone, out Out
                   const previousInput = this._input
 
                   const leftExec: ErasedExecutor<Env> = new ChannelExecutor(
-                    this._currentChannel.left() as Channel.Channel<Env, unknown, unknown, unknown, never, never, never>,
+                    this._currentChannel.left() as Channel.Channel<never, unknown, never, unknown, never, unknown, Env>,
                     this._providedEnv,
                     (effect) => this._executeCloseLastSubstream(effect)
                   )
@@ -1102,12 +1094,12 @@ export const readUpstream = <R, E, E2, A>(
 
 /** @internal */
 export const run = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env> => pipe(runScoped(self), Effect.scoped)
 
 /** @internal */
 export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
-  self: Channel.Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>
+  self: Channel.Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env | Scope.Scope> => {
   const run = (
     channelDeferred: Deferred.Deferred<OutDone, OutErr>,
@@ -1163,7 +1155,7 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
 /** @internal */
 const runScopedInterpret = <Env, InErr, InDone, OutErr, OutDone>(
   channelState: ChannelState.ChannelState<Env, OutErr>,
-  exec: ChannelExecutor<Env, InErr, unknown, InDone, OutErr, never, OutDone>
+  exec: ChannelExecutor<never, unknown, OutErr, InErr, OutDone, InDone, Env>
 ): Effect.Effect<OutDone, OutErr, Env> => {
   const op = channelState as ChannelState.Primitive
   switch (op._tag) {
diff --git a/packages/effect/src/internal/channel/continuation.ts b/packages/effect/src/internal/channel/continuation.ts
index bf0fac5cab..5578ecd143 100644
--- a/packages/effect/src/internal/channel/continuation.ts
+++ b/packages/effect/src/internal/channel/continuation.ts
@@ -98,13 +98,13 @@ export interface ContinuationK<
   readonly _tag: OpCodes.OP_CONTINUATION_K
   onSuccess(
     o: OutDone
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
   onHalt(
     c: Cause.Cause<OutErr>
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
   onExit(
     exit: Exit.Exit<OutDone, OutErr>
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>
 }
 
 /** @internal */
@@ -176,15 +176,15 @@ export class ContinuationKImpl<
   constructor(
     readonly onSuccess: (
       o: OutDone
-    ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>,
+    ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env>,
     readonly onHalt: (
       c: Cause.Cause<OutErr>
-    ) => Channel.Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>
+    ) => Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
   ) {
   }
   onExit(
     exit: Exit.Exit<OutDone, OutErr>
-  ): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr2, OutElem, OutDone2> {
+  ): Channel.Channel<OutElem, InElem, OutErr2, InErr, OutDone2, InDone, Env | Env2> {
     return Exit.isFailure(exit) ? this.onHalt(exit.cause) : this.onSuccess(exit.value)
   }
 }
diff --git a/packages/effect/src/internal/core-stream.ts b/packages/effect/src/internal/core-stream.ts
index b7858fae60..30f076e7c4 100644
--- a/packages/effect/src/internal/core-stream.ts
+++ b/packages/effect/src/internal/core-stream.ts
@@ -54,7 +54,7 @@ const proto = {
 }
 
 /** @internal */
-type ErasedChannel = Channel.Channel<never, unknown, unknown, unknown, never, never, never>
+type ErasedChannel = Channel.Channel<never, unknown, never, unknown, never, unknown>
 
 /** @internal */
 export type Op<Tag extends string, Body = {}> =
@@ -203,13 +203,13 @@ export const isChannel = (u: unknown): u is Channel.Channel<
 
 /** @internal */
 export const acquireReleaseOut = dual<
-  <R2, Z>(
+  <Z, R2>(
     release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>
-  ) => <R, E>(self: Effect.Effect<Z, E, R>) => Channel.Channel<R | R2, unknown, unknown, unknown, E, Z, void>,
-  <R, R2, E, Z>(
+  ) => <E, R>(self: Effect.Effect<Z, E, R>) => Channel.Channel<Z, unknown, E, unknown, void, unknown, R | R2>,
+  <Z, E, R, R2>(
     self: Effect.Effect<Z, E, R>,
     release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>
-  ) => Channel.Channel<R | R2, unknown, unknown, unknown, E, Z, void>
+  ) => Channel.Channel<Z, unknown, E, unknown, void, unknown, R | R2>
 >(2, (self, release) => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_BRACKET_OUT
@@ -220,44 +220,44 @@ export const acquireReleaseOut = dual<
 
 /** @internal */
 export const catchAllCause = dual<
-  <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    f: (cause: Cause.Cause<OutErr>) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
-  ) => <Env, InErr, InElem, InDone, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutErr, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(
+    f: (cause: Cause.Cause<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<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (cause: Cause.Cause<OutErr>) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <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: (cause: Cause.Cause<OutErr>) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem1 | OutElem,
-    OutDone1 | OutDone
+    InErr & InErr1,
+    OutDone1 | OutDone,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   2,
-  <Env, InErr, InElem, InDone, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutElem1, OutDone1>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (cause: Cause.Cause<OutErr>) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>
+  <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: (cause: Cause.Cause<OutErr>) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>
   ): Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1,
-    OutElem | OutElem1,
-    OutDone | OutDone1
+    InErr & InErr1,
+    OutDone | OutDone1,
+    InDone & InDone1,
+    Env | Env1
   > => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_FOLD
@@ -269,16 +269,8 @@ export const catchAllCause = dual<
 
 /** @internal */
 export const collectElements = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-): Channel.Channel<
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
-  never,
-  [Chunk.Chunk<OutElem>, OutDone]
-> => {
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+): Channel.Channel<never, InElem, OutErr, InErr, [Chunk.Chunk<OutElem>, OutDone], InDone, Env> => {
   return suspend(() => {
     const builder: Array<OutElem> = []
     return flatMap(
@@ -291,7 +283,7 @@ export const collectElements = <Env, InErr, InElem, InDone, OutErr, OutElem, Out
 /** @internal */
 const collectElementsReader = <OutErr, OutElem, OutDone>(
   builder: Array<OutElem>
-): Channel.Channel<never, OutErr, OutElem, OutDone, OutErr, never, OutDone> =>
+): Channel.Channel<never, OutElem, OutErr, OutErr, OutDone, OutDone> =>
   readWith({
     onInput: (outElem) =>
       flatMap(
@@ -305,54 +297,54 @@ const collectElementsReader = <OutErr, OutElem, OutDone>(
   })
 
 /** @internal */
-export const concatAll = <Env, InErr, InElem, InDone, OutErr, OutElem>(
+export const concatAll = <OutElem, InElem, OutErr, InErr, InDone, Env>(
   channels: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem, OutErr, InErr, any, InDone, Env>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any>,
-    any
+    InErr,
+    any,
+    InDone,
+    Env
   >
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, any> => concatAllWith(channels, constVoid, constVoid)
+): Channel.Channel<OutElem, InElem, OutErr, InErr, any, InDone, Env> => concatAllWith(channels, constVoid, constVoid)
 
 /** @internal */
 export const concatAllWith = <
-  Env,
-  InErr,
-  InElem,
-  InDone,
-  OutErr,
   OutElem,
-  OutDone,
-  OutDone2,
-  OutDone3,
-  Env2,
-  InErr2,
   InElem2,
+  OutErr2,
+  InErr2,
+  OutDone,
   InDone2,
-  OutErr2
+  Env2,
+  InElem,
+  OutErr,
+  InErr,
+  OutDone2,
+  InDone,
+  Env,
+  OutDone3
 >(
   channels: Channel.Channel<
-    Env,
-    InErr,
+    Channel.Channel<OutElem, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     InElem,
-    InDone,
     OutErr,
-    Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem, OutDone>,
-    OutDone2
+    InErr,
+    OutDone2,
+    InDone,
+    Env
   >,
   f: (o: OutDone, o1: OutDone) => OutDone,
   g: (o: OutDone, o2: OutDone2) => OutDone3
 ): Channel.Channel<
-  Env | Env2,
-  InErr & InErr2,
+  OutElem,
   InElem & InElem2,
-  InDone & InDone2,
   OutErr | OutErr2,
-  OutElem,
-  OutDone3
+  InErr & InErr2,
+  OutDone3,
+  InDone & InDone2,
+  Env | Env2
 > => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_CONCAT_ALL
@@ -367,50 +359,50 @@ export const concatAllWith = <
 
 /** @internal */
 export const concatMapWith = dual<
-  <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone2, OutDone3>(
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3
   ) => <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    OutDone3
+    InErr & InErr2,
+    OutDone3,
+    InDone & InDone2,
+    Env2 | Env
   >,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    OutElem2,
-    OutDone,
+    InErr,
     OutDone2,
-    OutDone3,
-    Env2,
-    InErr2,
+    InDone,
+    Env,
+    OutElem2,
     InElem2,
+    OutErr2,
+    InErr2,
+    OutDone,
     InDone2,
-    OutErr2
+    Env2,
+    OutDone3
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    OutDone3
+    InErr & InErr2,
+    OutDone3,
+    InDone & InDone2,
+    Env2 | Env
   >
 >(4, <
   Env,
@@ -429,20 +421,20 @@ export const concatMapWith = dual<
   InDone2,
   OutErr2
 >(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
   f: (
     o: OutElem
-  ) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
   g: (o: OutDone, o1: OutDone) => OutDone,
   h: (o: OutDone, o2: OutDone2) => OutDone3
 ): Channel.Channel<
-  Env | Env2,
-  InErr & InErr2,
+  OutElem2,
   InElem & InElem2,
-  InDone & InDone2,
   OutErr | OutErr2,
-  OutElem2,
-  OutDone3
+  InErr & InErr2,
+  OutDone3,
+  InDone & InDone2,
+  Env | Env2
 > => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_CONCAT_ALL
@@ -457,8 +449,8 @@ export const concatMapWith = dual<
 
 /** @internal */
 export const concatMapWithCustom = dual<
-  <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone2, OutDone3>(
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3,
     onPull: (
@@ -466,35 +458,35 @@ export const concatMapWithCustom = dual<
     ) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>,
     onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision
   ) => <Env, InErr, InElem, InDone, OutErr>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    OutDone3
+    InErr & InErr2,
+    OutDone3,
+    InDone & InDone2,
+    Env2 | Env
   >,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
-    InDone,
     OutErr,
-    OutElem,
-    OutElem2,
-    OutDone,
+    InErr,
     OutDone2,
-    OutDone3,
-    Env2,
-    InErr2,
+    InDone,
+    Env,
+    OutElem2,
     InElem2,
+    OutErr2,
+    InErr2,
+    OutDone,
     InDone2,
-    OutErr2
+    Env2,
+    OutDone3
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
-    f: (o: OutElem) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
     g: (o: OutDone, o1: OutDone) => OutDone,
     h: (o: OutDone, o2: OutDone2) => OutDone3,
     onPull: (
@@ -502,13 +494,13 @@ export const concatMapWithCustom = dual<
     ) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>,
     onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision
   ) => Channel.Channel<
-    Env2 | Env,
-    InErr & InErr2,
+    OutElem2,
     InElem & InElem2,
-    InDone & InDone2,
     OutErr2 | OutErr,
-    OutElem2,
-    OutDone3
+    InErr & InErr2,
+    OutDone3,
+    InDone & InDone2,
+    Env2 | Env
   >
 >(6, <
   Env,
@@ -527,10 +519,10 @@ export const concatMapWithCustom = dual<
   InDone2,
   OutErr2
 >(
-  self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>,
+  self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>,
   f: (
     o: OutElem
-  ) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>,
+  ) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>,
   g: (o: OutDone, o1: OutDone) => OutDone,
   h: (o: OutDone, o2: OutDone2) => OutDone3,
   onPull: (
@@ -538,13 +530,13 @@ export const concatMapWithCustom = dual<
   ) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>,
   onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision
 ): Channel.Channel<
-  Env | Env2,
-  InErr & InErr2,
+  OutElem2,
   InElem & InElem2,
-  InDone & InDone2,
   OutErr | OutErr2,
-  OutElem2,
-  OutDone3
+  InErr & InErr2,
+  OutDone3,
+  InDone & InDone2,
+  Env | Env2
 > => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_CONCAT_ALL
@@ -561,19 +553,19 @@ export const concatMapWithCustom = dual<
 export const embedInput = dual<
   <InErr, InElem, InDone>(
     input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>
-  ) => <Env, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, OutErr, OutElem, OutDone, InErr, InElem, InDone>(
-    self: Channel.Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>,
+  ) => <OutElem, OutErr, OutDone, Env>(
+    self: Channel.Channel<OutElem, unknown, OutErr, unknown, OutDone, unknown, Env>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+  <OutElem, OutErr, OutDone, Env, InErr, InElem, InDone>(
+    self: Channel.Channel<OutElem, unknown, OutErr, unknown, OutDone, unknown, Env>,
     input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
 >(
   2,
-  <Env, OutErr, OutElem, OutDone, InErr, InElem, InDone>(
-    self: Channel.Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>,
+  <OutElem, OutErr, OutDone, Env, InErr, InElem, InDone>(
+    self: Channel.Channel<OutElem, unknown, OutErr, unknown, OutDone, unknown, Env>,
     input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>
-  ): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_BRIDGE
     op.input = input
@@ -584,21 +576,21 @@ export const embedInput = dual<
 
 /** @internal */
 export const ensuringWith = dual<
-  <Env2, OutErr, OutDone>(
+  <OutDone, OutErr, Env2>(
     finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
-  ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <Env, InErr, InElem, InDone, OutElem, Env2, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <OutElem, InElem, InErr, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env2 | Env>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env2>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env2 | Env>
 >(
   2,
-  <Env, InErr, InElem, InDone, OutElem, Env2, OutErr, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, Env2>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
-  ): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | Env2> => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_ENSURING
     op.channel = self
@@ -608,23 +600,23 @@ export const ensuringWith = dual<
 )
 
 /** @internal */
-export const fail = <E>(error: E): Channel.Channel<never, unknown, unknown, unknown, E, never, never> =>
+export const fail = <E>(error: E): Channel.Channel<never, unknown, E, unknown, never, unknown> =>
   failCause(Cause.fail(error))
 
 /** @internal */
 export const failSync = <E>(
   evaluate: LazyArg<E>
-): Channel.Channel<never, unknown, unknown, unknown, E, never, never> => failCauseSync(() => Cause.fail(evaluate()))
+): Channel.Channel<never, unknown, E, unknown, never, unknown> => failCauseSync(() => Cause.fail(evaluate()))
 
 /** @internal */
 export const failCause = <E>(
   cause: Cause.Cause<E>
-): Channel.Channel<never, unknown, unknown, unknown, E, never, never> => failCauseSync(() => cause)
+): Channel.Channel<never, unknown, E, unknown, never, unknown> => failCauseSync(() => cause)
 
 /** @internal */
 export const failCauseSync = <E>(
   evaluate: LazyArg<Cause.Cause<E>>
-): Channel.Channel<never, unknown, unknown, unknown, E, never, never> => {
+): Channel.Channel<never, unknown, E, unknown, never, unknown> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_FAIL
   op.error = evaluate
@@ -633,44 +625,44 @@ export const failCauseSync = <E>(
 
 /** @internal */
 export const flatMap = dual<
-  <OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
-    f: (d: OutDone) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
-  ) => <Env, InErr, InElem, InDone, OutErr, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutDone, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>(
+    f: (d: OutDone) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>
+  ) => <OutElem, InElem, OutErr, InErr, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone2
+    InErr & InErr1,
+    OutDone2,
+    InDone & InDone1,
+    Env1 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (d: OutDone) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (d: OutDone) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>
   ) => Channel.Channel<
-    Env1 | Env,
-    InErr & InErr1,
+    OutElem1 | OutElem,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr1 | OutErr,
-    OutElem1 | OutElem,
-    OutDone2
+    InErr & InErr1,
+    OutDone2,
+    InDone & InDone1,
+    Env1 | Env
   >
 >(
   2,
-  <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    f: (d: OutDone) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
+    f: (d: OutDone) => Channel.Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>
   ): Channel.Channel<
-    Env | Env1,
-    InErr & InErr1,
+    OutElem | OutElem1,
     InElem & InElem1,
-    InDone & InDone1,
     OutErr | OutErr1,
-    OutElem | OutElem1,
-    OutDone2
+    InErr & InErr1,
+    OutDone2,
+    InDone & InDone1,
+    Env | Env1
   > => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_FOLD
@@ -683,119 +675,119 @@ export const flatMap = dual<
 /** @internal */
 export const foldCauseChannel = dual<
   <
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
-    InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
     OutErr,
-    OutErr2,
-    OutErr3,
     OutElem1,
-    OutElem2,
-    OutDone,
+    InElem1,
+    OutErr2,
+    InErr1,
     OutDone2,
-    OutDone3
+    InDone1,
+    Env1,
+    OutDone,
+    OutElem2,
+    InElem2,
+    OutErr3,
+    InErr2,
+    OutDone3,
+    InDone2,
+    Env2
   >(
     options: {
       readonly onFailure: (
         c: Cause.Cause<OutErr>
-      ) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>
-      readonly onSuccess: (o: OutDone) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>
+      ) => Channel.Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>
+      readonly onSuccess: (o: OutDone) => Channel.Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>
     }
   ) => <Env, InErr, InElem, InDone, OutElem>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1 & InErr2,
+    OutDone2 | OutDone3,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
+    Env,
+    OutElem1,
     InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
-    OutErr,
     OutErr2,
-    OutErr3,
-    OutElem1,
-    OutElem2,
-    OutDone,
+    InErr1,
     OutDone2,
-    OutDone3
+    InDone1,
+    Env1,
+    OutElem2,
+    InElem2,
+    OutErr3,
+    InErr2,
+    OutDone3,
+    InDone2,
+    Env2
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
       readonly onFailure: (
         c: Cause.Cause<OutErr>
-      ) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>
-      readonly onSuccess: (o: OutDone) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>
+      ) => Channel.Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>
+      readonly onSuccess: (o: OutDone) => Channel.Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>
     }
   ) => Channel.Channel<
-    Env1 | Env2 | Env,
-    InErr & InErr1 & InErr2,
+    OutElem1 | OutElem2 | OutElem,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr2 | OutErr3,
-    OutElem1 | OutElem2 | OutElem,
-    OutDone2 | OutDone3
+    InErr & InErr1 & InErr2,
+    OutDone2 | OutDone3,
+    InDone & InDone1 & InDone2,
+    Env1 | Env2 | Env
   >
 >(
   2,
   <
-    Env,
-    InErr,
+    OutElem,
     InElem,
+    OutErr,
+    InErr,
+    OutDone,
     InDone,
-    OutElem,
-    Env1,
-    Env2,
-    InErr1,
-    InErr2,
+    Env,
+    OutElem1,
     InElem1,
-    InElem2,
-    InDone1,
-    InDone2,
-    OutErr,
     OutErr2,
-    OutErr3,
-    OutElem1,
-    OutElem2,
-    OutDone,
+    InErr1,
     OutDone2,
-    OutDone3
+    InDone1,
+    Env1,
+    OutElem2,
+    InElem2,
+    OutErr3,
+    InErr2,
+    OutDone3,
+    InDone2,
+    Env2
   >(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     options: {
       readonly onFailure: (
         c: Cause.Cause<OutErr>
-      ) => Channel.Channel<Env1, InErr1, InElem1, InDone1, OutErr2, OutElem1, OutDone2>
-      readonly onSuccess: (o: OutDone) => Channel.Channel<Env2, InErr2, InElem2, InDone2, OutErr3, OutElem2, OutDone3>
+      ) => Channel.Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>
+      readonly onSuccess: (o: OutDone) => Channel.Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>
     }
   ): Channel.Channel<
-    Env | Env1 | Env2,
-    InErr & InErr1 & InErr2,
+    OutElem | OutElem1 | OutElem2,
     InElem & InElem1 & InElem2,
-    InDone & InDone1 & InDone2,
     OutErr2 | OutErr3,
-    OutElem | OutElem1 | OutElem2,
-    OutDone2 | OutDone3
+    InErr & InErr1 & InErr2,
+    OutDone2 | OutDone3,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
   > => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_FOLD
@@ -808,7 +800,7 @@ export const foldCauseChannel = dual<
 /** @internal */
 export const fromEffect = <A, E, R>(
   effect: Effect.Effect<A, E, R>
-): Channel.Channel<R, unknown, unknown, unknown, E, never, A> => {
+): Channel.Channel<never, unknown, E, unknown, A, unknown, R> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_FROM_EFFECT
   op.effect = () => effect
@@ -817,21 +809,21 @@ export const fromEffect = <A, E, R>(
 
 /** @internal */
 export const pipeTo = dual<
-  <Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    that: Channel.Channel<Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ) => <Env, InErr, InElem, InDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>,
-  <Env, InErr, InElem, InDone, Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ) => Channel.Channel<Env2 | Env, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
+  <OutElem2, OutElem, OutErr2, OutErr, OutDone2, OutDone, Env2>(
+    that: Channel.Channel<OutElem2, OutElem, OutErr2, OutErr, OutDone2, OutDone, Env2>
+  ) => <InElem, InErr, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel.Channel<OutElem2, InElem, OutErr2, 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, OutErr, OutDone2, OutDone, Env2>
+  ) => Channel.Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2 | Env>
 >(
   2,
-  <Env, InErr, InElem, InDone, Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-    that: Channel.Channel<Env2, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>
-  ): Channel.Channel<Env | Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2> => {
+  <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, OutErr, OutDone2, OutDone, Env2>
+  ): Channel.Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env | Env2> => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_PIPE_TO
     op.left = () => self
@@ -844,19 +836,19 @@ export const pipeTo = dual<
 export const provideContext = dual<
   <Env>(
     env: Context.Context<Env>
-  ) => <InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     env: Context.Context<Env>
-  ) => Channel.Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone>
 >(
   2,
-  <InErr, InElem, InDone, OutErr, OutElem, OutDone, Env>(
-    self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+    self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     env: Context.Context<Env>
-  ): Channel.Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone> => {
     const op = Object.create(proto)
     op._tag = OpCodes.OP_PROVIDE
     op.context = () => env
@@ -866,9 +858,9 @@ export const provideContext = dual<
 )
 
 /** @internal */
-export const readOrFail = <In, E>(
+export const readOrFail = <E, In = unknown>(
   error: E
-): Channel.Channel<never, unknown, In, unknown, E, never, In> => {
+): Channel.Channel<never, In, E, unknown, In, unknown> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_READ
   op.more = succeed
@@ -878,35 +870,35 @@ export const readOrFail = <In, E>(
 
 /** @internal */
 export const readWith = <
-  Env,
-  InErr,
   InElem,
-  InDone,
-  OutErr,
   OutElem,
+  OutErr,
+  InErr,
   OutDone,
-  Env2,
-  OutErr2,
+  InDone,
+  Env,
   OutElem2,
+  OutErr2,
   OutDone2,
-  Env3,
-  OutErr3,
+  Env2,
   OutElem3,
-  OutDone3
+  OutErr3,
+  OutDone3,
+  Env3
 >(
   options: {
-    readonly onInput: (input: InElem) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-    readonly onFailure: (error: InErr) => Channel.Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
-    readonly onDone: (done: InDone) => Channel.Channel<Env3, InErr, InElem, InDone, OutErr3, OutElem3, OutDone3>
+    readonly onInput: (input: InElem) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
+    readonly onFailure: (error: InErr) => Channel.Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
+    readonly onDone: (done: InDone) => Channel.Channel<OutElem3, InElem, OutErr3, InErr, OutDone3, InDone, Env3>
   }
 ): Channel.Channel<
-  Env | Env2 | Env3,
-  InErr,
+  OutElem | OutElem2 | OutElem3,
   InElem,
-  InDone,
   OutErr | OutErr2 | OutErr3,
-  OutElem | OutElem2 | OutElem3,
-  OutDone | OutDone2 | OutDone3
+  InErr,
+  OutDone | OutDone2 | OutDone3,
+  InDone,
+  Env | Env2 | Env3
 > =>
   readWithCause({
     onInput: options.onInput,
@@ -916,37 +908,37 @@ export const readWith = <
 
 /** @internal */
 export const readWithCause = <
-  Env,
-  InErr,
   InElem,
-  InDone,
-  OutErr,
   OutElem,
+  OutErr,
+  InErr,
   OutDone,
-  Env2,
-  OutErr2,
+  InDone,
+  Env,
   OutElem2,
+  OutErr2,
   OutDone2,
-  Env3,
-  OutErr3,
+  Env2,
   OutElem3,
-  OutDone3
+  OutErr3,
+  OutDone3,
+  Env3
 >(
   options: {
-    readonly onInput: (input: InElem) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+    readonly onInput: (input: InElem) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
     readonly onFailure: (
       cause: Cause.Cause<InErr>
-    ) => Channel.Channel<Env2, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2>
-    readonly onDone: (done: InDone) => Channel.Channel<Env3, InErr, InElem, InDone, OutErr3, OutElem3, OutDone3>
+    ) => Channel.Channel<OutElem2, InElem, OutErr2, InErr, OutDone2, InDone, Env2>
+    readonly onDone: (done: InDone) => Channel.Channel<OutElem3, InElem, OutErr3, InErr, OutDone3, InDone, Env3>
   }
 ): Channel.Channel<
-  Env | Env2 | Env3,
-  InErr,
+  OutElem | OutElem2 | OutElem3,
   InElem,
-  InDone,
   OutErr | OutErr2 | OutErr3,
-  OutElem | OutElem2 | OutElem3,
-  OutDone | OutDone2 | OutDone3
+  InErr,
+  OutDone | OutDone2 | OutDone3,
+  InDone,
+  Env | Env2 | Env3
 > => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_READ
@@ -958,12 +950,12 @@ export const readWithCause = <
 /** @internal */
 export const succeed = <A>(
   value: A
-): Channel.Channel<never, unknown, unknown, unknown, never, never, A> => sync(() => value)
+): Channel.Channel<never, unknown, never, unknown, A, unknown> => sync(() => value)
 
 /** @internal */
 export const succeedNow = <OutDone>(
   result: OutDone
-): Channel.Channel<never, unknown, unknown, unknown, never, never, OutDone> => {
+): Channel.Channel<never, unknown, never, unknown, OutDone, unknown> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_SUCCEED_NOW
   op.terminal = result
@@ -971,9 +963,9 @@ export const succeedNow = <OutDone>(
 }
 
 /** @internal */
-export const suspend = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  evaluate: LazyArg<Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>
-): Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> => {
+export const suspend = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  evaluate: LazyArg<Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>>
+): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_SUSPEND
   op.channel = evaluate
@@ -982,7 +974,7 @@ export const suspend = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 
 export const sync = <OutDone>(
   evaluate: LazyArg<OutDone>
-): Channel.Channel<never, unknown, unknown, unknown, never, never, OutDone> => {
+): Channel.Channel<never, unknown, never, unknown, OutDone, unknown> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_SUCCEED
   op.evaluate = evaluate
@@ -990,12 +982,12 @@ export const sync = <OutDone>(
 }
 
 /** @internal */
-export const unit: Channel.Channel<never, unknown, unknown, unknown, never, never, void> = succeedNow(void 0)
+export const unit: Channel.Channel<never> = succeedNow(void 0)
 
 /** @internal */
 export const write = <OutElem>(
   out: OutElem
-): Channel.Channel<never, unknown, unknown, unknown, never, OutElem, void> => {
+): Channel.Channel<OutElem, unknown, never, unknown, void, unknown> => {
   const op = Object.create(proto)
   op._tag = OpCodes.OP_EMIT
   op.out = out
diff --git a/packages/effect/src/internal/groupBy.ts b/packages/effect/src/internal/groupBy.ts
index a45b99e18d..c5672b4ea4 100644
--- a/packages/effect/src/internal/groupBy.ts
+++ b/packages/effect/src/internal/groupBy.ts
@@ -419,7 +419,7 @@ export const groupByKey = dual<
     const loop = (
       map: Map<K, Queue.Queue<Take.Take<A, E>>>,
       outerQueue: Queue.Queue<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>
-    ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, never, unknown> =>
+    ): Channel.Channel<never, Chunk.Chunk<A>, E, E, unknown, unknown, R> =>
       core.readWithCause({
         onInput: (input: Chunk.Chunk<A>) =>
           core.flatMap(
diff --git a/packages/effect/src/internal/sink.ts b/packages/effect/src/internal/sink.ts
index dc82711df7..4abb7067a0 100644
--- a/packages/effect/src/internal/sink.ts
+++ b/packages/effect/src/internal/sink.ts
@@ -45,7 +45,7 @@ const sinkVariance = {
 export class SinkImpl<out R, out E, in In, out L, out Z> implements Sink.Sink<R, E, In, L, Z> {
   readonly [SinkTypeId] = sinkVariance
   constructor(
-    readonly channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
+    readonly channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R>
   ) {
   }
   pipe() {
@@ -77,7 +77,7 @@ export const collectAll = <In>(): Sink.Sink<never, never, In, never, Chunk.Chunk
 /** @internal */
 const collectAllLoop = <In>(
   acc: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, never, Chunk.Chunk<In>> =>
+): Channel.Channel<never, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWithCause({
     onInput: (chunk: Chunk.Chunk<In>) => collectAllLoop(pipe(acc, Chunk.appendAll(chunk))),
     onFailure: core.failCause,
@@ -92,7 +92,7 @@ export const collectAllN = <In>(n: number): Sink.Sink<never, never, In, In, Chun
 const collectAllNLoop = <In>(
   n: number,
   acc: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWithCause({
     onInput: (chunk: Chunk.Chunk<In>) => {
       const [collected, leftovers] = Chunk.splitAt(chunk, n)
@@ -209,7 +209,7 @@ export const collectAllWhile: {
 const collectAllWhileReader = <In>(
   predicate: Predicate<In>,
   done: Chunk.Chunk<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const [collected, leftovers] = pipe(Chunk.toReadonlyArray(input), ReadonlyArray.span(predicate))
@@ -237,7 +237,7 @@ export const collectAllWhileEffect = <In, R, E>(
 const collectAllWhileEffectReader = <In, R, E>(
   predicate: (input: In) => Effect.Effect<boolean, E, R>,
   done: Chunk.Chunk<In>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, Chunk.Chunk<In>> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, never, Chunk.Chunk<In>, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -288,8 +288,8 @@ export const collectAllWhileWith = dual<
     const newChannel = pipe(
       core.fromEffect(refs),
       core.flatMap(([leftoversRef, upstreamDoneRef]) => {
-        const upstreamMarker: Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =
-          core.readWith({
+        const upstreamMarker: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> = core
+          .readWith({
             onInput: (input) => pipe(core.write(input), core.flatMap(() => upstreamMarker)),
             onFailure: core.fail,
             onDone: (done) => pipe(core.fromEffect(Ref.set(upstreamDoneRef, true)), channel.as(done))
@@ -315,7 +315,7 @@ const collectAllWhileWithLoop = <R, E, In, L extends In, Z, S>(
   currentResult: S,
   p: Predicate<Z>,
   f: (s: S, z: Z) => S
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, S> => {
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, S, unknown, R> => {
   return pipe(
     toChannel(self),
     channel.doneCollect,
@@ -400,7 +400,7 @@ export const mapInputChunks = dual<
     self: Sink.Sink<R, E, In, L, Z>,
     f: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
   ): Sink.Sink<R, E, In0, L, Z> => {
-    const loop: Channel.Channel<R, never, Chunk.Chunk<In0>, unknown, never, Chunk.Chunk<In>, unknown> = core.readWith({
+    const loop: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In0>, never, never, unknown, unknown, R> = core.readWith({
       onInput: (chunk) => pipe(core.write(f(chunk)), core.flatMap(() => loop)),
       onFailure: core.fail,
       onDone: core.succeed
@@ -424,7 +424,7 @@ export const mapInputChunksEffect = dual<
     self: Sink.Sink<R, E, In, L, Z>,
     f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
   ): Sink.Sink<R | R2, E | E2, In0, L, Z> => {
-    const loop: Channel.Channel<R | R2, never, Chunk.Chunk<In0>, unknown, E2, Chunk.Chunk<In>, unknown> = core
+    const loop: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In0>, E2, never, unknown, unknown, R | R2> = core
       .readWith({
         onInput: (chunk) => pipe(core.fromEffect(f(chunk)), core.flatMap(core.write), core.flatMap(() => loop)),
         onFailure: core.fail,
@@ -560,7 +560,7 @@ export const dimapChunksEffect = dual<
 
 /** @internal */
 export const drain: Sink.Sink<never, never, unknown, never, void> = new SinkImpl(
-  channel.drain(channel.identityChannel<never, unknown, unknown>())
+  channel.drain(channel.identityChannel())
 )
 
 /** @internal */
@@ -570,7 +570,7 @@ export const drop = <In>(n: number): Sink.Sink<never, never, In, In, unknown> =>
 /** @internal */
 const dropLoop = <In>(
   n: number
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const dropped = pipe(input, Chunk.drop(n))
@@ -581,7 +581,7 @@ const dropLoop = <In>(
       }
       return pipe(
         core.write(dropped),
-        channel.zipRight(channel.identityChannel<never, Chunk.Chunk<In>, unknown>())
+        channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, never, unknown>())
       )
     },
     onFailure: core.fail,
@@ -602,7 +602,7 @@ export const dropUntilEffect = <In, R, E>(
 /** @internal */
 const dropUntilEffectReader = <In, R, E>(
   predicate: (input: In) => Effect.Effect<boolean, E, R>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, unknown, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -614,7 +614,7 @@ const dropUntilEffectReader = <In, R, E>(
             dropUntilEffectReader(predicate) :
             pipe(
               core.write(Chunk.unsafeFromArray(leftover)),
-              channel.zipRight(channel.identityChannel<E, Chunk.Chunk<In>, unknown>())
+              channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, E, unknown>())
             )
         }),
         channel.unwrap
@@ -630,14 +630,14 @@ export const dropWhile = <In>(predicate: Predicate<In>): Sink.Sink<never, never,
 /** @internal */
 const dropWhileReader = <In>(
   predicate: Predicate<In>
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const out = pipe(input, Chunk.dropWhile(predicate))
       if (Chunk.isEmpty(out)) {
         return dropWhileReader(predicate)
       }
-      return pipe(core.write(out), channel.zipRight(channel.identityChannel<never, Chunk.Chunk<In>, unknown>()))
+      return pipe(core.write(out), channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, never, unknown>()))
     },
     onFailure: core.fail,
     onDone: core.succeedNow
@@ -651,7 +651,7 @@ export const dropWhileEffect = <In, R, E>(
 /** @internal */
 const dropWhileEffectReader = <In, R, E>(
   predicate: (input: In) => Effect.Effect<boolean, E, R>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, unknown> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, unknown, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -663,7 +663,7 @@ const dropWhileEffectReader = <In, R, E>(
             dropWhileEffectReader(predicate) :
             pipe(
               core.write(Chunk.unsafeFromArray(leftover)),
-              channel.zipRight(channel.identityChannel<E, Chunk.Chunk<In>, unknown>())
+              channel.zipRight(channel.identityChannel<Chunk.Chunk<In>, E, unknown>())
             )
         }),
         channel.unwrap
@@ -797,13 +797,13 @@ export const findEffect = dual<
         Effect.zip(Ref.make(false))
       )),
       core.flatMap(([leftoversRef, upstreamDoneRef]) => {
-        const upstreamMarker: Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, unknown> =
-          core.readWith({
+        const upstreamMarker: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, unknown, unknown> = core
+          .readWith({
             onInput: (input) => pipe(core.write(input), core.flatMap(() => upstreamMarker)),
             onFailure: core.fail,
             onDone: (done) => pipe(core.fromEffect(Ref.set(upstreamDoneRef, true)), channel.as(done))
           })
-        const loop: Channel.Channel<R | R2, never, Chunk.Chunk<In>, unknown, E | E2, Chunk.Chunk<L>, Option.Option<Z>> =
+        const loop: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E | E2, never, Option.Option<Z>, unknown, R | R2> =
           channel.foldChannel(core.collectElements(toChannel(self)), {
             onFailure: core.fail,
             onSuccess: ([leftovers, doneValue]) =>
@@ -849,7 +849,7 @@ const foldReader = <S, In>(
   s: S,
   contFn: Predicate<S>,
   f: (z: S, input: In) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, S> => {
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, S, unknown> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -910,13 +910,13 @@ export const foldSink = dual<
     }
   ): Sink.Sink<R | R1 | R2, E1 | E2, In1 & In2, L1 | L2, Z1 | Z2> => {
     const newChannel: Channel.Channel<
-      R | R1 | R2,
-      never,
+      Chunk.Chunk<L1 | L2>,
       Chunk.Chunk<In1 & In2>,
-      unknown,
       E1 | E2,
-      Chunk.Chunk<L1 | L2>,
-      Z1 | Z2
+      never,
+      Z1 | Z2,
+      unknown,
+      R | R1 | R2
     > = pipe(
       toChannel(self),
       core.collectElements,
@@ -937,7 +937,7 @@ export const foldSink = dual<
               // L <: In1 and therefore Chunk[L] can be safely cast to Chunk[In1].
               core.flatMap((chunk) => channel.writeChunk(chunk as Chunk.Chunk<Chunk.Chunk<In1 & In2>>))
             )
-            const passthrough = channel.identityChannel<never, Chunk.Chunk<In1 & In2>, unknown>()
+            const passthrough = channel.identityChannel<Chunk.Chunk<In1 & In2>, never, unknown>()
             const continuationSink = pipe(
               refReader,
               channel.zipRight(passthrough),
@@ -972,7 +972,7 @@ const foldChunksReader = <S, In>(
   s: S,
   contFn: Predicate<S>,
   f: (s: S, chunk: Chunk.Chunk<In>) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, never, S> => {
+): Channel.Channel<never, Chunk.Chunk<In>, never, never, S, unknown> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -995,7 +995,7 @@ const foldChunksEffectReader = <S, R, E, In>(
   s: S,
   contFn: Predicate<S>,
   f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, S> => {
+): Channel.Channel<never, Chunk.Chunk<In>, E, E, S, unknown, R> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -1022,7 +1022,7 @@ const foldEffectReader = <S, In, R, E>(
   s: S,
   contFn: Predicate<S>,
   f: (s: S, input: In) => Effect.Effect<S, E, R>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, S> => {
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, S, unknown, R> => {
   if (!contFn(s)) {
     return core.succeedNow(s)
   }
@@ -1171,7 +1171,7 @@ const foldWeightedDecomposeLoop = <S, In>(
   costFn: (s: S, input: In) => number,
   decompose: (input: In) => Chunk.Chunk<In>,
   f: (s: S, input: In) => S
-): Channel.Channel<never, never, Chunk.Chunk<In>, unknown, never, Chunk.Chunk<In>, S> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, S, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
       const [nextS, nextCost, nextDirty, leftovers] = foldWeightedDecomposeFold(
@@ -1282,7 +1282,7 @@ const foldWeightedDecomposeEffectLoop = <S, In, R, E, R2, E2, R3, E3>(
   f: (s: S, input: In) => Effect.Effect<S, E3, R3>,
   cost: number,
   dirty: boolean
-): Channel.Channel<R | R2 | R3, E | E2 | E3, Chunk.Chunk<In>, unknown, E | E2 | E3, Chunk.Chunk<In>, S> =>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E | E2 | E3, E | E2 | E3, S, unknown, R | R2 | R3> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
@@ -1375,7 +1375,7 @@ export const flatMap = dual<
 
 /** @internal */
 export const forEach = <In, R, E, _>(f: (input: In) => Effect.Effect<_, E, R>): Sink.Sink<R, E, In, never, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWithCause({
+  const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(core.fromEffect(Effect.forEach(input, (v) => f(v), { discard: true })), core.flatMap(() => process)),
     onFailure: core.failCause,
@@ -1388,7 +1388,7 @@ export const forEach = <In, R, E, _>(f: (input: In) => Effect.Effect<_, E, R>):
 export const forEachChunk = <In, R, E, _>(
   f: (input: Chunk.Chunk<In>) => Effect.Effect<_, E, R>
 ): Sink.Sink<R, E, In, never, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWithCause({
+  const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => pipe(core.fromEffect(f(input)), core.flatMap(() => process)),
     onFailure: core.failCause,
     onDone: () => core.unit
@@ -1400,7 +1400,7 @@ export const forEachChunk = <In, R, E, _>(
 export const forEachWhile = <In, R, E>(
   f: (input: In) => Effect.Effect<boolean, E, R>
 ): Sink.Sink<R, E, In, In, void> => {
-  const process: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void> = core.readWithCause({
+  const process: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => forEachWhileReader(f, input, 0, input.length, process),
     onFailure: core.failCause,
     onDone: () => core.unit
@@ -1414,8 +1414,8 @@ const forEachWhileReader = <In, R, E>(
   input: Chunk.Chunk<In>,
   index: number,
   length: number,
-  cont: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void>
-): Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<In>, void> => {
+  cont: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R>
+): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R> => {
   if (index === length) {
     return cont
   }
@@ -1434,7 +1434,7 @@ const forEachWhileReader = <In, R, E>(
 export const forEachChunkWhile = <In, R, E>(
   f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>
 ): Sink.Sink<R, E, In, In, void> => {
-  const reader: Channel.Channel<R, E, Chunk.Chunk<In>, unknown, E, never, void> = core.readWith({
+  const reader: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
         core.fromEffect(f(input)),
@@ -1448,7 +1448,7 @@ export const forEachChunkWhile = <In, R, E>(
 
 /** @internal */
 export const fromChannel = <R, E, In, L, Z>(
-  channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
+  channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R>
 ): Sink.Sink<R, E, In, L, Z> => new SinkImpl(channel)
 
 /** @internal */
@@ -1477,7 +1477,7 @@ const fromPushPull = <R, E, In, L, Z>(
   push: (
     option: Option.Option<Chunk.Chunk<In>>
   ) => Effect.Effect<void, readonly [Either.Either<E, Z>, Chunk.Chunk<L>], R>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z> =>
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) =>
       channel.foldChannel(core.fromEffect(push(Option.some(input))), {
@@ -1721,13 +1721,13 @@ export const raceWith = dual<
         })
       )
       const racedChannel: Channel.Channel<
-        R | R2,
-        never,
+        Chunk.Chunk<L | L2>,
         Chunk.Chunk<In & In2>,
-        unknown,
         E | E2,
-        Chunk.Chunk<L | L2>,
-        Z3 | Z4
+        never,
+        Z3 | Z4,
+        unknown,
+        R | R2
       > = channel.mergeWith(reader, {
         other: writer,
         onSelfDone: (_) => mergeDecision.Await((exit) => Effect.suspend(() => exit)),
@@ -1850,7 +1850,7 @@ const splitWhereSplitter = <E, A>(
   written: boolean,
   leftovers: Ref.Ref<Chunk.Chunk<A>>,
   f: Predicate<A>
-): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> =>
+): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, never, unknown, unknown> =>
   core.readWithCause({
     onInput: (input) => {
       if (Chunk.isEmpty(input)) {
@@ -1967,7 +1967,7 @@ export const take = <In>(n: number): Sink.Sink<never, never, In, In, Chunk.Chunk
 /** @internal */
 export const toChannel = <R, E, In, L, Z>(
   self: Sink.Sink<R, E, In, L, Z>
-): Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z> =>
+): Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, Z, unknown, R> =>
   Effect.isEffect(self) ?
     toChannel(fromEffect(self as Effect.Effect<Z, E, R>)) :
     (self as SinkImpl<R, E, In, L, Z>).channel
@@ -2128,8 +2128,8 @@ export const zipWith = dual<
 // Circular with Channel
 
 /** @internal */
-export const channelToSink = <Env, InErr, InElem, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, InErr, Chunk.Chunk<InElem>, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>
+export const channelToSink = <OutElem, InElem, OutErr, InErr, OutDone, Env>(
+  self: Channel.Channel<Chunk.Chunk<OutElem>, Chunk.Chunk<InElem>, OutErr, InErr, OutDone, unknown, Env>
 ): Sink.Sink<Env, OutErr, InElem, OutElem, OutDone> => new SinkImpl(self)
 
 // Constants
diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
index 6ec100a290..34144e2900 100644
--- a/packages/effect/src/internal/stream.ts
+++ b/packages/effect/src/internal/stream.ts
@@ -69,7 +69,7 @@ const streamVariance = {
 export class StreamImpl<out A, out E = never, out R = never> implements Stream.Stream<A, E, R> {
   readonly [StreamTypeId] = streamVariance
   constructor(
-    readonly channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
+    readonly channel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>
   ) {
   }
 
@@ -93,7 +93,7 @@ export const accumulate = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream
 export const accumulateChunks = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> => {
   const accumulator = (
     s: Chunk.Chunk<A>
-  ): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, void> =>
+  ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, void, unknown> =>
     core.readWith({
       onInput: (input: Chunk.Chunk<A>) => {
         const next = Chunk.appendAll(s, input)
@@ -188,7 +188,7 @@ export const aggregateWithinEither = dual<
     return pipe(
       fromEffect(layer),
       flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
-        const handoffProducer: Channel.Channel<never, E | E2, Chunk.Chunk<A>, unknown, never, never, unknown> = core
+        const handoffProducer: Channel.Channel<never, Chunk.Chunk<A>, never, E | E2, unknown, unknown> = core
           .readWithCause({
             onInput: (input: Chunk.Chunk<A>) =>
               core.flatMap(
@@ -214,78 +214,77 @@ export const aggregateWithinEither = dual<
                 )
               )
           })
-        const handoffConsumer: Channel.Channel<never, unknown, unknown, unknown, E | E2, Chunk.Chunk<A | A2>, void> =
-          pipe(
-            Ref.getAndSet(sinkLeftovers, Chunk.empty()),
-            Effect.flatMap((leftovers) => {
-              if (Chunk.isNonEmpty(leftovers)) {
-                return pipe(
-                  Ref.set(consumed, true),
-                  Effect.zipRight(Effect.succeed(pipe(
-                    core.write(leftovers),
-                    core.flatMap(() => handoffConsumer)
-                  )))
-                )
-              }
+        const handoffConsumer: Channel.Channel<Chunk.Chunk<A | A2>, unknown, E | E2, unknown, void, unknown> = pipe(
+          Ref.getAndSet(sinkLeftovers, Chunk.empty()),
+          Effect.flatMap((leftovers) => {
+            if (Chunk.isNonEmpty(leftovers)) {
               return pipe(
-                Handoff.take(handoff),
-                Effect.map((signal) => {
-                  switch (signal._tag) {
-                    case HandoffSignal.OP_EMIT: {
+                Ref.set(consumed, true),
+                Effect.zipRight(Effect.succeed(pipe(
+                  core.write(leftovers),
+                  core.flatMap(() => handoffConsumer)
+                )))
+              )
+            }
+            return pipe(
+              Handoff.take(handoff),
+              Effect.map((signal) => {
+                switch (signal._tag) {
+                  case HandoffSignal.OP_EMIT: {
+                    return pipe(
+                      core.fromEffect(Ref.set(consumed, true)),
+                      channel.zipRight(core.write(signal.elements)),
+                      channel.zipRight(core.fromEffect(Ref.get(endAfterEmit))),
+                      core.flatMap((bool) => bool ? core.unit : handoffConsumer)
+                    )
+                  }
+                  case HandoffSignal.OP_HALT: {
+                    return core.failCause(signal.cause)
+                  }
+                  case HandoffSignal.OP_END: {
+                    if (signal.reason._tag === SinkEndReason.OP_SCHEDULE_END) {
                       return pipe(
-                        core.fromEffect(Ref.set(consumed, true)),
-                        channel.zipRight(core.write(signal.elements)),
-                        channel.zipRight(core.fromEffect(Ref.get(endAfterEmit))),
-                        core.flatMap((bool) => bool ? core.unit : handoffConsumer)
-                      )
-                    }
-                    case HandoffSignal.OP_HALT: {
-                      return core.failCause(signal.cause)
-                    }
-                    case HandoffSignal.OP_END: {
-                      if (signal.reason._tag === SinkEndReason.OP_SCHEDULE_END) {
-                        return pipe(
-                          Ref.get(consumed),
-                          Effect.map((bool) =>
-                            bool ?
+                        Ref.get(consumed),
+                        Effect.map((bool) =>
+                          bool ?
+                            core.fromEffect(
+                              pipe(
+                                Ref.set(sinkEndReason, SinkEndReason.ScheduleEnd),
+                                Effect.zipRight(Ref.set(endAfterEmit, true))
+                              )
+                            ) :
+                            pipe(
                               core.fromEffect(
                                 pipe(
                                   Ref.set(sinkEndReason, SinkEndReason.ScheduleEnd),
                                   Effect.zipRight(Ref.set(endAfterEmit, true))
                                 )
-                              ) :
-                              pipe(
-                                core.fromEffect(
-                                  pipe(
-                                    Ref.set(sinkEndReason, SinkEndReason.ScheduleEnd),
-                                    Effect.zipRight(Ref.set(endAfterEmit, true))
-                                  )
-                                ),
-                                core.flatMap(() => handoffConsumer)
-                              )
-                          ),
-                          channel.unwrap
-                        )
-                      }
-                      return pipe(
-                        Ref.set<SinkEndReason.SinkEndReason>(sinkEndReason, signal.reason),
-                        Effect.zipRight(Ref.set(endAfterEmit, true)),
-                        core.fromEffect
+                              ),
+                              core.flatMap(() => handoffConsumer)
+                            )
+                        ),
+                        channel.unwrap
                       )
                     }
+                    return pipe(
+                      Ref.set<SinkEndReason.SinkEndReason>(sinkEndReason, signal.reason),
+                      Effect.zipRight(Ref.set(endAfterEmit, true)),
+                      core.fromEffect
+                    )
                   }
-                })
-              )
-            }),
-            channel.unwrap
-          )
+                }
+              })
+            )
+          }),
+          channel.unwrap
+        )
         const timeout = (lastB: Option.Option<B>): Effect.Effect<C, Option.Option<never>, R2 | R3> =>
           scheduleDriver.next(lastB)
         const scheduledAggregator = (
           sinkFiber: Fiber.RuntimeFiber<readonly [Chunk.Chunk<Chunk.Chunk<A | A2>>, B], E | E2>,
           scheduleFiber: Fiber.RuntimeFiber<C, Option.Option<never>>,
           scope: Scope.Scope
-        ): Channel.Channel<R2 | R3, unknown, unknown, unknown, E | E2, Chunk.Chunk<Either.Either<C, B>>, unknown> => {
+        ): Channel.Channel<Chunk.Chunk<Either.Either<C, B>>, unknown, E | E2, unknown, unknown, unknown, R2 | R3> => {
           const forkSink = pipe(
             Ref.set(consumed, false),
             Effect.zipRight(Ref.set(endAfterEmit, false)),
@@ -303,7 +302,7 @@ export const aggregateWithinEither = dual<
             leftovers: Chunk.Chunk<Chunk.Chunk<A | A2>>,
             b: B,
             c: Option.Option<C>
-          ): Channel.Channel<R2 | R3, unknown, unknown, unknown, E | E2, Chunk.Chunk<Either.Either<C, B>>, unknown> =>
+          ): Channel.Channel<Chunk.Chunk<Either.Either<C, B>>, unknown, E | E2, unknown, unknown, unknown, R2 | R3> =>
             pipe(
               Ref.set(sinkLeftovers, Chunk.flatten(leftovers)),
               Effect.zipRight(
@@ -502,7 +501,7 @@ export const asyncEffect = <A, E = never, R = never>(
               )
             ),
             Effect.map(() => {
-              const loop: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+              const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
                 Queue.take(output),
                 Effect.flatMap(_take.done),
                 Effect.match({
@@ -562,7 +561,7 @@ export const asyncInterrupt = <A, E = never, R = never>(
             ),
             Effect.map(Either.match({
               onLeft: (canceler) => {
-                const loop: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+                const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
                   Queue.take(output),
                   Effect.flatMap(_take.done),
                   Effect.match({
@@ -683,7 +682,7 @@ export const branchAfter = dual<
     suspend(() => {
       const buffering = (
         acc: Chunk.Chunk<A>
-      ): Channel.Channel<R | R2, never, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown> =>
+      ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, never, unknown, unknown, R | R2> =>
         core.readWith({
           onInput: (input) => {
             const nextSize = acc.length + input.length
@@ -699,7 +698,7 @@ export const branchAfter = dual<
       const running = (
         prefix: Chunk.Chunk<A>,
         leftover: Chunk.Chunk<A>
-      ): Channel.Channel<R | R2, never, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown> =>
+      ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, never, unknown, unknown, R | R2> =>
         core.pipeTo(
           channel.zipRight(
             core.write(leftover),
@@ -843,7 +842,7 @@ export const buffer = dual<
   return new StreamImpl(
     channel.unwrapScoped(
       Effect.map(queue, (queue) => {
-        const process: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+        const process: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
           core.fromEffect(Queue.take(queue)),
           core.flatMap(Exit.match({
             onFailure: (cause) =>
@@ -883,7 +882,7 @@ export const bufferChunks = dual<
   return new StreamImpl(
     channel.unwrapScoped(
       Effect.map(queue, (queue) => {
-        const process: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+        const process: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
           core.fromEffect(Queue.take(queue)),
           core.flatMap(_take.match({
             onEnd: () => core.unit,
@@ -946,7 +945,7 @@ const bufferUnbounded = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A
   return new StreamImpl(
     channel.unwrapScoped(
       Effect.map(queue, (queue) => {
-        const process: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+        const process: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
           core.fromEffect(Queue.take(queue)),
           core.flatMap(_take.match({
             onEnd: () => core.unit,
@@ -962,13 +961,13 @@ const bufferUnbounded = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A
 
 const bufferSignal = <A, E, R>(
   scoped: Effect.Effect<Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>, never, Scope.Scope>,
-  bufferChannel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void>
-): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> => {
+  bufferChannel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown, R>
+): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown, R> => {
   const producer = (
     queue: Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>,
     ref: Ref.Ref<Deferred.Deferred<void, never>>
-  ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, never, unknown> => {
-    const terminate = (take: Take.Take<A, E>): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, never, unknown> =>
+  ): Channel.Channel<never, Chunk.Chunk<A>, never, E, unknown, unknown, R> => {
+    const terminate = (take: Take.Take<A, E>): Channel.Channel<never, Chunk.Chunk<A>, never, E, unknown, unknown, R> =>
       pipe(
         Ref.get(ref),
         Effect.tap(Deferred.await),
@@ -1004,8 +1003,8 @@ const bufferSignal = <A, E, R>(
   }
   const consumer = (
     queue: Queue.Queue<readonly [Take.Take<A, E>, Deferred.Deferred<void, never>]>
-  ): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> => {
-    const process: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+  ): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown, R> => {
+    const process: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
       core.fromEffect(Queue.take(queue)),
       core.flatMap(([take, deferred]) =>
         channel.zipRight(
@@ -1218,7 +1217,7 @@ export const changesWith = dual<
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, f: (x: A, y: A) => boolean): Stream.Stream<A, E, R> => {
   const writer = (
     last: Option.Option<A>
-  ): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, void> =>
+  ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, void, unknown> =>
     core.readWithCause({
       onInput: (input: Chunk.Chunk<A>) => {
         const [newLast, newChunk] = Chunk.reduce(
@@ -1259,7 +1258,7 @@ export const changesWithEffect = dual<
   ): Stream.Stream<A, E2 | E, R2 | R> => {
     const writer = (
       last: Option.Option<A>
-    ): Channel.Channel<R | R2, E | E2, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> =>
+    ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E | E2, void, unknown, R | R2> =>
       core.readWithCause({
         onInput: (input: Chunk.Chunk<A>) =>
           pipe(
@@ -1358,7 +1357,7 @@ export const combine = dual<
   const producer = <Err, Elem>(
     handoff: Handoff.Handoff<Exit.Exit<Elem, Option.Option<Err>>>,
     latch: Handoff.Handoff<void>
-  ): Channel.Channel<R, Err, Elem, unknown, never, never, unknown> =>
+  ): Channel.Channel<never, Elem, never, Err, unknown, unknown, R> =>
     pipe(
       core.fromEffect(Handoff.take(latch)),
       channel.zipRight(core.readWithCause({
@@ -1462,7 +1461,7 @@ export const combineChunks = dual<
   const producer = <Err, Elem>(
     handoff: Handoff.Handoff<Take.Take<Elem, Err>>,
     latch: Handoff.Handoff<void>
-  ): Channel.Channel<R, Err, Chunk.Chunk<Elem>, unknown, never, never, unknown> =>
+  ): Channel.Channel<never, Chunk.Chunk<Elem>, never, Err, unknown, unknown, R> =>
     channel.zipRight(
       core.fromEffect(Handoff.take(latch)),
       core.readWithCause({
@@ -1481,7 +1480,7 @@ export const combineChunks = dual<
               _take.failCause(cause)
             )
           ),
-        onDone: (): Channel.Channel<R, Err, Chunk.Chunk<Elem>, unknown, never, never, unknown> =>
+        onDone: (): Channel.Channel<never, Chunk.Chunk<Elem>, never, Err, unknown, unknown, R> =>
           core.fromEffect(Handoff.offer<Take.Take<Elem, Err>>(handoff, _take.end))
       })
     )
@@ -1643,7 +1642,7 @@ export const debounce = dual<
           Handoff.make<HandoffSignal.HandoffSignal<E, A>>(),
           Effect.map((handoff) => {
             const enqueue = (last: Chunk.Chunk<A>): Effect.Effect<
-              Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
+              Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown>
             > =>
               pipe(
                 Clock.sleep(duration),
@@ -1652,7 +1651,7 @@ export const debounce = dual<
                 grafter,
                 Effect.map((fiber) => consumer(DebounceState.previous(fiber)))
               )
-            const producer: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, never, unknown> = core
+            const producer: Channel.Channel<never, Chunk.Chunk<A>, E, E, unknown, unknown> = core
               .readWithCause({
                 onInput: (input: Chunk.Chunk<A>) =>
                   Option.match(Chunk.last(input), {
@@ -1682,7 +1681,7 @@ export const debounce = dual<
               })
             const consumer = (
               state: DebounceState.DebounceState<E, A>
-            ): Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> => {
+            ): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown> => {
               switch (state._tag) {
                 case DebounceState.OP_NOT_STARTED: {
                   return pipe(
@@ -1758,18 +1757,17 @@ export const debounce = dual<
                 }
               }
             }
-            const debounceChannel: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> =
-              pipe(
-                channel.fromInput(input),
-                core.pipeTo(producer),
-                channelExecutor.run,
-                Effect.forkScoped,
-                Effect.as(pipe(
-                  consumer(DebounceState.notStarted),
-                  core.embedInput<E, Chunk.Chunk<A>, unknown>(input as any)
-                )),
-                channel.unwrapScoped
-              )
+            const debounceChannel: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown> = pipe(
+              channel.fromInput(input),
+              core.pipeTo(producer),
+              channelExecutor.run,
+              Effect.forkScoped,
+              Effect.as(pipe(
+                consumer(DebounceState.notStarted),
+                core.embedInput<E, Chunk.Chunk<A>, unknown>(input as any)
+              )),
+              channel.unwrapScoped
+            )
             return new StreamImpl(pipe(toChannel(self), core.pipeTo(debounceChannel)))
           })
         )
@@ -2119,7 +2117,7 @@ export const drop = dual<
   (n: number) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>,
   <A, E, R>(self: Stream.Stream<A, E, R>, n: number) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, n: number): Stream.Stream<A, E, R> => {
-  const loop = (r: number): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> =>
+  const loop = (r: number): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, never, never, unknown, unknown> =>
     core.readWith({
       onInput: (input: Chunk.Chunk<A>) => {
         const dropped = pipe(input, Chunk.drop(r))
@@ -2130,7 +2128,7 @@ export const drop = dual<
         }
         return pipe(
           core.write(dropped),
-          channel.zipRight(channel.identityChannel<never, Chunk.Chunk<A>, unknown>())
+          channel.zipRight(channel.identityChannel<Chunk.Chunk<A>, never, unknown>())
         )
       },
       onFailure: core.fail,
@@ -2149,7 +2147,7 @@ export const dropRight = dual<
   }
   return suspend(() => {
     const queue = new RingBuffer<A>(n)
-    const reader: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, void> = core.readWith({
+    const reader: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, void, unknown> = core.readWith({
       onInput: (input: Chunk.Chunk<A>) => {
         const outputs = pipe(
           input,
@@ -2193,7 +2191,7 @@ export const dropUntilEffect = dual<
     self: Stream.Stream<A, E, R>,
     predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
   ): Stream.Stream<A, E2 | E, R2 | R> => {
-    const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core.readWith({
+    const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> = core.readWith({
       onInput: (input: Chunk.Chunk<A>) =>
         pipe(
           Effect.dropUntil(input, predicate),
@@ -2205,7 +2203,7 @@ export const dropUntilEffect = dual<
             }
             return pipe(
               core.write(leftover),
-              channel.zipRight(channel.identityChannel<E | E2, Chunk.Chunk<A>, unknown>())
+              channel.zipRight(channel.identityChannel<Chunk.Chunk<A>, E | E2, unknown>())
             )
           }),
           channel.unwrap
@@ -2222,7 +2220,7 @@ export const dropWhile = dual<
   <A>(predicate: Predicate<NoInfer<A>>) => <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>,
   <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>) => Stream.Stream<A, E, R>
 >(2, <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R> => {
-  const loop: Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> = core.readWith({
+  const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, never, never, unknown, unknown> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) => {
       const output = Chunk.dropWhile(input, predicate)
       if (Chunk.isEmpty(output)) {
@@ -2230,7 +2228,7 @@ export const dropWhile = dual<
       }
       return channel.zipRight(
         core.write(output),
-        channel.identityChannel<never, Chunk.Chunk<A>, unknown>()
+        channel.identityChannel<Chunk.Chunk<A>, never, unknown>()
       )
     },
     onFailure: core.fail,
@@ -2254,7 +2252,7 @@ export const dropWhileEffect = dual<
     self: Stream.Stream<A, E, R>,
     predicate: (a: A) => Effect.Effect<boolean, E2, R2>
   ): Stream.Stream<A, E2 | E, R2 | R> => {
-    const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core.readWith({
+    const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> = core.readWith({
       onInput: (input: Chunk.Chunk<A>) =>
         pipe(
           Effect.dropWhile(input, predicate),
@@ -2266,7 +2264,7 @@ export const dropWhileEffect = dual<
             }
             return channel.zipRight(
               core.write(leftover),
-              channel.identityChannel<E | E2, Chunk.Chunk<A>, unknown>()
+              channel.identityChannel<Chunk.Chunk<A>, E | E2, unknown>()
             )
           }),
           channel.unwrap
@@ -2376,7 +2374,7 @@ export const filterEffect = dual<
   ): Stream.Stream<A, E2 | E, R2 | R> => {
     const loop = (
       iterator: Iterator<A>
-    ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> => {
+    ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> => {
       const next = iterator.next()
       if (next.done) {
         return core.readWithCause({
@@ -2430,7 +2428,7 @@ export const filterMapEffect = dual<
     suspend(() => {
       const loop = (
         iterator: Iterator<A>
-      ): Channel.Channel<R | R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A2>, unknown> => {
+      ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R | R2> => {
         const next = iterator.next()
         if (next.done) {
           return core.readWithCause({
@@ -2462,7 +2460,7 @@ export const filterMapWhile = dual<
 >(
   2,
   <R, E, A, A2>(self: Stream.Stream<A, E, R>, pf: (a: A) => Option.Option<A2>) => {
-    const loop: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A2>, unknown> = core.readWith({
+    const loop: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E, E, unknown, unknown> = core.readWith({
       onInput: (input: Chunk.Chunk<A>) => {
         const mapped = Chunk.filterMapWhile(input, pf)
         if (mapped.length === input.length) {
@@ -2495,7 +2493,7 @@ export const filterMapWhileEffect = dual<
     suspend(() => {
       const loop = (
         iterator: Iterator<A>
-      ): Channel.Channel<R | R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A2>, unknown> => {
+      ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R | R2> => {
         const next = iterator.next()
         if (next.done) {
           return core.readWithCause({
@@ -2531,7 +2529,7 @@ export const find: {
   <R, E, A, B extends A>(self: Stream.Stream<A, E, R>, refinement: Refinement<A, B>): Stream.Stream<B, E, R>
   <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R>
 } = dual(2, <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R> => {
-  const loop: Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> = core.readWith({
+  const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown, R> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) =>
       Option.match(Chunk.findFirst(input, predicate), {
         onNone: () => loop,
@@ -2558,7 +2556,7 @@ export const findEffect: {
     self: Stream.Stream<A, E, R>,
     predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
   ): Stream.Stream<A, E | E2, R | R2> => {
-    const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core.readWith({
+    const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> = core.readWith({
       onInput: (input: Chunk.Chunk<A>) =>
         pipe(
           Effect.findFirst(input, predicate),
@@ -2626,7 +2624,7 @@ export const flatMap = dual<
                 as,
                 Chunk.map((a) => toChannel(f(a))),
                 Chunk.reduce(
-                  core.unit as Channel.Channel<R2, unknown, unknown, unknown, E2, Chunk.Chunk<A2>, unknown>,
+                  core.unit as Channel.Channel<Chunk.Chunk<A2>, unknown, E2, unknown, unknown, unknown, R2>,
                   (left, right) => pipe(left, channel.zipRight(right))
                 )
               )
@@ -2712,7 +2710,7 @@ export const flatten = dual<
 
 /** @internal */
 export const flattenChunks = <A, E, R>(self: Stream.Stream<Chunk.Chunk<A>, E, R>): Stream.Stream<A, E, R> => {
-  const flatten: Channel.Channel<never, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown, E, Chunk.Chunk<A>, unknown> = core
+  const flatten: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<Chunk.Chunk<A>>, E, E, unknown, unknown> = core
     .readWithCause({
       onInput: (chunks: Chunk.Chunk<Chunk.Chunk<A>>) =>
         core.flatMap(
@@ -2768,7 +2766,7 @@ export const flattenExitOption = <R, E, E2, A>(
 ): Stream.Stream<A, E | E2, R> => {
   const processChunk = (
     chunk: Chunk.Chunk<Exit.Exit<A, Option.Option<E2>>>,
-    cont: Channel.Channel<R, E, Chunk.Chunk<Exit.Exit<A, Option.Option<E2>>>, unknown, E | E2, Chunk.Chunk<A>, unknown>
+    cont: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<Exit.Exit<A, Option.Option<E2>>>, E | E2, E, unknown, unknown, R>
   ) => {
     const [toEmit, rest] = pipe(chunk, Chunk.splitWhere((exit) => !Exit.isSuccess(exit)))
     const next = pipe(
@@ -2798,13 +2796,13 @@ export const flattenExitOption = <R, E, E2, A>(
     )
   }
   const process: Channel.Channel<
-    R,
-    E,
+    Chunk.Chunk<A>,
     Chunk.Chunk<Exit.Exit<A, Option.Option<E2>>>,
-    unknown,
     E | E2,
-    Chunk.Chunk<A>,
-    unknown
+    E,
+    unknown,
+    unknown,
+    R
   > = core.readWithCause({
     onInput: (chunk: Chunk.Chunk<Exit.Exit<A, Option.Option<E2>>>) => processChunk(chunk, process),
     onFailure: (cause) => core.failCause<E | E2>(cause),
@@ -2849,13 +2847,13 @@ export const fromAsyncIterable = <A, E>(
 
 /** @internal */
 export const fromChannel = <A, E, R>(
-  channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
+  channel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>
 ): Stream.Stream<A, E, R> => new StreamImpl(channel)
 
 /** @internal */
 export const toChannel = <A, E, R>(
   stream: Stream.Stream<A, E, R>
-): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> => {
+): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R> => {
   if ("channel" in stream) {
     return (stream as StreamImpl<A, E, R>).channel
   } else if (Effect.isEffect(stream)) {
@@ -2984,7 +2982,7 @@ export const fromIteratorSucceed = <A>(
       let builder: Array<A> = []
       const loop = (
         iterator: Iterator<A>
-      ): Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<A>, unknown> =>
+      ): Channel.Channel<Chunk.Chunk<A>, unknown, never, unknown, unknown, unknown> =>
         pipe(
           Effect.sync(() => {
             let next: IteratorResult<A, any> = iterator.next()
@@ -3206,7 +3204,7 @@ export const groupAdjacentBy = dual<
 
     const groupAdjacent = (
       state: Option.Option<Output>
-    ): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<Output>, unknown> =>
+    ): Channel.Channel<Chunk.Chunk<Output>, Chunk.Chunk<A>, never, never, unknown, unknown> =>
       core.readWithCause({
         onInput: (input: Chunk.Chunk<A>) => {
           const [updatedState, output] = groupAdjacentByChunk(state, input)
@@ -3277,7 +3275,7 @@ export const haltWhen = dual<
   ): Stream.Stream<A, E | E2, R | R2> => {
     const writer = (
       fiber: Fiber.Fiber<_, E2>
-    ): Channel.Channel<R2, E | E2, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> =>
+    ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E | E2, void, unknown, R2> =>
       pipe(
         Fiber.poll(fiber),
         Effect.map(Option.match({
@@ -3321,7 +3319,7 @@ export const haltWhenDeferred = dual<
 >(
   2,
   <R, E, A, E2, _>(self: Stream.Stream<A, E, R>, deferred: Deferred.Deferred<_, E2>): Stream.Stream<A, E | E2, R> => {
-    const writer: Channel.Channel<R, E | E2, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> = pipe(
+    const writer: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E | E2, void, unknown, R> = pipe(
       Deferred.poll(deferred),
       Effect.map(Option.match({
         onNone: () =>
@@ -3345,7 +3343,7 @@ export const haltWhenDeferred = dual<
 /** @internal */
 export const identityStream = <A, E = never, R = never>(): Stream.Stream<A, E, R> =>
   new StreamImpl(
-    channel.identityChannel() as Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
+    channel.identityChannel() as Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown>
   )
 
 /** @internal */
@@ -3385,7 +3383,7 @@ export const interleaveWith = dual<
   ): Stream.Stream<A2 | A, E2 | E3 | E, R2 | R3 | R> => {
     const producer = (
       handoff: Handoff.Handoff<Take.Take<A | A2, E | E2 | E3>>
-    ): Channel.Channel<R | R2 | R3, E | E2 | E3, A | A2, unknown, never, never, void> =>
+    ): Channel.Channel<never, A | A2, never, E | E2 | E3, void, unknown, R | R2 | R3> =>
       core.readWithCause({
         onInput: (value: A | A2) =>
           core.flatMap(
@@ -3433,7 +3431,7 @@ export const interleaveWith = dual<
             const process = (
               leftDone: boolean,
               rightDone: boolean
-            ): Channel.Channel<R, E | E2 | E3, boolean, unknown, E | E2 | E3, Chunk.Chunk<A | A2>, void> =>
+            ): Channel.Channel<Chunk.Chunk<A | A2>, boolean, E | E2 | E3, E | E2 | E3, void, unknown, R> =>
               core.readWithCause({
                 onInput: (bool: boolean) => {
                   if (bool && !leftDone) {
@@ -3485,7 +3483,7 @@ export const intersperse = dual<
         core.suspend(() => {
           const writer = (
             isFirst: boolean
-          ): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A | A2>, unknown> =>
+          ): Channel.Channel<Chunk.Chunk<A | A2>, Chunk.Chunk<A>, E, E, unknown, unknown> =>
             core.readWithCause({
               onInput: (chunk: Chunk.Chunk<A>) => {
                 const builder: Array<A | A2> = []
@@ -3615,7 +3613,7 @@ export const mapAccum = dual<
     s: S,
     f: (s: S, a: A) => readonly [S, A2]
   ): Stream.Stream<A2, E, R> => {
-    const accumulator = (s: S): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A2>, void> =>
+    const accumulator = (s: S): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E, E, void, unknown> =>
       core.readWith({
         onInput: (input: Chunk.Chunk<A>) => {
           const [nextS, chunk] = Chunk.mapAccum(input, s, f)
@@ -3652,7 +3650,7 @@ export const mapAccumEffect = dual<
     suspend(() => {
       const accumulator = (
         s: S
-      ): Channel.Channel<R | R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A2>, unknown> =>
+      ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R | R2> =>
         core.readWith({
           onInput: (input: Chunk.Chunk<A>) =>
             pipe(
@@ -3816,7 +3814,7 @@ export const mapEffectSequential = dual<
   ): Stream.Stream<A2, E | E2, R | R2> => {
     const loop = (
       iterator: Iterator<A>
-    ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A2>, unknown> => {
+    ): Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> => {
       const next = iterator.next()
       if (next.done) {
         return core.readWithCause({
@@ -4176,7 +4174,7 @@ export const orElseIfEmptyStream = dual<
     self: Stream.Stream<A, E, R>,
     stream: LazyArg<Stream.Stream<A2, E2, R2>>
   ): Stream.Stream<A2 | A, E2 | E, R2 | R> => {
-    const writer: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A | A2>, unknown> = core.readWith(
+    const writer: Channel.Channel<Chunk.Chunk<A | A2>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> = core.readWith(
       {
         onInput: (input: Chunk.Chunk<A>) => {
           if (Chunk.isEmpty(input)) {
@@ -4184,7 +4182,7 @@ export const orElseIfEmptyStream = dual<
           }
           return pipe(
             core.write(input),
-            channel.zipRight(channel.identityChannel<E, Chunk.Chunk<A>, unknown>())
+            channel.zipRight(channel.identityChannel<Chunk.Chunk<A>, E, unknown>())
           )
         },
         onFailure: core.fail,
@@ -4217,7 +4215,7 @@ export const paginateChunk = <S, A>(
   s: S,
   f: (s: S) => readonly [Chunk.Chunk<A>, Option.Option<S>]
 ): Stream.Stream<A> => {
-  const loop = (s: S): Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<A>, unknown> => {
+  const loop = (s: S): Channel.Channel<Chunk.Chunk<A>, unknown, never, unknown, unknown, unknown> => {
     const page = f(s)
     return Option.match(page[1], {
       onNone: () => channel.zipRight(core.write(page[0]), core.unit),
@@ -4232,7 +4230,7 @@ export const paginateChunkEffect = <S, R, E, A>(
   s: S,
   f: (s: S) => Effect.Effect<readonly [Chunk.Chunk<A>, Option.Option<S>], E, R>
 ): Stream.Stream<A, E, R> => {
-  const loop = (s: S): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> =>
+  const loop = (s: S): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R> =>
     channel.unwrap(
       Effect.map(f(s), ([chunk, option]) =>
         Option.match(option, {
@@ -4296,15 +4294,7 @@ export const peel = dual<
                 _sink.fail(error)
               ),
             onSuccess: ([z, leftovers]) => {
-              const loop: Channel.Channel<
-                never,
-                E,
-                Chunk.Chunk<A>,
-                unknown,
-                E | E2,
-                Chunk.Chunk<A>,
-                void
-              > = core
+              const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, void, unknown> = core
                 .readWithCause({
                   onInput: (elements) =>
                     core.flatMap(
@@ -4339,7 +4329,7 @@ export const peel = dual<
             }
           })
 
-          const producer: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = pipe(
+          const producer: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = pipe(
             Handoff.take(handoff),
             Effect.map((signal) => {
               switch (signal._tag) {
@@ -4524,34 +4514,34 @@ export const pipeThrough = dual<
 /** @internal */
 export const pipeThroughChannel = dual<
   <R2, E, E2, A, A2>(
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ) => <R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2, R2 | R>,
   <R, R2, E, E2, A, A2>(
     self: Stream.Stream<A, E, R>,
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ) => Stream.Stream<A2, E2, R2 | R>
 >(
   2,
   <R, R2, E, E2, A, A2>(
     self: Stream.Stream<A, E, R>,
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): Stream.Stream<A2, E2, R2 | R> => new StreamImpl(pipe(toChannel(self), core.pipeTo(channel)))
 )
 
 /** @internal */
 export const pipeThroughChannelOrFail = dual<
   <R2, E, E2, A, A2>(
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ) => <R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E | E2, R2 | R>,
   <R, R2, E, E2, A, A2>(
     self: Stream.Stream<A, E, R>,
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ) => Stream.Stream<A2, E | E2, R2 | R>
 >(
   2,
   <R, R2, E, E2, A, A2>(
     self: Stream.Stream<A, E, R>,
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
   ): Stream.Stream<A2, E | E2, R2 | R> => new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(chan)))
 )
 
@@ -4715,7 +4705,7 @@ export const range = (min: number, max: number, chunkSize = DefaultChunkSize): S
       min: number,
       max: number,
       chunkSize: number
-    ): Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<number>, unknown> => {
+    ): Channel.Channel<Chunk.Chunk<number>, unknown, never, unknown, unknown, unknown> => {
       const remaining = max - min + 1
       if (remaining > chunkSize) {
         return pipe(
@@ -4743,7 +4733,7 @@ export const rechunk = dual<
 const rechunkProcess = <E, A>(
   rechunker: StreamRechunker<E, A>,
   target: number
-): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> =>
+): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown> =>
   core.readWithCause({
     onInput: (chunk: Chunk.Chunk<A>) => {
       if (chunk.length === target && rechunker.isEmpty()) {
@@ -4803,7 +4793,7 @@ class StreamRechunker<in out E, out A> {
     return undefined
   }
 
-  emitIfNotEmpty(): Channel.Channel<never, E, unknown, unknown, E, Chunk.Chunk<A>, void> {
+  emitIfNotEmpty(): Channel.Channel<Chunk.Chunk<A>, unknown, E, E, void, unknown> {
     if (this.pos !== 0) {
       return core.write(Chunk.unsafeFromArray(this.builder))
     }
@@ -4972,7 +4962,7 @@ export const repeatElementsWith = dual<
       Effect.map((driver) => {
         const feed = (
           input: Chunk.Chunk<A>
-        ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, void> =>
+        ): Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, void, unknown, R2> =>
           Option.match(Chunk.head(input), {
             onNone: () => loop,
             onSome: (a) =>
@@ -4984,13 +4974,13 @@ export const repeatElementsWith = dual<
         const step = (
           input: Chunk.Chunk<A>,
           a: A
-        ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, void> => {
+        ): Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, void, unknown, R2> => {
           const advance = pipe(
             driver.next(a),
             Effect.as(pipe(core.write(Chunk.of(options.onElement(a))), core.flatMap(() => step(input, a))))
           )
           const reset: Effect.Effect<
-            Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, void>,
+            Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, void, unknown, R2>,
             never,
             R2
           > = pipe(
@@ -5010,7 +5000,7 @@ export const repeatElementsWith = dual<
           )
           return pipe(advance, Effect.orElse(() => reset), channel.unwrap)
         }
-        const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, void> = core.readWith({
+        const loop: Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, void, unknown, R2> = core.readWith({
           onInput: feed,
           onFailure: core.fail,
           onDone: () => core.unit
@@ -5061,7 +5051,7 @@ export const repeatWith = dual<
       Effect.map((driver) => {
         const scheduleOutput = pipe(driver.last, Effect.orDie, Effect.map(options.onSchedule))
         const process = pipe(self, map(options.onElement), toChannel)
-        const loop: Channel.Channel<R | R2, unknown, unknown, unknown, E, Chunk.Chunk<C>, void> = channel.unwrap(
+        const loop: Channel.Channel<Chunk.Chunk<C>, unknown, E, unknown, void, unknown, R | R2> = channel.unwrap(
           Effect.match(driver.next(void 0), {
             onFailure: () => core.unit,
             onSuccess: () =>
@@ -5428,7 +5418,7 @@ export const runIntoQueueElementsScoped = dual<
   self: Stream.Stream<A, E, R>,
   queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>
 ): Effect.Effect<void, never, Scope.Scope | R> => {
-  const writer: Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, Exit.Exit<A, Option.Option<E>>, unknown> = core
+  const writer: Channel.Channel<Exit.Exit<A, Option.Option<E>>, Chunk.Chunk<A>, never, E, unknown, unknown, R> = core
     .readWithCause({
       onInput: (input: Chunk.Chunk<A>) =>
         core.flatMap(
@@ -5459,7 +5449,7 @@ export const runIntoQueueScoped = dual<
   self: Stream.Stream<A, E, R>,
   queue: Queue.Enqueue<Take.Take<A, E>>
 ): Effect.Effect<void, never, Scope.Scope | R> => {
-  const writer: Channel.Channel<R, E, Chunk.Chunk<A>, unknown, never, Take.Take<A, E>, unknown> = core
+  const writer: Channel.Channel<Take.Take<A, E>, Chunk.Chunk<A>, never, E, unknown, unknown, R> = core
     .readWithCause({
       onInput: (input: Chunk.Chunk<A>) => core.flatMap(core.write(_take.chunk(input)), () => writer),
       onFailure: (cause) => core.write(_take.failCause(cause)),
@@ -5606,7 +5596,7 @@ export const scheduleWith = dual<
     const loop = (
       driver: Schedule.ScheduleDriver<R2, A0, B>,
       iterator: Iterator<A>
-    ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<C>, unknown> => {
+    ): Channel.Channel<Chunk.Chunk<C>, Chunk.Chunk<A>, E, E, unknown, unknown, R2> => {
       const next = iterator.next()
       if (next.done) {
         return core.readWithCause({
@@ -5749,7 +5739,7 @@ export const slidingSize = dual<
       const queue = new RingBuffer<A>(chunkSize)
       const emitOnStreamEnd = (
         queueSize: number,
-        channelEnd: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown>
+        channelEnd: Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown>
       ) => {
         if (queueSize < chunkSize) {
           const items = queue.toChunk()
@@ -5767,7 +5757,7 @@ export const slidingSize = dual<
       }
       const reader = (
         queueSize: number
-      ): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown> =>
+      ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown> =>
         core.readWithCause({
           onInput: (input: Chunk.Chunk<A>) =>
             core.flatMap(
@@ -5799,7 +5789,7 @@ export const split = dual<
   const split = (
     leftovers: Chunk.Chunk<A>,
     input: Chunk.Chunk<A>
-  ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown> => {
+  ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> => {
     const [chunk, remaining] = pipe(leftovers, Chunk.appendAll(input), Chunk.splitWhere(predicate))
     if (Chunk.isEmpty(chunk) || Chunk.isEmpty(remaining)) {
       return loop(pipe(chunk, Chunk.appendAll(pipe(remaining, Chunk.drop(1)))))
@@ -5811,7 +5801,7 @@ export const split = dual<
   }
   const loop = (
     leftovers: Chunk.Chunk<A>
-  ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown> =>
+  ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> =>
     core.readWith({
       onInput: (input: Chunk.Chunk<A>) => split(leftovers, input),
       onFailure: core.fail,
@@ -5839,7 +5829,7 @@ export const splitOnChunk = dual<
   const next = (
     leftover: Option.Option<Chunk.Chunk<A>>,
     delimiterIndex: number
-  ): Channel.Channel<R, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<Chunk.Chunk<A>>, unknown> =>
+  ): Channel.Channel<Chunk.Chunk<Chunk.Chunk<A>>, Chunk.Chunk<A>, E, E, unknown, unknown, R> =>
     core.readWithCause({
       onInput: (inputChunk: Chunk.Chunk<A>) => {
         let buffer: Array<Chunk.Chunk<A>> | undefined
@@ -5954,7 +5944,7 @@ export const splitLines = <R, E>(self: Stream.Stream<string, E, R>): Stream.Stre
       })
       return Chunk.unsafeFromArray(chunkBuilder)
     }
-    const loop: Channel.Channel<R, E, Chunk.Chunk<string>, unknown, E, Chunk.Chunk<string>, unknown> = core
+    const loop: Channel.Channel<Chunk.Chunk<string>, Chunk.Chunk<string>, E, E, unknown, unknown, R> = core
       .readWithCause({
         onInput: (input: Chunk.Chunk<string>) => {
           const out = splitLinesChunk(input)
@@ -5992,7 +5982,7 @@ export const take = dual<
   if (!Number.isInteger(n)) {
     return die(new Cause.IllegalArgumentException(`${n} must be an integer`))
   }
-  const loop = (n: number): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> =>
+  const loop = (n: number): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, never, never, unknown, unknown> =>
     core.readWith({
       onInput: (input: Chunk.Chunk<A>) => {
         const taken = pipe(input, Chunk.take(Math.min(n, Number.POSITIVE_INFINITY)))
@@ -6026,7 +6016,7 @@ export const takeRight = dual<
     pipe(
       Effect.succeed(new RingBuffer<A>(n)),
       Effect.map((queue) => {
-        const reader: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, void> = core.readWith({
+        const reader: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, void, unknown> = core.readWith({
           onInput: (input: Chunk.Chunk<A>) => {
             for (const element of input) {
               queue.put(element)
@@ -6048,7 +6038,7 @@ export const takeUntil: {
   <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
   <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R>
 } = dual(2, <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R> => {
-  const loop: Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> = core.readWith({
+  const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, never, never, unknown, unknown> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) => {
       const taken = pipe(input, Chunk.takeWhile((a) => !predicate(a)))
       const last = pipe(input, Chunk.drop(taken.length), Chunk.take(1))
@@ -6080,7 +6070,7 @@ export const takeUntilEffect: {
   ): Stream.Stream<A, E | E2, R | R2> => {
     const loop = (
       iterator: Iterator<A>
-    ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> => {
+    ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> => {
       const next = iterator.next()
       if (next.done) {
         return core.readWithCause({
@@ -6115,7 +6105,7 @@ export const takeWhile: {
   <R, E, A, B extends A>(self: Stream.Stream<A, E, R>, refinement: Refinement<A, B>): Stream.Stream<B, E, R>
   <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R>
 } = dual(2, <A, E, R>(self: Stream.Stream<A, E, R>, predicate: Predicate<A>): Stream.Stream<A, E, R> => {
-  const loop: Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> = core.readWith({
+  const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, never, never, unknown, unknown> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) => {
       const taken = pipe(input, Chunk.takeWhile(predicate))
       const more = taken.length === input.length
@@ -6206,7 +6196,7 @@ export const tapErrorCause: {
     self: Stream.Stream<A, E, R>,
     f: (cause: Cause.Cause<E>) => Effect.Effect<_, E2, R2>
   ): Stream.Stream<A, E | E2, R | R2> => {
-    const loop: Channel.Channel<R | R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core
+    const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R | R2> = core
       .readWithCause({
         onInput: (chunk) => core.flatMap(core.write(chunk), () => loop),
         onFailure: (cause) => core.fromEffect(Effect.zipRight(f(cause), Effect.failCause(cause))),
@@ -6236,7 +6226,7 @@ export const tapSink = dual<
       fromEffect(Effect.all([Queue.bounded<Take.Take<A, E | E2>>(1), Deferred.make<void>()])),
       flatMap(([queue, deferred]) => {
         const right = flattenTake(fromQueue(queue, { maxChunkSize: 1 }))
-        const loop: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown> = core
+        const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2> = core
           .readWithCause({
             onInput: (chunk: Chunk.Chunk<A>) =>
               pipe(
@@ -6245,7 +6235,7 @@ export const tapSink = dual<
                   onFailure: () => core.flatMap(core.write(chunk), () => channel.identityChannel()),
                   onSuccess: () => core.flatMap(core.write(chunk), () => loop)
                 })
-              ) as Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, unknown>,
+              ) as Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, unknown, unknown, R2>,
             onFailure: (cause: Cause.Cause<E | E2>) =>
               pipe(
                 core.fromEffect(Queue.offer(queue, _take.failCause(cause))),
@@ -6374,7 +6364,7 @@ const throttleEnforceEffect = <R, E, A, R2, E2>(
   const loop = (
     tokens: number,
     timestampMillis: number
-  ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> =>
+  ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, void, unknown, R2> =>
     core.readWithCause({
       onInput: (input: Chunk.Chunk<A>) =>
         pipe(
@@ -6417,7 +6407,7 @@ const throttleShapeEffect = <R, E, A, R2, E2>(
   const loop = (
     tokens: number,
     timestampMillis: number
-  ): Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<A>, void> =>
+  ): Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, void, unknown, R2> =>
     core.readWithCause({
       onInput: (input: Chunk.Chunk<A>) =>
         pipe(
@@ -6724,7 +6714,7 @@ export const transduce = dual<
     const newChannel = core.suspend(() => {
       const leftovers = { ref: Chunk.empty<Chunk.Chunk<A>>() }
       const upstreamDone = { ref: false }
-      const buffer: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> = core.suspend(
+      const buffer: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown> = core.suspend(
         () => {
           const leftover = leftovers.ref
           if (Chunk.isEmpty(leftover)) {
@@ -6744,7 +6734,7 @@ export const transduce = dual<
         leftovers.ref = concatenated
         return concatenated
       }
-      const upstreamMarker: Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, unknown> = core
+      const upstreamMarker: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E, E, unknown, unknown> = core
         .readWith({
           onInput: (input: Chunk.Chunk<A>) => core.flatMap(core.write(input), () => upstreamMarker),
           onFailure: core.fail,
@@ -6756,7 +6746,7 @@ export const transduce = dual<
               core.succeedNow(done)
             )
         })
-      const transducer: Channel.Channel<R | R2, never, Chunk.Chunk<A>, unknown, E | E2, Chunk.Chunk<Z>, void> = pipe(
+      const transducer: Channel.Channel<Chunk.Chunk<Z>, Chunk.Chunk<A>, E | E2, never, void, unknown, R | R2> = pipe(
         sink,
         _sink.toChannel,
         core.collectElements,
@@ -6792,7 +6782,7 @@ export const unfoldChunk = <S, A>(
   s: S,
   f: (s: S) => Option.Option<readonly [Chunk.Chunk<A>, S]>
 ): Stream.Stream<A> => {
-  const loop = (s: S): Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<A>, unknown> =>
+  const loop = (s: S): Channel.Channel<Chunk.Chunk<A>, unknown, never, unknown, unknown, unknown> =>
     Option.match(f(s), {
       onNone: () => core.unit,
       onSome: ([chunk, s]) => core.flatMap(core.write(chunk), () => loop(s))
@@ -6806,7 +6796,7 @@ export const unfoldChunkEffect = <R, E, A, S>(
   f: (s: S) => Effect.Effect<Option.Option<readonly [Chunk.Chunk<A>, S]>, E, R>
 ): Stream.Stream<A, E, R> =>
   suspend(() => {
-    const loop = (s: S): Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> =>
+    const loop = (s: S): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R> =>
       channel.unwrap(
         Effect.map(
           f(s),
@@ -7976,7 +7966,7 @@ export const zipWithNext = <A, E, R>(
 ): Stream.Stream<[A, Option.Option<A>], E, R> => {
   const process = (
     last: Option.Option<A>
-  ): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<readonly [A, Option.Option<A>]>, void> =>
+  ): Channel.Channel<Chunk.Chunk<readonly [A, Option.Option<A>]>, Chunk.Chunk<A>, never, never, void, unknown> =>
     core.readWithCause({
       onInput: (input: Chunk.Chunk<A>) => {
         const [newLast, chunk] = Chunk.mapAccum(
@@ -8145,8 +8135,8 @@ export const let_ = dual<
 // Circular with Channel
 
 /** @internal */
-export const channelToStream = <Env, OutErr, OutElem, OutDone>(
-  self: Channel.Channel<Env, unknown, unknown, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>
+export const channelToStream = <OutElem, OutErr, OutDone, Env>(
+  self: Channel.Channel<Chunk.Chunk<OutElem>, unknown, OutErr, unknown, OutDone, unknown, Env>
 ): Stream.Stream<OutElem, OutErr, Env> => {
   return new StreamImpl(self)
 }
diff --git a/packages/effect/test/Channel/reading.test.ts b/packages/effect/test/Channel/reading.test.ts
index dd7fbf810c..6ef8fdfc4e 100644
--- a/packages/effect/test/Channel/reading.test.ts
+++ b/packages/effect/test/Channel/reading.test.ts
@@ -14,7 +14,7 @@ import { assert, describe } from "vitest"
 
 export const mapper = <A, B>(
   f: (a: A) => B
-): Channel.Channel<never, unknown, A, unknown, never, B, void> => {
+): Channel.Channel<B, A, never, unknown, void, unknown> => {
   return Channel.readWith({
     onInput: (a: A) =>
       Channel.flatMap(
@@ -28,7 +28,7 @@ export const mapper = <A, B>(
 
 export const refWriter = <A>(
   ref: Ref.Ref<ReadonlyArray<A>>
-): Channel.Channel<never, unknown, A, unknown, never, never, void> => {
+): Channel.Channel<never, A, never, unknown, void, unknown> => {
   return Channel.readWith({
     onInput: (a: A) =>
       Channel.flatMap(
@@ -42,7 +42,7 @@ export const refWriter = <A>(
 
 export const refReader = <A>(
   ref: Ref.Ref<Array<A>>
-): Channel.Channel<never, unknown, unknown, unknown, never, A, void> => {
+): Channel.Channel<A, unknown, never, unknown, void, unknown> => {
   return pipe(
     Channel.fromEffect(
       Ref.modify(ref, (array) => {
@@ -104,7 +104,7 @@ describe("Channel", () => {
       const innerChannel = pipe(
         Channel.fromEffect(Ref.make<ReadonlyArray<number>>([])),
         Channel.flatMap((ref) => {
-          const inner = (): Channel.Channel<never, unknown, number, unknown, never, number, void> =>
+          const inner = (): Channel.Channel<number, number, never, unknown, void, unknown> =>
             Channel.readWith({
               onInput: (input: number) =>
                 pipe(
@@ -137,18 +137,16 @@ describe("Channel", () => {
   it.effect("read pipelining 2", () =>
     Effect.gen(function*($) {
       const ref = yield* $(Ref.make<ReadonlyArray<number>>([]))
-      const intProducer: Channel.Channel<
-        never,
-        unknown,
-        unknown,
-        unknown,
-        never,
-        number,
-        void
-      > = Channel.writeAll(1, 2, 3, 4, 5)
+      const intProducer: Channel.Channel<number, unknown, never, unknown, void, unknown> = Channel.writeAll(
+        1,
+        2,
+        3,
+        4,
+        5
+      )
       const readIntsN = (
         n: number
-      ): Channel.Channel<never, unknown, number, unknown, never, number, string> =>
+      ): Channel.Channel<number, number, never, unknown, string, unknown> =>
         n > 0
           ? Channel.readWith({
             onInput: (i: number) => pipe(Channel.write(i), Channel.flatMap(() => readIntsN(n - 1))),
@@ -160,7 +158,7 @@ describe("Channel", () => {
       const sum = (
         label: string,
         n: number
-      ): Channel.Channel<never, unknown, number, unknown, unknown, never, void> =>
+      ): Channel.Channel<never, number, unknown, unknown, void, unknown> =>
         Channel.readWith({
           onInput: (input: number) => sum(label, n + input),
           onFailure: () => Channel.fromEffect(Ref.update(ref, (array) => [...array, n])),
diff --git a/packages/experimental/src/MsgPack.ts b/packages/experimental/src/MsgPack.ts
index 6c38ff4a21..3e0fa8360b 100644
--- a/packages/experimental/src/MsgPack.ts
+++ b/packages/experimental/src/MsgPack.ts
@@ -25,13 +25,12 @@ export class MsgPackError extends Data.TaggedError("MsgPackError")<{
  * @category constructors
  */
 export const pack = <IE = never>(): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<Uint8Array>,
   Chunk.Chunk<unknown>,
-  unknown,
   IE | MsgPackError,
-  Chunk.Chunk<Uint8Array>,
-  void
+  IE,
+  void,
+  unknown
 > =>
   Channel.flatMap(
     Channel.sync(() => new Packr()),
@@ -45,19 +44,12 @@ export const pack = <IE = never>(): Channel.Channel<
           Channel.write
         )
 
-      const loop: Channel.Channel<
-        never,
-        IE,
-        Chunk.Chunk<unknown>,
-        unknown,
-        IE | MsgPackError,
-        Chunk.Chunk<Uint8Array>,
-        void
-      > = Channel.readWithCause({
-        onInput: (input: Chunk.Chunk<unknown>) => Channel.zipRight(pack(input), loop),
-        onFailure: (cause) => Channel.failCause(cause),
-        onDone: () => Channel.unit
-      })
+      const loop: Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<unknown>, IE | MsgPackError, IE, void, unknown> =
+        Channel.readWithCause({
+          onInput: (input: Chunk.Chunk<unknown>) => Channel.zipRight(pack(input), loop),
+          onFailure: (cause) => Channel.failCause(cause),
+          onDone: () => Channel.unit
+        })
       return loop
     }
   )
@@ -70,16 +62,16 @@ export const packSchema = <A, I, R>(
   schema: Schema.Schema<A, I, R>
 ) =>
 <IE = never>(): Channel.Channel<
-  R,
-  IE,
+  Chunk.Chunk<Uint8Array>,
   Chunk.Chunk<A>,
-  unknown,
   IE | MsgPackError | ParseError,
-  Chunk.Chunk<Uint8Array>,
-  void
+  IE,
+  void,
+  unknown,
+  R
 > => {
   const encode = Schema.encode(Schema.chunkFromSelf(schema))
-  const loop: Channel.Channel<R, IE, Chunk.Chunk<A>, unknown, IE | ParseError, Chunk.Chunk<I>, unknown> = Channel
+  const loop: Channel.Channel<Chunk.Chunk<I>, Chunk.Chunk<A>, IE | ParseError, IE, unknown, unknown, R> = Channel
     .readWithCause({
       onInput: (input: Chunk.Chunk<A>) =>
         Channel.zipRight(
@@ -97,13 +89,12 @@ export const packSchema = <A, I, R>(
  * @category constructors
  */
 export const unpack = <IE = never>(): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<unknown>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   IE | MsgPackError,
-  Chunk.Chunk<unknown>,
-  void
+  IE,
+  void,
+  unknown
 > =>
   Channel.flatMap(
     Channel.sync(() => new Unpackr()),
@@ -137,19 +128,12 @@ export const unpack = <IE = never>(): Channel.Channel<
           Channel.write
         )
 
-      const loop: Channel.Channel<
-        never,
-        IE,
-        Chunk.Chunk<Uint8Array>,
-        unknown,
-        IE | MsgPackError,
-        Chunk.Chunk<unknown>,
-        void
-      > = Channel.readWithCause({
-        onInput: (input: Chunk.Chunk<Uint8Array>) => Channel.zipRight(unpack(input), loop),
-        onFailure: (cause) => Channel.failCause(cause),
-        onDone: () => Channel.unit
-      })
+      const loop: Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<Uint8Array>, IE | MsgPackError, IE, void, unknown> =
+        Channel.readWithCause({
+          onInput: (input: Chunk.Chunk<Uint8Array>) => Channel.zipRight(unpack(input), loop),
+          onFailure: (cause) => Channel.failCause(cause),
+          onDone: () => Channel.unit
+        })
 
       return loop
     }
@@ -163,13 +147,13 @@ export const unpackSchema = <A, I, R>(
   schema: Schema.Schema<A, I, R>
 ) =>
 <IE = never>(): Channel.Channel<
-  R,
-  IE,
+  Chunk.Chunk<A>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   MsgPackError | ParseError | IE,
-  Chunk.Chunk<A>,
-  void
+  IE,
+  void,
+  unknown,
+  R
 > => {
   const parse = Schema.decodeUnknown(Schema.chunkFromSelf(schema))
   return Channel.mapOutEffect(unpack<IE>(), parse)
@@ -180,24 +164,8 @@ export const unpackSchema = <A, I, R>(
  * @category combinators
  */
 export const duplex = <R, IE, OE>(
-  self: Channel.Channel<
-    R,
-    IE | MsgPackError,
-    Chunk.Chunk<Uint8Array>,
-    unknown,
-    OE,
-    Chunk.Chunk<Uint8Array>,
-    void
-  >
-): Channel.Channel<
-  R,
-  IE,
-  Chunk.Chunk<unknown>,
-  unknown,
-  MsgPackError | OE,
-  Chunk.Chunk<unknown>,
-  void
-> =>
+  self: Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, OE, IE | MsgPackError, void, unknown, R>
+): Channel.Channel<Chunk.Chunk<unknown>, Chunk.Chunk<unknown>, MsgPackError | OE, IE, void, unknown, R> =>
   Channel.pipeTo(
     Channel.pipeTo(pack(), self),
     unpack()
@@ -215,45 +183,45 @@ export const duplexSchema: {
     }
   ): <R, InErr, OutErr>(
     self: Channel.Channel<
-      R,
-      MsgPackError | ParseError | InErr,
       Chunk.Chunk<Uint8Array>,
-      unknown,
-      OutErr,
       Chunk.Chunk<Uint8Array>,
-      void
+      OutErr,
+      MsgPackError | ParseError | InErr,
+      void,
+      unknown,
+      R
     >
   ) => Channel.Channel<
-    IR | OR | R,
-    InErr,
+    Chunk.Chunk<OA>,
     Chunk.Chunk<IA>,
-    unknown,
     MsgPackError | ParseError | OutErr,
-    Chunk.Chunk<OA>,
-    void
+    InErr,
+    void,
+    unknown,
+    IR | OR | R
   >
   <R, InErr, OutErr, IA, II, IR, OA, OI, OR>(
     self: Channel.Channel<
-      R,
-      MsgPackError | ParseError | InErr,
       Chunk.Chunk<Uint8Array>,
-      unknown,
-      OutErr,
       Chunk.Chunk<Uint8Array>,
-      void
+      OutErr,
+      MsgPackError | ParseError | InErr,
+      void,
+      unknown,
+      R
     >,
     options: {
       readonly inputSchema: Schema.Schema<IA, II, IR>
       readonly outputSchema: Schema.Schema<OA, OI, OR>
     }
   ): Channel.Channel<
-    R | IR | OR,
-    InErr,
+    Chunk.Chunk<OA>,
     Chunk.Chunk<IA>,
-    unknown,
     MsgPackError | ParseError | OutErr,
-    Chunk.Chunk<OA>,
-    void
+    InErr,
+    void,
+    unknown,
+    R | IR | OR
   >
 } = dual<
   <IA, II, IR, OA, OI, OR>(
@@ -263,68 +231,68 @@ export const duplexSchema: {
     }
   ) => <R, InErr, OutErr>(
     self: Channel.Channel<
-      R,
-      MsgPackError | ParseError | InErr,
       Chunk.Chunk<Uint8Array>,
-      unknown,
-      OutErr,
       Chunk.Chunk<Uint8Array>,
-      void
+      OutErr,
+      MsgPackError | ParseError | InErr,
+      void,
+      unknown,
+      R
     >
   ) => Channel.Channel<
-    R | IR | OR,
-    InErr,
+    Chunk.Chunk<OA>,
     Chunk.Chunk<IA>,
-    unknown,
     MsgPackError | ParseError | OutErr,
-    Chunk.Chunk<OA>,
-    void
+    InErr,
+    void,
+    unknown,
+    R | IR | OR
   >,
   <R, InErr, OutErr, IA, II, IR, OA, OI, OR>(
     self: Channel.Channel<
-      R,
-      MsgPackError | ParseError | InErr,
       Chunk.Chunk<Uint8Array>,
-      unknown,
-      OutErr,
       Chunk.Chunk<Uint8Array>,
-      void
+      OutErr,
+      MsgPackError | ParseError | InErr,
+      void,
+      unknown,
+      R
     >,
     options: {
       readonly inputSchema: Schema.Schema<IA, II, IR>
       readonly outputSchema: Schema.Schema<OA, OI, OR>
     }
   ) => Channel.Channel<
-    R | IR | OR,
-    InErr,
+    Chunk.Chunk<OA>,
     Chunk.Chunk<IA>,
-    unknown,
     MsgPackError | ParseError | OutErr,
-    Chunk.Chunk<OA>,
-    void
+    InErr,
+    void,
+    unknown,
+    R | IR | OR
   >
 >(2, <R, InErr, OutErr, IA, II, IR, OA, OI, OR>(
   self: Channel.Channel<
-    R,
-    MsgPackError | ParseError | InErr,
     Chunk.Chunk<Uint8Array>,
-    unknown,
-    OutErr,
     Chunk.Chunk<Uint8Array>,
-    void
+    OutErr,
+    MsgPackError | ParseError | InErr,
+    void,
+    unknown,
+    R
   >,
   options: {
     readonly inputSchema: Schema.Schema<IA, II, IR>
     readonly outputSchema: Schema.Schema<OA, OI, OR>
   }
 ): Channel.Channel<
-  R | IR | OR,
-  InErr,
+  Chunk.Chunk<OA>,
   Chunk.Chunk<IA>,
-  unknown,
   MsgPackError | ParseError | OutErr,
-  Chunk.Chunk<OA>,
-  void
+  InErr,
+  void,
+  unknown,
+  R | IR | OR
 > => {
   const pack = packSchema(options.inputSchema)
   const unpack = unpackSchema(options.outputSchema)
diff --git a/packages/experimental/src/Socket.ts b/packages/experimental/src/Socket.ts
index 912a0d0921..6d79c9e092 100644
--- a/packages/experimental/src/Socket.ts
+++ b/packages/experimental/src/Socket.ts
@@ -70,7 +70,7 @@ export class SocketError extends Data.TaggedError("SocketError")<{
  */
 export const toChannel = <IE>(
   self: Socket
-): Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, Chunk.Chunk<Uint8Array>, void> =>
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
   Channel.unwrap(
     Effect.gen(function*(_) {
       const writeScope = yield* _(Scope.make())
@@ -104,21 +104,14 @@ export const toChannel = <IE>(
         Effect.fork
       )
 
-      const loop: Channel.Channel<
-        never,
-        unknown,
-        unknown,
-        unknown,
-        SocketError | IE,
-        Chunk.Chunk<Uint8Array>,
-        void
-      > = Channel.flatMap(
-        Queue.take(exitQueue),
-        Exit.match({
-          onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.unit : Channel.failCause(cause),
-          onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
-        })
-      )
+      const loop: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, unknown, void, unknown> = Channel
+        .flatMap(
+          Queue.take(exitQueue),
+          Exit.match({
+            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.unit : Channel.failCause(cause),
+            onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
+          })
+        )
 
       return Channel.embedInput(loop, input)
     })
@@ -131,7 +124,7 @@ export const toChannel = <IE>(
 export const toChannelWith = <IE = never>() =>
 (
   self: Socket
-): Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, Chunk.Chunk<Uint8Array>, void> =>
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
   toChannel(self)
 
 /**
@@ -139,13 +132,13 @@ export const toChannelWith = <IE = never>() =>
  * @category constructors
  */
 export const makeChannel = <IE = never>(): Channel.Channel<
-  Socket,
-  IE,
   Chunk.Chunk<Uint8Array>,
-  unknown,
-  SocketError | IE,
   Chunk.Chunk<Uint8Array>,
-  void
+  SocketError | IE,
+  IE,
+  void,
+  unknown,
+  Socket
 > => Channel.unwrap(Effect.map(Socket, toChannelWith<IE>()))
 
 /**
@@ -284,15 +277,7 @@ export const makeWebSocketChannel = <IE = never>(
   options?: {
     readonly closeCodeIsError?: (code: number) => boolean
   }
-): Channel.Channel<
-  never,
-  IE,
-  Chunk.Chunk<Uint8Array>,
-  unknown,
-  SocketError | IE,
-  Chunk.Chunk<Uint8Array>,
-  void
-> =>
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
   Channel.unwrapScoped(
     Effect.map(makeWebSocket(url, options), toChannelWith<IE>())
   )
diff --git a/packages/experimental/src/Socket/Node.ts b/packages/experimental/src/Socket/Node.ts
index d68e872d0b..684059585e 100644
--- a/packages/experimental/src/Socket/Node.ts
+++ b/packages/experimental/src/Socket/Node.ts
@@ -139,15 +139,7 @@ export const fromNetSocket = (
  */
 export const makeNetChannel = <IE = never>(
   options: Net.NetConnectOpts
-): Channel.Channel<
-  never,
-  IE,
-  Chunk.Chunk<Uint8Array>,
-  unknown,
-  Socket.SocketError | IE,
-  Chunk.Chunk<Uint8Array>,
-  void
-> =>
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, Socket.SocketError | IE, IE, void, unknown> =>
   Channel.unwrapScoped(
     Effect.map(makeNet(options), Socket.toChannelWith<IE>())
   )
diff --git a/packages/platform-node-shared/src/NodeSink.ts b/packages/platform-node-shared/src/NodeSink.ts
index 7446a5cbcf..494f02c4b6 100644
--- a/packages/platform-node-shared/src/NodeSink.ts
+++ b/packages/platform-node-shared/src/NodeSink.ts
@@ -27,4 +27,4 @@ export const fromWritableChannel: <IE, OE, A>(
   writable: LazyArg<Writable | NodeJS.WritableStream>,
   onError: (error: unknown) => OE,
   options?: FromWritableOptions
-) => Channel<never, IE, Chunk<A>, unknown, IE | OE, Chunk<never>, void> = internal.fromWritableChannel
+) => Channel<Chunk<never>, Chunk<A>, IE | OE, IE, void, unknown> = internal.fromWritableChannel
diff --git a/packages/platform-node-shared/src/NodeStream.ts b/packages/platform-node-shared/src/NodeStream.ts
index 24ed6bc3cf..64cb30c715 100644
--- a/packages/platform-node-shared/src/NodeStream.ts
+++ b/packages/platform-node-shared/src/NodeStream.ts
@@ -47,7 +47,7 @@ export const fromReadableChannel: <E, A = Uint8Array>(
   evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
   onError: (error: unknown) => E,
   chunkSize: number | undefined
-) => Channel<never, unknown, unknown, unknown, E, Chunk<A>, void> = internal.fromReadableChannel
+) => Channel<Chunk<A>, unknown, E, unknown, void, unknown> = internal.fromReadableChannel
 
 /**
  * @category constructors
@@ -57,7 +57,7 @@ export const fromDuplex: <IE, E, I = Uint8Array, O = Uint8Array>(
   evaluate: LazyArg<Duplex>,
   onError: (error: unknown) => E,
   options?: FromReadableOptions & FromWritableOptions
-) => Channel<never, IE, Chunk<I>, unknown, IE | E, Chunk<O>, void> = internal.fromDuplex
+) => Channel<Chunk<O>, Chunk<I>, IE | E, IE, void, unknown> = internal.fromDuplex
 
 /**
  * @category combinators
diff --git a/packages/platform-node-shared/src/internal/sink.ts b/packages/platform-node-shared/src/internal/sink.ts
index 9fed2a3ae8..44e18d0a74 100644
--- a/packages/platform-node-shared/src/internal/sink.ts
+++ b/packages/platform-node-shared/src/internal/sink.ts
@@ -20,7 +20,7 @@ export const fromWritableChannel = <IE, OE, A>(
   writable: LazyArg<Writable | NodeJS.WritableStream>,
   onError: (error: unknown) => OE,
   options?: FromWritableOptions
-): Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, IE | OE, Chunk.Chunk<never>, void> =>
+): Channel.Channel<Chunk.Chunk<never>, Chunk.Chunk<A>, IE | OE, IE, void, unknown> =>
   Channel.flatMap(
     Effect.zip(
       Effect.sync(() => writable()),
diff --git a/packages/platform-node-shared/src/internal/stream.ts b/packages/platform-node-shared/src/internal/stream.ts
index 26656fbdb2..fa55b2975f 100644
--- a/packages/platform-node-shared/src/internal/stream.ts
+++ b/packages/platform-node-shared/src/internal/stream.ts
@@ -112,7 +112,7 @@ export const fromDuplex = <IE, E, I = Uint8Array | string, O = Uint8Array>(
   evaluate: LazyArg<Duplex>,
   onError: (error: unknown) => E,
   options: FromReadableOptions & FromWritableOptions = {}
-): Channel.Channel<never, IE, Chunk.Chunk<I>, unknown, IE | E, Chunk.Chunk<O>, void> =>
+): Channel.Channel<Chunk.Chunk<O>, Chunk.Chunk<I>, IE | E, IE, void, unknown> =>
   Channel.acquireUseRelease(
     Effect.tap(
       Effect.zip(
@@ -194,7 +194,7 @@ export const fromReadableChannel = <E, A = Uint8Array>(
   evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
   onError: (error: unknown) => E,
   chunkSize: number | undefined
-): Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> =>
+): Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> =>
   Channel.acquireUseRelease(
     Effect.tap(
       Effect.zip(
@@ -297,7 +297,7 @@ const readableTake = <E, A>(
   chunkSize: number | undefined
 ) => {
   const read = readChunkChannel<A>(readable, chunkSize)
-  const loop: Channel.Channel<never, unknown, unknown, unknown, E, Chunk.Chunk<A>, void> = Channel.flatMap(
+  const loop: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, void, unknown> = Channel.flatMap(
     Queue.take(queue),
     Either.match({
       onLeft: Exit.match({
diff --git a/packages/platform/src/Http/Multipart.ts b/packages/platform/src/Http/Multipart.ts
index 8936e7ece3..b6eb724c88 100644
--- a/packages/platform/src/Http/Multipart.ts
+++ b/packages/platform/src/Http/Multipart.ts
@@ -220,7 +220,7 @@ export const schemaPersisted: <R, I extends Persisted, A>(
 export const makeChannel: <IE>(
   headers: Record<string, string>,
   bufferSize?: number
-) => Channel.Channel<never, IE, Chunk.Chunk<Uint8Array>, unknown, MultipartError | IE, Chunk.Chunk<Part>, unknown> =
+) => Channel.Channel<Chunk.Chunk<Part>, Chunk.Chunk<Uint8Array>, MultipartError | IE, IE, unknown, unknown> =
   internal.makeChannel
 
 /**
diff --git a/packages/platform/src/internal/fileSystem.ts b/packages/platform/src/internal/fileSystem.ts
index 5071547b81..44e40bb9a4 100644
--- a/packages/platform/src/internal/fileSystem.ts
+++ b/packages/platform/src/internal/fileSystem.ts
@@ -97,7 +97,7 @@ const stream = (file: File, {
 
   function loop(
     totalBytesRead: bigint
-  ): Channel.Channel<never, unknown, unknown, unknown, Error.PlatformError, Chunk.Chunk<Uint8Array>, void> {
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, Error.PlatformError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.unit
     }
diff --git a/packages/platform/src/internal/http/multipart.ts b/packages/platform/src/internal/http/multipart.ts
index 06120ab416..f67b0863de 100644
--- a/packages/platform/src/internal/http/multipart.ts
+++ b/packages/platform/src/internal/http/multipart.ts
@@ -173,12 +173,11 @@ export const makeChannel = <IE>(
   headers: Record<string, string>,
   bufferSize = 16
 ): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<Multipart.Part>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   Multipart.MultipartError | IE,
-  Chunk.Chunk<Multipart.Part>,
+  IE,
+  unknown,
   unknown
 > =>
   Channel.acquireUseRelease(
@@ -194,12 +193,11 @@ const makeFromQueue = <IE>(
   config: MP.BaseConfig,
   queue: Queue.Queue<Chunk.Chunk<Uint8Array> | null>
 ): Channel.Channel<
-  never,
-  IE,
+  Chunk.Chunk<Multipart.Part>,
   Chunk.Chunk<Uint8Array>,
-  unknown,
   IE | Multipart.MultipartError,
-  Chunk.Chunk<Multipart.Part>,
+  IE,
+  unknown,
   unknown
 > =>
   Channel.suspend(() => {
@@ -229,7 +227,7 @@ const makeFromQueue = <IE>(
       onFile(info) {
         let chunks: Array<Uint8Array> = []
         let finished = false
-        const take: Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<Uint8Array>, void> = Channel
+        const take: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, never, unknown, void, unknown> = Channel
           .suspend(() => {
             if (chunks.length === 0) {
               return finished ? Channel.unit : Channel.zipRight(pump, take)
@@ -285,13 +283,12 @@ const makeFromQueue = <IE>(
     )
 
     const partsChannel: Channel.Channel<
-      never,
-      unknown,
-      unknown,
+      Chunk.Chunk<Multipart.Part>,
       unknown,
       IE | Multipart.MultipartError,
-      Chunk.Chunk<Multipart.Part>,
-      void
+      unknown,
+      void,
+      unknown
     > = Channel.suspend(() => {
       if (error._tag === "Some") {
         return Channel.failCause(error.value)
@@ -351,7 +348,7 @@ class FileImpl implements Multipart.File {
 
   constructor(
     info: MP.PartInfo,
-    channel: Channel.Channel<never, unknown, unknown, unknown, never, Chunk.Chunk<Uint8Array>, void>
+    channel: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, never, unknown, void, unknown>
   ) {
     this[TypeId] = TypeId
     this.key = info.name
diff --git a/packages/platform/src/internal/worker.ts b/packages/platform/src/internal/worker.ts
index 3b1cb887fa..1a3a3ed024 100644
--- a/packages/platform/src/internal/worker.ts
+++ b/packages/platform/src/internal/worker.ts
@@ -220,8 +220,8 @@ export const makeManager = Effect.gen(function*(_) {
               executeRelease
             ),
             ([, queue]) => {
-              const loop: Channel.Channel<never, unknown, unknown, unknown, E | WorkerError, Chunk.Chunk<O>, void> =
-                Channel.flatMap(
+              const loop: Channel.Channel<Chunk.Chunk<O>, unknown, E | WorkerError, unknown, void, unknown> = Channel
+                .flatMap(
                   Queue.take(queue),
                   Exit.match({
                     onFailure: (cause) => Cause.isEmpty(cause) ? Channel.unit : Channel.failCause(cause),