effect 2.2.5 → 2.3.1

package/dist/dts/Channel.d.ts

@@ -64,7 +64,7 @@ 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 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>;
     [Unify.ignoreSymbol]?: ChannelUnifyIgnore;
@@ -76,7 +76,7 @@ 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 InElem, infer InDone, infer OutErr, infer OutElem, infer OutDone> | infer _ ? Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> : never;
+    Channel?: () => A[Unify.typeSymbol] extends Channel<infer OutElem, infer InElem, infer OutErr, infer InErr, infer OutDone, infer InDone, infer Env> | infer _ ? Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env> : never;
 }
 /**
  * @category models
@@ -90,7 +90,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;
@@ -104,14 +104,14 @@ export declare namespace Channel {
      * @since 2.0.0
      * @category models
      */
-    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>;
+    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
      */
-    interface VarianceStruct<out Env, in InErr, in InElem, in InDone, out OutErr, out OutElem, out OutDone> {
+    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>;
@@ -147,12 +147,15 @@ export interface ChannelException<out E> {
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>;
+};
 /**
  * Returns a new channel that is the same as this one, except the terminal
  * value of the channel is the specified constant value.
@@ -164,14 +167,14 @@ export declare const acquireReleaseOut: <R, R2, E, Z>(self: Effect.Effect<R, E,
  * @category mapping
  */
 export declare 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>, value: OutDone2): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>;
+    <OutDone2>(value: OutDone2): <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<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>;
 };
 /**
  * @since 2.0.0
  * @category mapping
  */
-export declare 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>;
+export declare 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>;
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel
  * will simply passthrough its input as output. However, when the buffer is
@@ -180,16 +183,16 @@ export declare const asUnit: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDo
  * @since 2.0.0
  * @category constructors
  */
-export declare const buffer: <InErr, InElem, InDone>(options: {
+export declare const buffer: <InElem, InErr, InDone>(options: {
     readonly empty: InElem;
     readonly isEmpty: Predicate<InElem>;
     readonly ref: Ref.Ref<InElem>;
-}) => Channel<never, InErr, InElem, InDone, InErr, InElem, InDone>;
+}) => Channel<InElem, InElem, InErr, InErr, InDone, InDone, never>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const bufferChunk: <InErr, InElem, InDone>(ref: Ref.Ref<Chunk.Chunk<InElem>>) => Channel<never, InErr, Chunk.Chunk<InElem>, InDone, InErr, Chunk.Chunk<InElem>, InDone>;
+export declare const bufferChunk: <InElem, InErr, InDone>(ref: Ref.Ref<Chunk.Chunk<InElem>>) => Channel<Chunk.Chunk<InElem>, Chunk.Chunk<InElem>, InErr, InErr, InDone, InDone>;
 /**
  * Returns a new channel that is the same as this one, except if this channel
  * errors for any typed error, then the returned channel will switch over to
@@ -199,8 +202,8 @@ export declare const bufferChunk: <InErr, InElem, InDone>(ref: Ref.Ref<Chunk.Chu
  * @category error handling
  */
 export declare 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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem1 | OutElem, OutDone1 | OutDone>;
-    <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>): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem | OutElem1, OutDone | OutDone1>;
+    <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<OutElem1 | OutElem, InElem & InElem1, OutErr1, InErr & InErr1, OutDone1 | OutDone, InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (error: OutErr) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>): Channel<OutElem | OutElem1, InElem & InElem1, OutErr1, InErr & InErr1, OutDone | OutDone1, InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a new channel that is the same as this one, except if this channel
@@ -211,8 +214,8 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare 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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem1 | OutElem, OutDone1 | OutDone>;
-    <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>): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem | OutElem1, OutDone | OutDone1>;
+    <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<OutElem1 | OutElem, InElem & InElem1, OutErr1, InErr & InErr1, OutDone1 | OutDone, InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>): Channel<OutElem | OutElem1, InElem & InElem1, OutErr1, InErr & InErr1, OutDone | OutDone1, InDone & InDone1, Env | Env1>;
 };
 /**
  * Concat sequentially a channel of channels.
@@ -220,14 +223,14 @@ export declare const catchAllCause: {
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>;
 /**
  * Concat sequentially a channel of channels.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const concatAllWith: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem, OutDone>, OutDone2>, 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>;
+export declare const concatAllWith: <OutElem, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, InElem, OutErr, InErr, OutDone2, InDone, Env, OutDone3>(channels: Channel<Channel<OutElem, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2>, InElem, OutErr, InErr, OutDone2, InDone, Env>, f: (o: OutDone, o1: OutDone) => OutDone, g: (o: OutDone, o2: OutDone2) => OutDone3) => Channel<OutElem, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env>;
 /**
  * Returns a new channel whose outputs are fed to the specified factory
  * function, which creates new channels in response. These new channels are
@@ -238,8 +241,8 @@ export declare const concatAllWith: <Env, InErr, InElem, InDone, OutErr, OutElem
  * @category utils
  */
 export declare const concatMap: {
-    <OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, _>): <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>;
-    <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>;
+    <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<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<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>;
 };
 /**
  * Returns a new channel whose outputs are fed to the specified factory
@@ -253,8 +256,8 @@ export declare const concatMap: {
  * @category utils
  */
 export declare const concatMapWith: {
-    <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>, 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>;
-    <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>, f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>, 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>;
+    <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<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>) => Channel<OutElem2, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone3>(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<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, OutDone3, InDone & InDone2, Env | Env2>;
 };
 /**
  * Returns a new channel whose outputs are fed to the specified factory
@@ -268,8 +271,8 @@ export declare const concatMapWith: {
  * @category utils
  */
 export declare const concatMapWithCustom: {
-    <OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>, 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): <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>;
-    <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone, OutDone2, OutDone3, Env2, InErr2, InElem2, InDone2, OutErr2>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>, f: (o: OutElem) => Channel<Env2, InErr2, InElem2, InDone2, OutErr2, OutElem2, OutDone>, 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>;
+    <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: (upstreamPullRequest: UpstreamPullRequest.UpstreamPullRequest<OutElem>) => UpstreamPullStrategy.UpstreamPullStrategy<OutElem2>, onEmit: (elem: OutElem2) => ChildExecutorDecision.ChildExecutorDecision): <Env, InErr, InElem, InDone, OutErr>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>) => Channel<OutElem2, InElem & InElem2, OutErr2 | OutErr, InErr & InErr2, OutDone3, InDone & InDone2, Env2 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env, OutElem2, InElem2, OutErr2, InErr2, OutDone, InDone2, Env2, OutDone3>(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<OutElem2, InElem & InElem2, OutErr | OutErr2, InErr & InErr2, OutDone3, InDone & InDone2, Env | Env2>;
 };
 /**
  * Returns a new channel, which is the same as this one, except its outputs
@@ -279,8 +282,8 @@ export declare const concatMapWithCustom: {
  * @category utils
  */
 export declare const collect: {
-    <Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone>(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>, pf: (o: OutElem) => Option.Option<OutElem2>): Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>;
+    <OutElem, OutElem2>(pf: (o: OutElem) => Option.Option<OutElem2>): <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<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>;
 };
 /**
  * Returns a new channel, which is the concatenation of all the channels that
@@ -290,7 +293,7 @@ export declare const collect: {
  * @since 2.0.0
  * @category utils
  */
-export declare const concatOut: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown>, OutDone>) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, unknown>;
+export declare const concatOut: <OutElem, InElem, OutErr, InErr, InDone, Env, OutDone>(self: Channel<Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env>, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem, InElem, OutErr, InErr, unknown, InDone, Env>;
 /**
  * Returns a new channel which is the same as this one but applies the given
  * function to the input channel's done value.
@@ -299,8 +302,8 @@ export declare const concatOut: <Env, InErr, InElem, InDone, OutErr, OutElem, Ou
  * @category utils
  */
 export declare 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>, f: (a: InDone0) => InDone): Channel<Env, InErr, InElem, InDone0, OutErr, OutElem, OutDone>;
+    <InDone0, InDone>(f: (a: InDone0) => InDone): <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<OutElem, InElem, OutErr, InErr, OutDone, InDone0, Env>;
 };
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -310,8 +313,8 @@ export declare const mapInput: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -321,8 +324,8 @@ export declare const mapInputEffect: {
  * @category utils
  */
 export declare 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>, f: (a: InErr0) => InErr): Channel<Env, InErr0, InElem, InDone, OutErr, OutElem, OutDone>;
+    <InErr0, InErr>(f: (a: InErr0) => InErr): <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<OutElem, InElem, OutErr, InErr0, OutDone, InDone, Env>;
 };
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -332,8 +335,8 @@ export declare const mapInputError: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -343,8 +346,8 @@ export declare const mapInputErrorEffect: {
  * @category utils
  */
 export declare 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>, f: (a: InElem0) => InElem): Channel<Env, InErr, InElem0, InDone, OutErr, OutElem, OutDone>;
+    <InElem0, InElem>(f: (a: InElem0) => InElem): <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<OutElem, InElem0, OutErr, InErr, OutDone, InDone, Env>;
 };
 /**
  * Returns a new channel which is the same as this one but applies the given
@@ -354,8 +357,8 @@ export declare const mapInputIn: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel, which is the same as this one, except that all the
@@ -369,7 +372,7 @@ export declare const mapInputInEffect: {
  * @since 2.0.0
  * @category utils
  */
-export declare 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]>;
+export declare 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>;
 /**
  * Returns a new channel which reads all the elements from upstream's output
  * channel and ignores them, then terminates with the upstream result value.
@@ -377,7 +380,7 @@ export declare const doneCollect: <Env, InErr, InElem, InDone, OutErr, OutElem,
  * @since 2.0.0
  * @category utils
  */
-export declare 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>;
+export declare 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>;
 /**
  * Returns a new channel which connects the given `AsyncInputProducer` as
  * this channel's input.
@@ -386,8 +389,8 @@ export declare const drain: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
  * @category utils
  */
 export declare 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>, input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    <InErr, InElem, InDone>(input: SingleProducerAsyncInput.AsyncInputProducer<InErr, InElem, InDone>): <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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>;
 };
 /**
  * Returns a new channel that collects the output and terminal value of this
@@ -396,7 +399,7 @@ export declare const embedInput: {
  * @since 2.0.0
  * @category utils
  */
-export declare 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>;
+export declare 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>;
 /**
  * Returns a new channel with an attached finalizer. The finalizer is
  * guaranteed to be executed so long as the channel begins execution (and
@@ -406,8 +409,8 @@ export declare const emitCollect: <Env, InErr, InElem, InDone, OutErr, OutElem,
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel with an attached finalizer. The finalizer is
@@ -418,8 +421,8 @@ export declare const ensuring: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Accesses the whole context of the channel.
@@ -427,35 +430,35 @@ export declare const ensuringWith: {
  * @since 2.0.0
  * @category context
  */
-export declare const context: <Env>() => Channel<Env, unknown, unknown, unknown, never, never, Context.Context<Env>>;
+export declare const context: <Env>() => Channel<never, unknown, never, unknown, Context.Context<Env>, unknown, Env>;
 /**
  * Accesses the context of the channel with the specified function.
  *
  * @since 2.0.0
  * @category context
  */
-export declare const contextWith: <Env, OutDone>(f: (env: Context.Context<Env>) => OutDone) => Channel<Env, unknown, unknown, unknown, never, never, OutDone>;
+export declare const contextWith: <Env, OutDone>(f: (env: Context.Context<Env>) => OutDone) => Channel<never, unknown, never, unknown, OutDone, unknown, Env>;
 /**
  * Accesses the context of the channel in the context of a channel.
  *
  * @since 2.0.0
  * @category context
  */
-export declare 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>;
+export declare 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>;
 /**
  * Accesses the context of the channel in the context of an effect.
  *
  * @since 2.0.0
  * @category context
  */
-export declare 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>;
+export declare 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>;
 /**
  * Constructs a channel that fails immediately with the specified error.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fail: <E>(error: E) => Channel<never, unknown, unknown, unknown, E, never, never>;
+export declare const fail: <E>(error: E) => Channel<never, unknown, E, unknown, never, unknown>;
 /**
  * Constructs a channel that succeeds immediately with the specified lazily
  * evaluated value.
@@ -463,14 +466,14 @@ export declare const fail: <E>(error: E) => Channel<never, unknown, unknown, unk
  * @since 2.0.0
  * @category constructors
  */
-export declare const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, unknown, unknown, unknown, E, never, never>;
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, unknown, E, unknown, never, unknown>;
 /**
  * Constructs a channel that fails immediately with the specified `Cause`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unknown, unknown, unknown, E, never, never>;
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unknown, E, unknown, never, unknown>;
 /**
  * Constructs a channel that succeeds immediately with the specified lazily
  * evaluated `Cause`.
@@ -478,7 +481,7 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, unk
  * @since 2.0.0
  * @category constructors
  */
-export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Channel<never, unknown, unknown, unknown, E, never, never>;
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Channel<never, unknown, E, unknown, never, unknown>;
 /**
  * Returns a new channel, which sequentially combines this channel, together
  * with the provided factory function, which creates a second channel based on
@@ -490,8 +493,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ch
  * @category sequencing
  */
 export declare 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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone2>;
-    <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>): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem | OutElem1, OutDone2>;
+    <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<OutElem1 | OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone2, InDone & InDone1, Env1 | Env>;
+    <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<OutElem | OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, OutDone2, InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a new channel, which flattens the terminal value of this channel.
@@ -501,7 +504,7 @@ export declare const flatMap: {
  * @since 2.0.0
  * @category sequencing
  */
-export declare const flatten: <Env, InErr, InElem, InDone, OutErr, OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone2>>) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem | OutElem1, OutDone2>;
+export declare const flatten: <OutElem, InElem, OutErr, InErr, OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1, InDone, Env>(self: Channel<OutElem, InElem, OutErr, InErr, Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone2, InDone1, Env1>, InDone, Env>) => Channel<OutElem | OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, OutDone2, InDone & InDone1, Env1 | Env>;
 /**
  * Folds over the result of this channel.
  *
@@ -509,14 +512,14 @@ export declare const flatten: <Env, InErr, InElem, InDone, OutErr, OutElem, Env1
  * @category utils
  */
 export declare const foldChannel: {
-    <Env1, Env2, InErr1, InErr2, InElem1, InElem2, InDone1, InDone2, OutErr, OutErr1, OutErr2, OutElem1, OutElem2, OutDone, OutDone1, OutDone2>(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>;
-    }): <Env, InErr, InElem, InDone, OutElem>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env2 | Env, InErr & InErr1 & InErr2, InElem & InElem1 & InElem2, InDone & InDone1 & InDone2, OutErr1 | OutErr2, OutElem1 | OutElem2 | OutElem, OutDone1 | OutDone2>;
-    <Env, InErr, InElem, InDone, OutElem, Env1, Env2, InErr1, InErr2, InElem1, InElem2, InDone1, InDone2, OutErr, OutErr1, OutErr2, OutElem1, OutElem2, OutDone, OutDone1, OutDone2>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, 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>;
-    }): Channel<Env | Env1 | Env2, InErr & InErr1 & InErr2, InElem & InElem1 & InElem2, InDone & InDone1 & InDone2, OutErr1 | OutErr2, OutElem | OutElem1 | OutElem2, OutDone1 | OutDone2>;
+    <OutErr, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutDone, OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>(options: {
+        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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem2 | OutElem, InElem & InElem1 & InElem2, OutErr1 | OutErr2, InErr & InErr1 & InErr2, OutDone1 | OutDone2, InDone & InDone1 & InDone2, Env1 | Env2 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutElem2, InElem2, OutErr2, InErr2, OutDone2, InDone2, Env2>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, options: {
+        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<OutElem | OutElem1 | OutElem2, InElem & InElem1 & InElem2, OutErr1 | OutErr2, InErr & InErr1 & InErr2, OutDone1 | OutDone2, InDone & InDone1 & InDone2, Env | Env1 | Env2>;
 };
 /**
  * Folds over the result of this channel including any cause of termination.
@@ -525,14 +528,14 @@ export declare const foldChannel: {
  * @category utils
  */
 export declare const foldCauseChannel: {
-    <Env1, Env2, InErr1, InErr2, InElem1, InElem2, InDone1, InDone2, OutErr, OutErr2, OutErr3, OutElem1, OutElem2, OutDone, OutDone2, OutDone3>(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>;
-    }): <Env, InErr, InElem, InDone, OutElem>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env2 | Env, InErr & InErr1 & InErr2, InElem & InElem1 & InElem2, InDone & InDone1 & InDone2, OutErr2 | OutErr3, OutElem1 | OutElem2 | OutElem, OutDone2 | OutDone3>;
-    <Env, InErr, InElem, InDone, OutElem, Env1, Env2, InErr1, InErr2, InElem1, InElem2, InDone1, InDone2, OutErr, OutErr2, OutErr3, OutElem1, OutElem2, OutDone, OutDone2, OutDone3>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, 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<Env | Env1 | Env2, InErr & InErr1 & InErr2, InElem & InElem1 & InElem2, InDone & InDone1 & InDone2, OutErr2 | OutErr3, OutElem | OutElem1 | OutElem2, OutDone2 | OutDone3>;
+    <OutErr, OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1, OutDone, OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>(options: {
+        readonly onFailure: (c: Cause.Cause<OutErr>) => 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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem2 | OutElem, InElem & InElem1 & InElem2, OutErr2 | OutErr3, InErr & InErr1 & InErr2, OutDone2 | OutDone3, InDone & InDone1 & InDone2, Env1 | Env2 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1, OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, options: {
+        readonly onFailure: (c: Cause.Cause<OutErr>) => Channel<OutElem1, InElem1, OutErr2, InErr1, OutDone2, InDone1, Env1>;
+        readonly onSuccess: (o: OutDone) => Channel<OutElem2, InElem2, OutErr3, InErr2, OutDone3, InDone2, Env2>;
+    }): Channel<OutElem | OutElem1 | OutElem2, InElem & InElem1 & InElem2, OutErr2 | OutErr3, InErr & InErr1 & InErr2, OutDone2 | OutDone3, InDone & InDone1 & InDone2, Env | Env1 | Env2>;
 };
 /**
  * Use an effect to end a channel.
@@ -540,54 +543,54 @@ export declare const foldCauseChannel: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Channel<R, unknown, unknown, unknown, E, never, A>;
+export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Channel<never, unknown, E, unknown, A, unknown, R>;
 /**
  * Constructs a channel from an `Either`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, unknown, unknown, unknown, E, never, A>;
+export declare const fromEither: <E, A>(either: Either.Either<E, A>) => Channel<never, unknown, E, unknown, A, unknown>;
 /**
  * Construct a `Channel` from an `AsyncInputConsumer`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromInput: <Err, Elem, Done>(input: SingleProducerAsyncInput.AsyncInputConsumer<Err, Elem, Done>) => Channel<never, unknown, unknown, unknown, Err, Elem, Done>;
+export declare const fromInput: <Err, Elem, Done>(input: SingleProducerAsyncInput.AsyncInputConsumer<Err, Elem, Done>) => Channel<Elem, unknown, Err, unknown, Done, unknown>;
 /**
  * Construct a `Channel` from a `PubSub`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromPubSub: <Err, Done, Elem>(pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Err, Done>, Elem>>) => Channel<never, unknown, unknown, unknown, Err, Elem, Done>;
+export declare const fromPubSub: <Done, Err, Elem>(pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>) => Channel<Elem, unknown, Err, unknown, Done, unknown>;
 /**
  * Construct a `Channel` from a `PubSub` within a scoped effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>>;
+export declare 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>;
 /**
  * Construct a `Channel` from an `Option`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromOption: <A>(option: Option.Option<A>) => Channel<never, unknown, unknown, unknown, Option.Option<never>, never, A>;
+export declare const fromOption: <A>(option: Option.Option<A>) => Channel<never, unknown, Option.Option<never>, unknown, A, unknown>;
 /**
  * Construct a `Channel` from a `Queue`.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const fromQueue: <Err, Elem, Done>(queue: Queue.Dequeue<Either.Either<Exit.Exit<Err, Done>, Elem>>) => Channel<never, unknown, unknown, unknown, Err, Elem, Done>;
+export declare const fromQueue: <Done, Err, Elem>(queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>) => Channel<Elem, unknown, Err, unknown, Done, unknown>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const identity: <Err, Elem, Done>() => Channel<never, Err, Elem, Done, Err, Elem, Done>;
+export declare const identity: <Elem, Err, Done>() => Channel<Elem, Elem, Err, Err, Done, Done>;
 /**
  * Returns a new channel, which is the same as this one, except it will be
  * interrupted when the specified effect completes. If the effect completes
@@ -601,8 +604,8 @@ export declare const identity: <Err, Elem, Done>() => Channel<never, Err, Elem,
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel, which is the same as this one, except it will be
@@ -616,8 +619,8 @@ export declare const interruptWhen: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel, which is the same as this one, except the terminal
@@ -628,8 +631,8 @@ export declare const interruptWhenDeferred: {
  * @category mapping
  */
 export declare 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>, f: (out: OutDone) => OutDone2): Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>;
+    <OutDone, OutDone2>(f: (out: OutDone) => OutDone2): <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<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env>;
 };
 /**
  * Returns a new channel, which is the same as this one, except the terminal
@@ -640,8 +643,8 @@ export declare const map: {
  * @category mapping
  */
 export declare 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>;
 };
 /**
  * Returns a new channel, which is the same as this one, except the failure
@@ -652,8 +655,8 @@ export declare const mapEffect: {
  * @category mapping
  */
 export declare 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>, f: (err: OutErr) => OutErr2): Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>;
+    <OutErr, OutErr2>(f: (err: OutErr) => OutErr2): <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<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>;
 };
 /**
  * A more powerful version of `mapError` which also surfaces the `Cause`
@@ -663,8 +666,8 @@ export declare const mapError: {
  * @category mapping
  */
 export declare 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>, f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>): Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone>;
+    <OutErr, OutErr2>(f: (cause: Cause.Cause<OutErr>) => Cause.Cause<OutErr2>): <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<OutElem, InElem, OutErr2, InErr, OutDone, InDone, Env>;
 };
 /**
  * Maps the output of this channel using the specified function.
@@ -673,8 +676,8 @@ export declare const mapErrorCause: {
  * @category mapping
  */
 export declare 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>, f: (o: OutElem) => OutElem2): Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>;
+    <OutElem, OutElem2>(f: (o: OutElem) => OutElem2): <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<OutElem2, InElem, OutErr, InErr, OutDone, InDone, Env>;
 };
 /**
  * Creates a channel that is like this channel but the given effectful function
@@ -684,8 +687,8 @@ export declare const mapOut: {
  * @category mapping
  */
 export declare 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>;
 };
 /**
  * Creates a channel that is like this channel but the given ZIO function gets
@@ -696,8 +699,8 @@ export declare const mapOutEffect: {
  * @category mapping
  */
 export declare const mapOutEffectPar: {
-    <OutElem, Env1, OutErr1, OutElem1>(f: (o: OutElem) => Effect.Effect<Env1, OutErr1, OutElem1>, 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>, n: number): Channel<Env | Env1, InErr, InElem, InDone, OutErr | OutErr1, OutElem1, OutDone>;
+    <OutElem, OutElem1, OutErr1, Env1>(f: (o: OutElem) => Effect.Effect<OutElem1, OutErr1, Env1>, n: number): <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<OutElem1, InElem, OutErr | OutErr1, InErr, OutDone, InDone, Env | Env1>;
 };
 /**
  * @since 2.0.0
@@ -707,17 +710,17 @@ export declare const mergeAll: (options: {
     readonly concurrency: number | "unbounded";
     readonly bufferSize?: number | undefined;
     readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined;
-}) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem>(channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>, unknown>) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, unknown>;
+}) => <OutElem, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(channels: Channel<Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>, InElem, OutErr, InErr, unknown, InDone, Env>) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env>;
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const mergeAllUnbounded: <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem>(channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, unknown>, unknown>) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, unknown>;
+export declare const mergeAllUnbounded: <OutElem, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(channels: Channel<Channel<OutElem, InElem1, OutErr1, InErr1, unknown, InDone1, Env1>, InElem, OutErr, InErr, unknown, InDone, Env>) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env>;
 /**
  * @since 2.0.0
  * @category utils
  */
-export declare const mergeAllUnboundedWith: <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem, OutDone>(channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>, OutDone>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone>;
+export declare const mergeAllUnboundedWith: <OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(channels: Channel<Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone, InDone & InDone1, Env1 | Env>;
 /**
  * @since 2.0.0
  * @category utils
@@ -726,7 +729,7 @@ export declare const mergeAllWith: ({ bufferSize, concurrency, mergeStrategy }:
     readonly concurrency: number | "unbounded";
     readonly bufferSize?: number | undefined;
     readonly mergeStrategy?: MergeStrategy.MergeStrategy | undefined;
-}) => <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem, OutDone>(channels: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem, OutDone>, OutDone>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem, OutDone>;
+}) => <OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(channels: Channel<Channel<OutElem, InElem1, OutErr1, InErr1, OutDone, InDone1, Env1>, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (o1: OutDone, o2: OutDone) => OutDone) => Channel<OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone, InDone & InDone1, Env1 | Env>;
 /**
  * Returns a new channel which creates a new channel for each emitted element
  * and merges some of them together. Different merge strategies control what
@@ -739,16 +742,16 @@ export declare const mergeAllWith: ({ bufferSize, concurrency, mergeStrategy }:
  * @category mapping
  */
 export declare const mergeMap: {
-    <OutElem, Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>(f: (outElem: OutElem) => Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>, options: {
+    <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>, options: {
+    }): <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>;
 };
 /**
  * Returns a new channel which merges a number of channels emitted by this
@@ -758,8 +761,8 @@ export declare const mergeMap: {
  * @category utils
  */
 export declare const mergeOut: {
-    (n: number): <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1, OutDone, Z>(self: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>, OutDone>) => 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>(self: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, Z>, OutDone>, n: number): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, unknown>;
+    (n: number): <OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1, InElem, OutErr, InErr, OutDone, InDone, Env>(self: Channel<Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>, InElem, OutErr, InErr, OutDone, InDone, Env>) => 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<Channel<OutElem1, InElem1, OutErr1, InErr1, Z, InDone1, Env1>, InElem, OutErr, InErr, OutDone, InDone, Env>, n: number): Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, unknown, InDone & InDone1, Env1 | Env>;
 };
 /**
  * Returns a new channel which merges a number of channels emitted by this
@@ -771,8 +774,8 @@ export declare const mergeOut: {
  * @category utils
  */
 export declare const mergeOutWith: {
-    <OutDone1>(n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): <Env, Env1, InErr, InErr1, InElem, InElem1, InDone, InDone1, OutErr, OutErr1, OutElem1>(self: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>, OutDone1>) => 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>(self: Channel<Env, InErr, InElem, InDone, OutErr, Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>, OutDone1>, n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem1, OutDone1>;
+    <OutDone1>(n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): <OutElem1, InElem1, OutErr1, InErr1, InDone1, Env1, InElem, OutErr, InErr, InDone, Env>(self: Channel<Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>, InElem, OutErr, InErr, OutDone1, InDone, Env>) => 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<Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>, InElem, OutErr, InErr, OutDone1, InDone, Env>, n: number, f: (o1: OutDone1, o2: OutDone1) => OutDone1): Channel<OutElem1, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone1, InDone & InDone1, Env1 | Env>;
 };
 /**
  * Returns a new channel, which is the merge of this channel and the specified
@@ -784,16 +787,16 @@ export declare const mergeOutWith: {
  * @category utils
  */
 export declare const mergeWith: {
-    <Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutErr2, OutErr3, OutElem1, OutDone, OutDone1, OutDone2, OutDone3>(options: {
-        readonly other: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>;
-        readonly onSelfDone: (exit: Exit.Exit<OutErr, OutDone>) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>;
-        readonly onOtherDone: (ex: Exit.Exit<OutErr1, OutDone1>) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>;
-    }): <Env, InErr, InElem, InDone, OutElem>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr2 | OutErr3, OutElem1 | OutElem, OutDone2 | OutDone3>;
-    <Env, InErr, InElem, InDone, OutElem, Env1, InErr1, InElem1, InDone1, OutErr, OutErr1, OutErr2, OutErr3, OutElem1, OutDone, OutDone1, OutDone2, OutDone3>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, options: {
-        readonly other: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>;
-        readonly onSelfDone: (exit: Exit.Exit<OutErr, OutDone>) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>;
-        readonly onOtherDone: (ex: Exit.Exit<OutErr1, OutDone1>) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>;
-    }): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr2 | OutErr3, OutElem | OutElem1, OutDone2 | OutDone3>;
+    <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutDone, OutErr, OutErr2, OutDone2, OutErr3, OutDone3>(options: {
+        readonly other: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>;
+        readonly onSelfDone: (exit: Exit.Exit<OutDone, OutErr>) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>;
+        readonly onOtherDone: (ex: Exit.Exit<OutDone1, OutErr1>) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>;
+    }): <Env, InErr, InElem, InDone, OutElem>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem, InElem & InElem1, OutErr2 | OutErr3, InErr & InErr1, OutDone2 | OutDone3, InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1, OutErr2, OutDone2, OutErr3, OutDone3>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, options: {
+        readonly other: Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>;
+        readonly onSelfDone: (exit: Exit.Exit<OutDone, OutErr>) => MergeDecision.MergeDecision<Env1, OutErr1, OutDone1, OutErr2, OutDone2>;
+        readonly onOtherDone: (ex: Exit.Exit<OutDone1, OutErr1>) => MergeDecision.MergeDecision<Env1, OutErr, OutDone, OutErr3, OutDone3>;
+    }): Channel<OutElem | OutElem1, InElem & InElem1, OutErr2 | OutErr3, InErr & InErr1, OutDone2 | OutDone3, InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a channel that never completes
@@ -801,7 +804,7 @@ export declare const mergeWith: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const never: Channel<never, unknown, unknown, unknown, never, never, never>;
+export declare const never: Channel<never, unknown, never, unknown, never, unknown>;
 /**
  * Translates channel failure into death of the fiber, making all failures
  * unchecked and not a part of the type of the channel.
@@ -810,8 +813,8 @@ export declare const never: Channel<never, unknown, unknown, unknown, never, nev
  * @category error handling
  */
 export declare 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>, error: LazyArg<E>): Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>;
+    <E>(error: LazyArg<E>): <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<OutElem, InElem, never, InErr, OutDone, InDone, Env>;
 };
 /**
  * Keeps none of the errors, and terminates the fiber with them, using the
@@ -821,8 +824,8 @@ export declare const orDie: {
  * @category error handling
  */
 export declare 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>, f: (e: OutErr) => unknown): Channel<Env, InErr, InElem, InDone, never, OutElem, OutDone>;
+    <OutErr>(f: (e: OutErr) => unknown): <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<OutElem, InElem, never, InErr, OutDone, InDone, Env>;
 };
 /**
  * Returns a new channel that will perform the operations of this one, until
@@ -833,8 +836,8 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare 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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem1 | OutElem, OutDone1 | OutDone>;
-    <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>>): Channel<Env | Env1, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1, OutElem | OutElem1, OutDone | OutDone1>;
+    <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<OutElem1 | OutElem, InElem & InElem1, OutErr1, InErr & InErr1, OutDone1 | OutDone, InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, that: LazyArg<Channel<OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>>): Channel<OutElem | OutElem1, InElem & InElem1, OutErr1, InErr & InErr1, OutDone | OutDone1, InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a new channel that pipes the output of this channel into the
@@ -846,8 +849,8 @@ export declare const orElse: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Returns a new channel that pipes the output of this channel into the
@@ -858,8 +861,8 @@ export declare const pipeTo: {
  * @category utils
  */
 export declare 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>;
 };
 /**
  * Provides the channel with its required context, which eliminates its
@@ -869,8 +872,8 @@ export declare const pipeToOrFail: {
  * @category context
  */
 export declare 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>, env: Context.Context<Env>): Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    <Env>(env: Context.Context<Env>): <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<OutElem, InElem, OutErr, InErr, OutDone, InDone, never>;
 };
 /**
  * Provides a layer to the channel, which translates it to another level.
@@ -879,8 +882,8 @@ export declare const provideContext: {
  * @category context
  */
 export declare 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>;
 };
 /**
  * Transforms the context being provided to the channel with the specified
@@ -890,8 +893,8 @@ export declare const provideLayer: {
  * @category context
  */
 export declare 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>, f: (env: Context.Context<Env0>) => Context.Context<Env>): Channel<Env0, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    <Env0, Env>(f: (env: Context.Context<Env0>) => Context.Context<Env>): <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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env0>;
 };
 /**
  * Splits the context into two parts, providing one part using the
@@ -901,8 +904,8 @@ export declare const mapInputContext: {
  * @category context
  */
 export declare 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>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -912,51 +915,51 @@ export declare const provideSomeLayer: {
  * @category context
  */
 export declare 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>, tag: T, service: Context.Tag.Service<T>): Channel<Exclude<Env, Context.Tag.Identifier<T>>, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <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<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Context.Tag.Identifier<T>>>;
 };
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const read: <In>() => Channel<never, unknown, In, unknown, Option.Option<never>, never, In>;
+export declare const read: <In>() => Channel<never, In, Option.Option<never>, unknown, In, unknown>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const readOrFail: <In, E>(error: E) => Channel<never, unknown, In, unknown, E, never, In>;
+export declare const readOrFail: <E, In = unknown>(error: E) => Channel<never, In, E, unknown, In, unknown>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const readWith: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env2, OutErr2, OutElem2, OutDone2, Env3, OutErr3, OutElem3, OutDone3>(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>;
-}) => Channel<Env | Env2 | Env3, InErr, InElem, InDone, OutErr | OutErr2 | OutErr3, OutElem | OutElem2 | OutElem3, OutDone | OutDone2 | OutDone3>;
+export declare const readWith: <InElem, OutElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2, OutElem3, OutErr3, OutDone3, Env3>(options: {
+    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<OutElem | OutElem2 | OutElem3, InElem, OutErr | OutErr2 | OutErr3, InErr, OutDone | OutDone2 | OutDone3, InDone, Env | Env2 | Env3>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const readWithCause: <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, Env2, OutErr2, OutElem2, OutDone2, Env3, OutErr3, OutElem3, OutDone3>(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>;
-}) => Channel<Env | Env2 | Env3, InErr, InElem, InDone, OutErr | OutErr2 | OutErr3, OutElem | OutElem2 | OutElem3, OutDone | OutDone2 | OutDone3>;
+export declare const readWithCause: <InElem, OutElem, OutErr, InErr, OutDone, InDone, Env, OutElem2, OutErr2, OutDone2, Env2, OutElem3, OutErr3, OutDone3, Env3>(options: {
+    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<OutElem | OutElem2 | OutElem3, InElem, OutErr | OutErr2 | OutErr3, InErr, OutDone | OutDone2 | OutDone3, InDone, Env | Env2 | Env3>;
 /**
  * Creates a channel which repeatedly runs this channel.
  *
  * @since 2.0.0
  * @category utils
  */
-export declare 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>;
+export declare 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>;
 /**
  * Runs a channel until the end is received.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const run: <Env, InErr, InDone, OutErr, OutDone>(self: Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>) => Effect.Effect<Env, OutErr, OutDone>;
+export declare const run: <OutErr, InErr, OutDone, InDone, Env>(self: Channel<never, unknown, OutErr, InErr, OutDone, InDone, Env>) => Effect.Effect<OutDone, OutErr, Env>;
 /**
  * Run the channel until it finishes with a done value or fails with an error
  * and collects its emitted output elements.
@@ -966,49 +969,49 @@ export declare const run: <Env, InErr, InDone, OutErr, OutDone>(self: Channel<En
  * @since 2.0.0
  * @category destructors
  */
-export declare 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]>;
+export declare 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>;
 /**
  * Runs a channel until the end is received.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runDrain: <Env, InErr, InDone, OutElem, OutErr, OutDone>(self: Channel<Env, InErr, unknown, InDone, OutErr, OutElem, OutDone>) => Effect.Effect<Env, OutErr, OutDone>;
+export declare const runDrain: <OutElem, OutErr, InErr, OutDone, InDone, Env>(self: Channel<OutElem, unknown, OutErr, InErr, OutDone, InDone, Env>) => Effect.Effect<OutDone, OutErr, Env>;
 /**
  * Use a scoped effect to emit an output element.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Channel<Exclude<R, Scope.Scope>, unknown, unknown, unknown, E, A, unknown>;
+export declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Channel<A, unknown, E, unknown, unknown, unknown, Exclude<R, Scope.Scope>>;
 /**
  * Constructs a channel that succeeds immediately with the specified value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const succeed: <A>(value: A) => Channel<never, unknown, unknown, unknown, never, never, A>;
+export declare const succeed: <A>(value: A) => Channel<never, unknown, never, unknown, A, unknown>;
 /**
  * Lazily constructs a channel from the given side effect.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>;
 /**
  * Constructs a channel that succeeds immediately with the specified lazy value.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const sync: <OutDone>(evaluate: LazyArg<OutDone>) => Channel<never, unknown, unknown, unknown, never, never, OutDone>;
+export declare const sync: <OutDone>(evaluate: LazyArg<OutDone>) => Channel<never, unknown, never, unknown, OutDone, unknown>;
 /**
  * Converts a `Channel` to a `PubSub`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const toPubSub: <Err, Done, Elem>(pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Err, Done>, Elem>>) => Channel<never, Err, Elem, Done, never, never, unknown>;
+export declare const toPubSub: <Done, Err, Elem>(pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>) => Channel<never, Elem, never, Err, unknown, Done>;
 /**
  * Returns a scoped `Effect` that can be used to repeatedly pull elements from
  * the constructed `Channel`. The pull effect fails with the channel's failure
@@ -1018,46 +1021,46 @@ export declare const toPubSub: <Err, Done, Elem>(pubsub: PubSub.PubSub<Either.Ei
  * @since 2.0.0
  * @category destructors
  */
-export declare 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 declare 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>;
 /**
  * Converts a `Channel` to a `Queue`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const toQueue: <Err, Done, Elem>(queue: Queue.Enqueue<Either.Either<Exit.Exit<Err, Done>, Elem>>) => Channel<never, Err, Elem, Done, never, never, unknown>;
+export declare const toQueue: <Done, Err, Elem>(queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>) => Channel<never, Elem, never, Err, unknown, Done>;
 /** Converts this channel to a `Sink`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare 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>;
+export declare 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>;
 /**
  * Converts this channel to a `Stream`.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const toStream: <Env, OutErr, OutElem, OutDone>(self: Channel<Env, unknown, unknown, unknown, OutErr, Chunk.Chunk<OutElem>, OutDone>) => Stream.Stream<Env, OutErr, OutElem>;
+export declare const toStream: <OutElem, OutErr, OutDone, Env>(self: Channel<Chunk.Chunk<OutElem>, unknown, OutErr, unknown, OutDone, unknown, Env>) => Stream.Stream<OutElem, OutErr, Env>;
 /**
  * @since 2.0.0
  * @category constructors
  */
-export declare const unit: Channel<never, unknown, unknown, unknown, never, never, void>;
+export declare const unit: Channel<never>;
 /**
  * Makes a channel from an effect that returns a channel in case of success.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>;
 /**
  * Makes a channel from a managed that returns a channel in case of success.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare 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>;
+export declare 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>>;
 /**
  * Updates a service in the context of this channel.
  *
@@ -1065,8 +1068,8 @@ export declare const unwrapScoped: <R, E, Env, InErr, InElem, InDone, OutErr, Ou
  * @category context
  */
 export declare 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>, tag: T, f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>): Channel<R | T, InErr, unknown, InDone, OutErr, OutElem, OutDone>;
+    <T extends Context.Tag<any, any>>(tag: T, f: (resource: Context.Tag.Service<T>) => Context.Tag.Service<T>): <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<OutElem, unknown, OutErr, InErr, OutDone, InDone, R | T>;
 };
 /**
  * Wraps the channel with a new span for tracing.
@@ -1081,14 +1084,14 @@ export declare 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>, name: string, options?: {
+    } | 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;
         readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined;
         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>>;
 };
 /**
  * Writes a single value to the channel.
@@ -1096,21 +1099,21 @@ export declare const withSpan: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const write: <OutElem>(out: OutElem) => Channel<never, unknown, unknown, unknown, never, OutElem, void>;
+export declare const write: <OutElem>(out: OutElem) => Channel<OutElem>;
 /**
  * Writes a sequence of values to the channel.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const writeAll: <OutElems extends Array<any>>(...outs: OutElems) => Channel<never, unknown, unknown, unknown, never, OutElems[number], void>;
+export declare const writeAll: <OutElems extends Array<any>>(...outs: OutElems) => Channel<OutElems[number]>;
 /**
  * Writes a `Chunk` of values to the channel.
  *
  * @since 2.0.0
  * @category constructors
  */
-export declare const writeChunk: <OutElem>(outs: Chunk.Chunk<OutElem>) => Channel<never, unknown, unknown, unknown, never, OutElem, void>;
+export declare const writeChunk: <OutElem>(outs: Chunk.Chunk<OutElem>) => Channel<OutElem>;
 /**
  * Returns a new channel that is the sequential composition of this channel
  * and the specified channel. The returned channel terminates with a tuple of
@@ -1120,12 +1123,12 @@ export declare const writeChunk: <OutElem>(outs: Chunk.Chunk<OutElem>) => Channe
  * @category zipping
  */
 export declare const zip: {
-    <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>, options?: {
+    <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, readonly [OutDone, OutDone1]>;
-    <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?: {
+    } | undefined): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, readonly [OutDone, OutDone1], InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(self: Channel<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, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem | OutElem1, readonly [OutDone, OutDone1]>;
+    } | undefined): Channel<OutElem | OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, readonly [OutDone, OutDone1], InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a new channel that is the sequential composition of this channel
@@ -1136,12 +1139,12 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
-    <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>, options?: {
+    <OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone>;
-    <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?: {
+    } | undefined): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone, InDone & InDone1, Env1 | Env>;
+    <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env, OutElem1, InElem1, OutErr1, InErr1, OutDone1, InDone1, Env1>(self: Channel<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, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem | OutElem1, OutDone>;
+    } | undefined): Channel<OutElem | OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, OutDone, InDone & InDone1, Env | Env1>;
 };
 /**
  * Returns a new channel that is the sequential composition of this channel
@@ -1152,12 +1155,12 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
-    <Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>, options?: {
+    <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>) => Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone1>;
-    <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?: {
+    }): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem1 | OutElem, InElem & InElem1, OutErr1 | OutErr, InErr & InErr1, OutDone1, InDone & InDone1, Env1 | Env>;
+    <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone, 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, InElem & InElem1, InDone & InDone1, OutErr | OutErr1, OutElem | OutElem1, OutDone1>;
+    }): Channel<OutElem | OutElem1, InElem & InElem1, OutErr | OutErr1, InErr & InErr1, OutDone1, InDone & InDone1, Env | Env1>;
 };
 /**
  * Represents a generic checked exception which occurs when a `Channel` is