effect 2.2.5 → 2.3.0

package/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<R, E, A> 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>(
-  acquire: Effect.Effect<Env, OutErr, Acquired>,
-  use: (a: Acquired) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>,
-  release: (a: Acquired, exit: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env, never, any>
-) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone> = channel.acquireUseRelease
+export const acquireUseRelease: <Acquired, OutErr, Env, OutElem1, InElem, InErr, OutDone, InDone>(
+  acquire: Effect.Effect<Acquired, OutErr, Env>,
+  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<OutElem1, InElem, OutErr, InErr, OutDone, InDone, Env> = channel.acquireUseRelease
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const acquireReleaseOut: <R, R2, E, Z>(
-  self: Effect.Effect<R, E, Z>,
-  release: (z: Z, e: Exit.Exit<unknown, unknown>) => Effect.Effect<R2, never, unknown>
-) => 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: <R, R2, E, Z>(
 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>(
-    f: (i: InDone0) => Effect.Effect<Env1, InErr, InDone>
-  ): <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>,
-    f: (i: InDone0) => Effect.Effect<Env1, InErr, InDone>
-  ): Channel<Env | Env1, InErr, InElem, InDone0, OutErr, OutElem, OutDone>
+  <InDone0, InDone, InErr, Env1>(
+    f: (i: InDone0) => Effect.Effect<InDone, InErr, Env1>
+  ): <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<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>(
-    f: (error: InErr0) => Effect.Effect<Env1, InErr, InDone>
-  ): <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>,
-    f: (error: InErr0) => Effect.Effect<Env1, InErr, InDone>
-  ): Channel<Env | Env1, InErr0, InElem, InDone, OutErr, OutElem, OutDone>
+  <InErr0, InDone, InErr, Env1>(
+    f: (error: InErr0) => Effect.Effect<InDone, InErr, Env1>
+  ): <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<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>(
-    f: (a: InElem0) => Effect.Effect<Env1, InErr, InElem>
-  ): <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>,
-    f: (a: InElem0) => Effect.Effect<Env1, InErr, InElem>
-  ): Channel<Env | Env1, InErr, InElem0, InDone, OutErr, OutElem, OutDone>
+  <InElem0, InElem, InErr, Env1>(
+    f: (a: InElem0) => Effect.Effect<InElem, InErr, Env1>
+  ): <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<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>(
-    finalizer: Effect.Effect<Env1, never, Z>
-  ): <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>,
-    finalizer: Effect.Effect<Env1, never, Z>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <Z, Env1>(
+    finalizer: Effect.Effect<Z, never, Env1>
+  ): <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<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>(
-    finalizer: (e: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env2, never, unknown>
-  ): <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>,
-    finalizer: (e: Exit.Exit<OutErr, OutDone>) => Effect.Effect<Env2, never, unknown>
-  ): Channel<Env | Env2, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+  <OutDone, OutErr, Env2>(
+    finalizer: (e: Exit.Exit<OutDone, OutErr>) => Effect.Effect<unknown, never, Env2>
+  ): <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<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>(
-  f: (env: Context.Context<Env>) => Effect.Effect<Env1, OutErr, OutDone>
-) => Channel<Env | Env1, unknown, unknown, unknown, OutErr, never, OutDone> = channel.contextWithEffect
+export const contextWithEffect: <Env, OutDone, OutErr, Env1>(
+  f: (env: Context.Context<Env>) => Effect.Effect<OutDone, OutErr, Env1>
+) => 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
 
@@ -1049,9 +1067,9 @@ export const foldCauseChannel: {
  * @since 2.0.0
  * @category constructors
  */
-export const fromEffect: <R, E, A>(
-  effect: Effect.Effect<R, E, A>
-) => Channel<R, unknown, unknown, unknown, E, never, A> = core.fromEffect
+export const fromEffect: <A, E, R>(
+  effect: Effect.Effect<A, E, R>
+) => Channel<never, unknown, E, unknown, A, unknown, R> = core.fromEffect
 
 /**
  * Constructs a channel from an `Either`.
@@ -1059,7 +1077,7 @@ export const fromEffect: <R, E, A>(
  * @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>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Err, Done>, Elem>>
-) => Channel<never, unknown, unknown, unknown, Err, Elem, Done> = channel.fromPubSub
+export const fromPubSub: <Done, Err, Elem>(
+  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+) => 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>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Err, Done>, Elem>>
-) => Effect.Effect<Scope.Scope, never, Channel<never, unknown, unknown, unknown, Err, Elem, Done>> =
-  channel.fromPubSubScoped
+export const fromPubSubScoped: <Done, Err, Elem>(
+  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+) => 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>(
-  queue: Queue.Dequeue<Either.Either<Exit.Exit<Err, Done>, Elem>>
-) => Channel<never, unknown, unknown, unknown, Err, Elem, Done> = channel.fromQueue
+export const fromQueue: <Done, Err, Elem>(
+  queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+) => 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>(
-    effect: Effect.Effect<Env1, OutErr1, OutDone1>
-  ): <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>,
-    effect: Effect.Effect<Env1, OutErr1, OutDone1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone | OutDone1>
+  <OutDone1, OutErr1, Env1>(
+    effect: Effect.Effect<OutDone1, OutErr1, Env1>
+  ): <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<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>(
-    deferred: Deferred.Deferred<OutErr1, OutDone1>
-  ): <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>,
-    deferred: Deferred.Deferred<OutErr1, OutDone1>
-  ): Channel<Env, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone | OutDone1>
+  <OutDone1, OutErr1>(
+    deferred: Deferred.Deferred<OutDone1, OutErr1>
+  ): <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<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>(
-    f: (o: OutDone) => Effect.Effect<Env1, OutErr1, OutDone1>
-  ): <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>,
-    f: (o: OutDone) => Effect.Effect<Env1, OutErr1, OutDone1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem, OutDone1>
+  <OutDone, OutDone1, OutErr1, Env1>(
+    f: (o: OutDone) => Effect.Effect<OutDone1, OutErr1, Env1>
+  ): <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<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>(
-    f: (o: OutElem) => Effect.Effect<Env1, OutErr1, OutElem1>
-  ): <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>,
-    f: (o: OutElem) => Effect.Effect<Env1, OutErr1, OutElem1>
-  ): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone>
+  <OutElem, OutElem1, OutErr1, Env1>(
+    f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>
+  ): <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<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>(
-    f: (o: OutElem) => Effect.Effect<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>,
-    f: (o: OutElem) => Effect.Effect<Env1, OutErr1, OutElem1>,
+  ): <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,65 +1533,65 @@ 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<OutErr, OutDone>
+        exit: Exit.Exit<OutDone, OutErr>
       ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
       readonly onOtherDone: (
-        ex: Exit.Exit<OutErr1, OutDone1>
+        ex: Exit.Exit<OutDone1, OutErr1>
       ) => 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<OutErr, OutDone>
+        exit: Exit.Exit<OutDone, OutErr>
       ) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>
       readonly onOtherDone: (
-        ex: Exit.Exit<OutErr1, OutDone1>
+        ex: Exit.Exit<OutDone1, OutErr1>
       ) => 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>(
-    layer: Layer.Layer<Env0, OutErr2, Env>
-  ): <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>,
-    layer: Layer.Layer<Env0, OutErr2, Env>
-  ): Channel<Env0, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone>
+  <Env, OutErr2, Env0>(
+    layer: Layer.Layer<Env, OutErr2, Env0>
+  ): <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<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>(
-    layer: Layer.Layer<Env0, OutErr2, Env2>
-  ): <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>,
-    layer: Layer.Layer<Env0, OutErr2, Env2>
-  ): Channel<Env0 | Exclude<R, Env2>, InErr, InElem, InDone, OutErr | OutErr2, OutElem, OutDone>
+  <Env2, OutErr2, Env0>(
+    layer: Layer.Layer<Env2, OutErr2, Env0>
+  ): <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<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,9 +1914,9 @@ 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>
-) => Effect.Effect<Env, OutErr, OutDone> = channel.run
+export const run: <OutErr, InErr, OutDone, InDone, Env>(
+  self: Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>
+) => Effect.Effect<OutDone, OutErr, Env> = channel.run
 
 /**
  * Run the channel until it finishes with a done value or fails with an error
@@ -1910,9 +1927,9 @@ 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>
-) => Effect.Effect<Env, OutErr, [Chunk.Chunk<OutElem>, OutDone]> = channel.runCollect
+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
 
 /**
  * Runs a channel until the end is received.
@@ -1920,9 +1937,9 @@ 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>
-) => Effect.Effect<Env, OutErr, OutDone> = channel.runDrain
+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
 
 /**
  * Use a scoped effect to emit an output element.
@@ -1930,9 +1947,9 @@ export const runDrain: <Env, InErr, InDone, OutElem, OutErr, OutDone>(
  * @since 2.0.0
  * @category constructors
  */
-export const scoped: <R, E, A>(
-  effect: Effect.Effect<R, E, A>
-) => Channel<Exclude<R, Scope.Scope>, unknown, unknown, unknown, E, A, unknown> = channel.scoped
+export const scoped: <A, E, R>(
+  effect: Effect.Effect<A, E, R>
+) => 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: <R, E, A>(
  * @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>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Err, Done>, Elem>>
-) => Channel<never, Err, Elem, Done, never, never, unknown> = channel.toPubSub
+export const toPubSub: <Done, Err, Elem>(
+  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+) => Channel<never, Elem, never, Err, unknown, Done> = channel.toPubSub
 
 /**
  * Returns a scoped `Effect` that can be used to repeatedly pull elements from
@@ -1981,9 +1998,9 @@ 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>
-) => Effect.Effect<Scope.Scope | Env, never, Effect.Effect<Env, OutErr, Either.Either<OutDone, OutElem>>> =
+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,18 +2009,18 @@ export const toPull: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
  * @since 2.0.0
  * @category destructors
  */
-export const toQueue: <Err, Done, Elem>(
-  queue: Queue.Enqueue<Either.Either<Exit.Exit<Err, Done>, Elem>>
-) => Channel<never, Err, Elem, Done, never, never, unknown> = channel.toQueue
+export const toQueue: <Done, Err, Elem>(
+  queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+) => 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>
-) => Sink.Sink<Env, OutErr, InElem, OutElem, OutDone> = sink.channelToSink
+export const toSink: <OutElem, InElem, OutErr, InErr, OutDone, Env>(
+  self: Channel<Chunk.Chunk<OutElem>, Chunk.Chunk<InElem>, OutErr, InErr, OutDone, unknown, Env>
+) => Sink.Sink<OutDone, InElem, OutElem, OutErr, Env> = sink.channelToSink
 
 /**
  * Converts this channel to a `Stream`.
@@ -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>
-) => Stream.Stream<Env, OutErr, OutElem> = stream.channelToStream
+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: <R, E, R2, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  channel: Effect.Effect<R, E, Channel<R2, InErr, InElem, InDone, OutErr, OutElem, OutDone>>
-) => 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: <R, E, R2, InErr, InElem, InDone, OutErr, OutElem, OutDone>
  * @since 2.0.0
  * @category constructors
  */
-export const unwrapScoped: <R, E, Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  self: Effect.Effect<R, E, Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>>
-) => 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