effect 2.2.5 → 2.3.0

package/src/Stream.ts

@@ -45,7 +45,7 @@ export const StreamTypeId: unique symbol = internal.StreamTypeId
 export type StreamTypeId = typeof StreamTypeId
 
 /**
- * A `Stream<R, E, A>` is a description of a program that, when evaluated, may
+ * A `Stream<A, E, R>` is a description of a program that, when evaluated, may
  * emit zero or more values of type `A`, may fail with errors of type `E`, and
  * uses an context of type `R`. One way to think of `Stream` is as a
  * `Effect` program that could emit multiple values.
@@ -64,7 +64,7 @@ export type StreamTypeId = typeof StreamTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, Pipeable {
+export interface Stream<out A, out E = never, out R = never> extends Stream.Variance<A, E, R>, Pipeable {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: StreamUnify<this>
   [Unify.ignoreSymbol]?: StreamUnifyIgnore
@@ -75,7 +75,7 @@ export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, P
  * @category models
  */
 export interface StreamUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
-  Stream?: () => A[Unify.typeSymbol] extends Stream<infer R0, infer E0, infer A0> | infer _ ? Stream<R0, E0, A0> : never
+  Stream?: () => A[Unify.typeSymbol] extends Stream<infer A0, infer E0, infer R0> | infer _ ? Stream<A0, E0, R0> : never
 }
 
 /**
@@ -91,7 +91,7 @@ export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @category models
  */
 declare module "./Effect.js" {
-  interface Effect<R, E, A> extends Stream<R, E, A> {}
+  interface Effect<A, E, R> extends Stream<A, E, R> {}
   interface EffectUnifyIgnore {
     Stream?: true
   }
@@ -102,7 +102,7 @@ declare module "./Effect.js" {
  * @since 2.0.0
  */
 export interface StreamTypeLambda extends TypeLambda {
-  readonly type: Stream<this["Out2"], this["Out1"], this["Target"]>
+  readonly type: Stream<this["Target"], this["Out1"], this["Out2"]>
 }
 
 /**
@@ -113,11 +113,11 @@ export declare namespace Stream {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<out R, out E, out A> {
+  export interface Variance<out A, out E, out R> {
     readonly [StreamTypeId]: {
-      _R: Covariant<R>
-      _E: Covariant<E>
       _A: Covariant<A>
+      _E: Covariant<E>
+      _R: Covariant<R>
     }
   }
 
@@ -152,7 +152,7 @@ export const DefaultChunkSize: number = internal.DefaultChunkSize
  * @since 2.0.0
  * @category utils
  */
-export const accumulate: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>> = internal.accumulate
+export const accumulate: <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R> = internal.accumulate
 
 /**
  * Re-chunks the elements of the stream by accumulating each underlying chunk.
@@ -160,7 +160,7 @@ export const accumulate: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.
  * @since 2.0.0
  * @category utils
  */
-export const accumulateChunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = internal.accumulateChunks
+export const accumulateChunks: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R> = internal.accumulateChunks
 
 /**
  * Creates a stream from a single value that will get cleaned up after the
@@ -169,10 +169,10 @@ export const accumulateChunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E,
  * @since 2.0.0
  * @category constructors
  */
-export const acquireRelease: <R, E, A, R2, _>(
-  acquire: Effect.Effect<R, E, A>,
-  release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<R2, never, _>
-) => Stream<R | R2, E, A> = internal.acquireRelease
+export const acquireRelease: <A, E, R, R2, _>(
+  acquire: Effect.Effect<A, E, R>,
+  release: (resource: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<_, never, R2>
+) => Stream<A, E, R | R2> = internal.acquireRelease
 
 /**
  * Aggregates elements of this stream using the provided sink for as long as
@@ -191,8 +191,8 @@ export const acquireRelease: <R, E, A, R2, _>(
  * @category utils
  */
 export const aggregate: {
-  <R2, E2, A, A2, B>(sink: Sink.Sink<R2, E2, A | A2, A2, B>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>
-  <R, E, R2, E2, A, A2, B>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A | A2, A2, B>): Stream<R | R2, E | E2, B>
+  <B, A, A2, E2, R2>(sink: Sink.Sink<B, A | A2, A2, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>
+  <A, E, R, B, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<B, A | A2, A2, E2, R2>): Stream<B, E | E2, R | R2>
 } = internal.aggregate
 
 /**
@@ -204,15 +204,15 @@ export const aggregate: {
  * @category utils
  */
 export const aggregateWithin: {
-  <R2, E2, A, A2, B, R3, C>(
-    sink: Sink.Sink<R2, E2, A | A2, A2, B>,
+  <B, A, A2, E2, R2, R3, C>(
+    sink: Sink.Sink<B, A | A2, A2, E2, R2>,
     schedule: Schedule.Schedule<R3, Option.Option<B>, C>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, B>
-  <R, E, R2, E2, A, A2, B, R3, C>(
-    self: Stream<R, E, A>,
-    sink: Sink.Sink<R2, E2, A | A2, A2, B>,
+  ): <E, R>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R3 | R>
+  <A, E, R, B, A2, E2, R2, R3, C>(
+    self: Stream<A, E, R>,
+    sink: Sink.Sink<B, A | A2, A2, E2, R2>,
     schedule: Schedule.Schedule<R3, Option.Option<B>, C>
-  ): Stream<R | R2 | R3, E | E2, B>
+  ): Stream<B, E | E2, R | R2 | R3>
 } = internal.aggregateWithin
 
 /**
@@ -233,15 +233,15 @@ export const aggregateWithin: {
  * @category utils
  */
 export const aggregateWithinEither: {
-  <R2, E2, A, A2, B, R3, C>(
-    sink: Sink.Sink<R2, E2, A | A2, A2, B>,
+  <B, A, A2, E2, R2, R3, C>(
+    sink: Sink.Sink<B, A | A2, A2, E2, R2>,
     schedule: Schedule.Schedule<R3, Option.Option<B>, C>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E, Either.Either<C, B>>
-  <R, E, R2, E2, A, A2, B, R3, C>(
-    self: Stream<R, E, A>,
-    sink: Sink.Sink<R2, E2, A | A2, A2, B>,
+  ): <E, R>(self: Stream<A, E, R>) => Stream<Either.Either<C, B>, E2 | E, R2 | R3 | R>
+  <A, E, R, B, A2, E2, R2, R3, C>(
+    self: Stream<A, E, R>,
+    sink: Sink.Sink<B, A | A2, A2, E2, R2>,
     schedule: Schedule.Schedule<R3, Option.Option<B>, C>
-  ): Stream<R | R2 | R3, E | E2, Either.Either<C, B>>
+  ): Stream<Either.Either<C, B>, E | E2, R | R2 | R3>
 } = internal.aggregateWithinEither
 
 /**
@@ -251,12 +251,15 @@ export const aggregateWithinEither: {
  * @category mapping
  */
 export const as: {
-  <B>(value: B): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <R, E, A, B>(self: Stream<R, E, A>, value: B): Stream<R, E, B>
+  <B>(value: B): <A, E, R>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <R, E, A, B>(self: Stream<A, E, R>, value: B): Stream<B, E, R>
 } = internal.as
 
-const _async: <R, E, A>(register: (emit: Emit.Emit<R, E, A, void>) => void, outputBuffer?: number) => Stream<R, E, A> =
-  internal._async
+const _async: <A, E = never, R = never>(
+  register: (emit: Emit.Emit<R, E, A, void>) => void,
+  outputBuffer?: number
+) => Stream<A, E, R> = internal._async
+
 export {
   /**
    * Creates a stream from an asynchronous callback that can be called multiple
@@ -278,10 +281,10 @@ export {
  * @since 2.0.0
  * @category constructors
  */
-export const asyncEffect: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>,
+export const asyncEffect: <A, E = never, R = never>(
+  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>,
   outputBuffer?: number
-) => Stream<R, E, A> = internal.asyncEffect
+) => Stream<A, E, R> = internal.asyncEffect
 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
@@ -292,10 +295,10 @@ export const asyncEffect: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const asyncInterrupt: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Either.Either<Effect.Effect<R, never, unknown>, Stream<R, E, A>>,
+export const asyncInterrupt: <A, E = never, R = never>(
+  register: (emit: Emit.Emit<R, E, A, void>) => Either.Either<Effect.Effect<unknown, never, R>, Stream<A, E, R>>,
   outputBuffer?: number
-) => Stream<R, E, A> = internal.asyncInterrupt
+) => Stream<A, E, R> = internal.asyncInterrupt
 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
@@ -306,10 +309,10 @@ export const asyncInterrupt: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const asyncOption: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Option.Option<Stream<R, E, A>>,
+export const asyncOption: <A, E = never, R = never>(
+  register: (emit: Emit.Emit<R, E, A, void>) => Option.Option<Stream<A, E, R>>,
   outputBuffer?: number
-) => Stream<R, E, A> = internal.asyncOption
+) => Stream<A, E, R> = internal.asyncOption
 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
@@ -320,10 +323,10 @@ export const asyncOption: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const asyncScoped: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R | Scope.Scope, E, unknown>,
+export const asyncScoped: <A, E = never, R = never>(
+  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>,
   outputBuffer?: number
-) => Stream<Exclude<R, Scope.Scope>, E, A> = internal.asyncScoped
+) => Stream<A, E, Exclude<R, Scope.Scope>> = internal.asyncScoped
 
 /**
  * Returns a `Stream` that first collects `n` elements from the input `Stream`,
@@ -334,15 +337,15 @@ export const asyncScoped: <R, E, A>(
  * @category sequencing
  */
 export const branchAfter: {
-  <A, R2, E2, A2>(
+  <A, A2, E2, R2>(
     n: number,
-    f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
+    f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, E, R, R2, E2, A2>(
+    self: Stream<A, E, R>,
     n: number,
-    f: (input: Chunk.Chunk<A>) => Stream<R2, E2, A2>
-  ): Stream<R | R2, E | E2, A2>
+    f: (input: Chunk.Chunk<A>) => Stream<A2, E2, R2>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.branchAfter
 
 /**
@@ -357,14 +360,14 @@ export const broadcast: {
   <N extends number>(
     n: N,
     maximumLag: number
-  ): <R, E, A>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>
-  <R, E, A, N extends number>(
-    self: Stream<R, E, A>,
+  ): <A, E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
+  <A, E, R, N extends number>(
+    self: Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Stream<never, E, A>, N>>
+  ): Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
 } = internal.broadcast
 
 /**
@@ -376,8 +379,8 @@ export const broadcast: {
  * @category utils
  */
 export const broadcastDynamic: {
-  (maximumLag: number): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>
-  <R, E, A>(self: Stream<R, E, A>, maximumLag: number): Effect.Effect<Scope.Scope | R, never, Stream<never, E, A>>
+  (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
+  <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
 } = internal.broadcastDynamic
 
 /**
@@ -394,14 +397,14 @@ export const broadcastedQueues: {
   <N extends number>(
     n: N,
     maximumLag: number
-  ): <R, E, A>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>
-  <R, E, A, N extends number>(
-    self: Stream<R, E, A>,
+  ): <A, E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>
+  <A, E, R, N extends number>(
+    self: Stream<A, E, R>,
     n: N,
     maximumLag: number
-  ): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Take.Take<E, A>>, N>>
+  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
 } = internal.broadcastedQueues
 
 /**
@@ -417,13 +420,13 @@ export const broadcastedQueues: {
 export const broadcastedQueuesDynamic: {
   (
     maximumLag: number
-  ): <R, E, A>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+  ): <A, E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, R | Scope.Scope>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     maximumLag: number
-  ): Effect.Effect<Scope.Scope | R, never, Effect.Effect<Scope.Scope, never, Queue.Dequeue<Take.Take<E, A>>>>
+  ): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
 } = internal.broadcastedQueuesDynamic
 
 /**
@@ -442,14 +445,14 @@ export const buffer: {
       readonly capacity: number
       readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
     }
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     options: { readonly capacity: "unbounded" } | {
       readonly capacity: number
       readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
     }
-  ): Stream<R, E, A>
+  ): Stream<A, E, R>
 } = internal.buffer
 
 /**
@@ -462,18 +465,12 @@ export const buffer: {
  */
 export const bufferChunks: {
   (
-    options: {
-      readonly capacity: number
-      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-    }
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(
-    self: Stream<R, E, A>,
-    options: {
-      readonly capacity: number
-      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-    }
-  ): Stream<R, E, A>
+    options: { readonly capacity: number; readonly strategy?: "dropping" | "sliding" | "suspend" | undefined }
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    options: { readonly capacity: number; readonly strategy?: "dropping" | "sliding" | "suspend" | undefined }
+  ): Stream<A, E, R>
 } = internal.bufferChunks
 
 /**
@@ -484,8 +481,8 @@ export const bufferChunks: {
  * @category error handling
  */
 export const catchAll: {
-  <E, R2, E2, A2>(f: (error: E) => Stream<R2, E2, A2>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>
-  <R, A, E, R2, E2, A2>(self: Stream<R, E, A>, f: (error: E) => Stream<R2, E2, A2>): Stream<R | R2, E2, A | A2>
+  <E, R2, E2, A2>(f: (error: E) => Stream<A2, E2, R2>): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>
+  <R, A, E, R2, E2, A2>(self: Stream<A, E, R>, f: (error: E) => Stream<A2, E2, R2>): Stream<A | A2, E2, R | R2>
 } = internal.catchAll
 
 /**
@@ -498,12 +495,12 @@ export const catchAll: {
  */
 export const catchAllCause: {
   <E, R2, E2, A2>(
-    f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>
+    f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>
   <R, A, E, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    f: (cause: Cause.Cause<E>) => Stream<R2, E2, A2>
-  ): Stream<R | R2, E2, A | A2>
+    self: Stream<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>
+  ): Stream<A | A2, E2, R | R2>
 } = internal.catchAllCause
 
 /**
@@ -515,12 +512,12 @@ export const catchAllCause: {
  */
 export const catchSome: {
   <E, R2, E2, A2>(
-    pf: (error: E) => Option.Option<Stream<R2, E2, A2>>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>
+    pf: (error: E) => Option.Option<Stream<A2, E2, R2>>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
   <R, A, E, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    pf: (error: E) => Option.Option<Stream<R2, E2, A2>>
-  ): Stream<R | R2, E | E2, A | A2>
+    self: Stream<A, E, R>,
+    pf: (error: E) => Option.Option<Stream<A2, E2, R2>>
+  ): Stream<A | A2, E | E2, R | R2>
 } = internal.catchSome
 
 /**
@@ -533,13 +530,13 @@ export const catchSome: {
 export const catchTag: {
   <K extends E["_tag"] & string, E extends { _tag: string }, R1, E1, A1>(
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Stream<R1, E1, A1>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
+    f: (e: Extract<E, { _tag: K }>) => Stream<A1, E1, R1>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   <R, E extends { _tag: string }, A, K extends E["_tag"] & string, R1, E1, A1>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Stream<R1, E1, A1>
-  ): Stream<R | R1, E1 | Exclude<E, { _tag: K }>, A | A1>
+    f: (e: Extract<E, { _tag: K }>) => Stream<A1, E1, R1>
+  ): Stream<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
 } = internal.catchTag
 
 /**
@@ -552,25 +549,25 @@ export const catchTag: {
 export const catchTags: {
   <
     E extends { _tag: string },
-    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Stream<any, any, any>) | undefined }
+    Cases extends { [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Stream<any, any, any> }
   >(
     cases: Cases
   ): <R, A>(
-    self: Stream<R, E, A>
+    self: Stream<A, E, R>
   ) => Stream<
-    | R
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer A, infer _E, infer _R> ? A
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _A, infer E, infer _R> ? E
         : never
     }[keyof Cases],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _A, infer _E, infer R> ? R
         : never
     }[keyof Cases]
   >
@@ -578,14 +575,14 @@ export const catchTags: {
     R,
     E extends { _tag: string },
     A,
-    Cases extends { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Stream<any, any, any>) | undefined }
+    Cases extends { [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Stream<any, any, any> }
   >(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     cases: Cases
   ): Stream<
-    | R
+    | A
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A
         : never
     }[keyof Cases],
     | Exclude<E, { _tag: keyof Cases }>
@@ -593,9 +590,9 @@ export const catchTags: {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer E, infer _A> ? E
         : never
     }[keyof Cases],
-    | A
+    | R
     | {
-      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer _R, infer _E, infer A> ? A
+      [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Stream.Variance<infer R, infer _E, infer _A> ? R
         : never
     }[keyof Cases]
   >
@@ -611,12 +608,12 @@ export const catchTags: {
  */
 export const catchSomeCause: {
   <E, R2, E2, A2>(
-    pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2 | A>
+    pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A2 | A, E | E2, R2 | R>
   <R, A, E, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    pf: (cause: Cause.Cause<E>) => Option.Option<Stream<R2, E2, A2>>
-  ): Stream<R | R2, E | E2, A | A2>
+    self: Stream<A, E, R>,
+    pf: (cause: Cause.Cause<E>) => Option.Option<Stream<A2, E2, R2>>
+  ): Stream<A | A2, E | E2, R | R2>
 } = internal.catchSomeCause
 
 /**
@@ -627,7 +624,7 @@ export const catchSomeCause: {
  * @since 2.0.0
  * @category utils
  */
-export const changes: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = internal.changes
+export const changes: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R> = internal.changes
 
 /**
  * Returns a new stream that only emits elements that are not equal to the
@@ -638,8 +635,8 @@ export const changes: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = inte
  * @category utils
  */
 export const changesWith: {
-  <A>(f: (x: A, y: A) => boolean): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, f: (x: A, y: A) => boolean): Stream<R, E, A>
+  <A>(f: (x: A, y: A) => boolean): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, f: (x: A, y: A) => boolean): Stream<A, E, R>
 } = internal.changesWith
 
 /**
@@ -652,9 +649,9 @@ export const changesWith: {
  */
 export const changesWithEffect: {
   <A, R2, E2>(
-    f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (x: A, y: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>
+    f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (x: A, y: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.changesWithEffect
 
 /**
@@ -664,7 +661,7 @@ export const changesWithEffect: {
  * @since 2.0.0
  * @category utils
  */
-export const chunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>> = internal.chunks
+export const chunks: <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R> = internal.chunks
 
 /**
  * Performs the specified stream transformation with the chunk structure of
@@ -673,9 +670,15 @@ export const chunks: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chun
  * @since 2.0.0
  * @category utils
  */
-export const chunksWith: <R, E, A, R2, E2, A2>(
-  f: (stream: Stream<R, E, Chunk.Chunk<A>>) => Stream<R2, E2, Chunk.Chunk<A2>>
-) => (self: Stream<R, E, A>) => Stream<R | R2, E | E2, A2> = internal.chunksWith
+export const chunksWith: {
+  <R, E, A, R2, E2, A2>(
+    f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>
+  ): (self: Stream<A, E, R>) => Stream<A2, E | E2, R | R2>
+  <R, E, A, R2, E2, A2>(
+    self: Stream<A, E, R>,
+    f: (stream: Stream<Chunk.Chunk<A>, E, R>) => Stream<Chunk.Chunk<A2>, E2, R2>
+  ): Stream<A2, E | E2, R | R2>
+} = internal.chunksWith
 
 /**
  * Combines the elements from this stream and the specified stream by
@@ -692,24 +695,24 @@ export const chunksWith: <R, E, A, R2, E2, A2>(
  */
 export const combine: {
   <R2, E2, A2, S, R3, E, A, R4, R5, A3>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     s: S,
     f: (
       s: S,
-      pullLeft: Effect.Effect<R3, Option.Option<E>, A>,
-      pullRight: Effect.Effect<R4, Option.Option<E2>, A2>
-    ) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>
-  ): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>
+      pullLeft: Effect.Effect<A, Option.Option<E>, R3>,
+      pullRight: Effect.Effect<A2, Option.Option<E2>, R4>
+    ) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>
+  ): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>
   <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
     s: S,
     f: (
       s: S,
-      pullLeft: Effect.Effect<R3, Option.Option<E>, A>,
-      pullRight: Effect.Effect<R4, Option.Option<E2>, A2>
-    ) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [A3, S]>>
-  ): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>
+      pullLeft: Effect.Effect<A, Option.Option<E>, R3>,
+      pullRight: Effect.Effect<A2, Option.Option<E2>, R4>
+    ) => Effect.Effect<Exit.Exit<readonly [A3, S], Option.Option<E2 | E>>, never, R5>
+  ): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>
 } = internal.combine
 
 /**
@@ -724,24 +727,24 @@ export const combine: {
  */
 export const combineChunks: {
   <R2, E2, A2, S, R3, E, A, R4, R5, A3>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     s: S,
     f: (
       s: S,
-      pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>,
-      pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>
-    ) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>
-  ): <R>(self: Stream<R, E, A>) => Stream<R2 | R3 | R4 | R5 | R, E2 | E, A3>
+      pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>,
+      pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>
+    ) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>
+  ): <R>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R3 | R4 | R5 | R>
   <R, R2, E2, A2, S, R3, E, A, R4, R5, A3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
     s: S,
     f: (
       s: S,
-      pullLeft: Effect.Effect<R3, Option.Option<E>, Chunk.Chunk<A>>,
-      pullRight: Effect.Effect<R4, Option.Option<E2>, Chunk.Chunk<A2>>
-    ) => Effect.Effect<R5, never, Exit.Exit<Option.Option<E2 | E>, readonly [Chunk.Chunk<A3>, S]>>
-  ): Stream<R | R2 | R3 | R4 | R5, E2 | E, A3>
+      pullLeft: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R3>,
+      pullRight: Effect.Effect<Chunk.Chunk<A2>, Option.Option<E2>, R4>
+    ) => Effect.Effect<Exit.Exit<readonly [Chunk.Chunk<A3>, S], Option.Option<E2 | E>>, never, R5>
+  ): Stream<A3, E2 | E, R | R2 | R3 | R4 | R5>
 } = internal.combineChunks
 
 /**
@@ -753,8 +756,8 @@ export const combineChunks: {
  * @category utils
  */
 export const concat: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>
 } = internal.concat
 
 /**
@@ -763,7 +766,7 @@ export const concat: {
  * @since 2.0.0
  * @category constructors
  */
-export const concatAll: <R, E, A>(streams: Chunk.Chunk<Stream<R, E, A>>) => Stream<R, E, A> = internal.concatAll
+export const concatAll: <A, E, R>(streams: Chunk.Chunk<Stream<A, E, R>>) => Stream<A, E, R> = internal.concatAll
 
 /**
  * Composes this stream with the specified stream to create a cartesian
@@ -776,8 +779,8 @@ export const concatAll: <R, E, A>(streams: Chunk.Chunk<Stream<R, E, A>>) => Stre
  * @category utils
  */
 export const cross: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
 } = internal.cross
 
 /**
@@ -791,8 +794,8 @@ export const cross: {
  * @category utils
  */
 export const crossLeft: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.crossLeft
 
 /**
@@ -807,8 +810,8 @@ export const crossLeft: {
  * @category utils
  */
 export const crossRight: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.crossRight
 
 /**
@@ -823,14 +826,14 @@ export const crossRight: {
  */
 export const crossWith: {
   <R2, E2, B, A, C>(
-    that: Stream<R2, E2, B>,
+    that: Stream<B, E2, R2>,
     f: (a: A, b: B) => C
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, C>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E2 | E, R2 | R>
   <R, E, R2, E2, B, A, C>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, B>,
+    self: Stream<A, E, R>,
+    that: Stream<B, E2, R2>,
     f: (a: A, b: B) => C
-  ): Stream<R | R2, E | E2, C>
+  ): Stream<C, E | E2, R | R2>
 } = internal.crossWith
 
 /**
@@ -848,8 +851,8 @@ export const crossWith: {
  * @category utils
  */
 export const debounce: {
-  (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>
+  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
 } = internal.debounce
 
 /**
@@ -858,7 +861,7 @@ export const debounce: {
  * @since 2.0.0
  * @category constructors
  */
-export const die: (defect: unknown) => Stream<never, never, never> = internal.die
+export const die: (defect: unknown) => Stream<never> = internal.die
 
 /**
  * The stream that dies with the specified lazily evaluated defect.
@@ -866,7 +869,7 @@ export const die: (defect: unknown) => Stream<never, never, never> = internal.di
  * @since 2.0.0
  * @category constructors
  */
-export const dieSync: (evaluate: LazyArg<unknown>) => Stream<never, never, never> = internal.dieSync
+export const dieSync: (evaluate: LazyArg<unknown>) => Stream<never> = internal.dieSync
 
 /**
  * The stream that dies with an exception described by `message`.
@@ -874,7 +877,7 @@ export const dieSync: (evaluate: LazyArg<unknown>) => Stream<never, never, never
  * @since 2.0.0
  * @category constructors
  */
-export const dieMessage: (message: string) => Stream<never, never, never> = internal.dieMessage
+export const dieMessage: (message: string) => Stream<never> = internal.dieMessage
 
 /**
  * More powerful version of `Stream.broadcast`. Allows to provide a function
@@ -889,19 +892,19 @@ export const distributedWith: {
     options: {
       readonly size: N
       readonly maximumLag: number
-      readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>
+      readonly decide: (a: A) => Effect.Effect<Predicate<number>>
     }
   ): <R, E>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>
+    self: Stream<A, E, R>
+  ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
   <R, E, N extends number, A>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     options: {
       readonly size: N
       readonly maximumLag: number
-      readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>
+      readonly decide: (a: A) => Effect.Effect<Predicate<number>>
     }
-  ): Effect.Effect<Scope.Scope | R, never, Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>, N>>
+  ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
 } = internal.distributedWith
 
 /**
@@ -917,27 +920,21 @@ export const distributedWith: {
  */
 export const distributedWithDynamic: {
   <E, A, _>(
-    options: {
-      readonly maximumLag: number
-      readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>
-    }
+    options: { readonly maximumLag: number; readonly decide: (a: A) => Effect.Effect<Predicate<number>> }
   ): <R>(
-    self: Stream<R, E, A>
+    self: Stream<A, E, R>
   ) => Effect.Effect<
-    Scope.Scope | R,
+    Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>]>,
     never,
-    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Scope.Scope | R
   >
   <R, E, A, _>(
-    self: Stream<R, E, A>,
-    options: {
-      readonly maximumLag: number
-      readonly decide: (a: A) => Effect.Effect<never, never, Predicate<number>>
-    }
+    self: Stream<A, E, R>,
+    options: { readonly maximumLag: number; readonly decide: (a: A) => Effect.Effect<Predicate<number>> }
   ): Effect.Effect<
-    Scope.Scope | R,
+    Effect.Effect<[number, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>]>,
     never,
-    Effect.Effect<never, never, [number, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>]>
+    Scope.Scope | R
   >
 } = internal.distributedWithDynamic
 
@@ -948,7 +945,7 @@ export const distributedWithDynamic: {
  * @since 2.0.0
  * @category utils
  */
-export const drain: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, never> = internal.drain
+export const drain: <A, E, R>(self: Stream<A, E, R>) => Stream<never, E, R> = internal.drain
 
 /**
  * Drains the provided stream in the background for as long as this stream is
@@ -959,8 +956,8 @@ export const drain: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, never> = in
  * @category utils
  */
 export const drainFork: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.drainFork
 
 /**
@@ -970,8 +967,8 @@ export const drainFork: {
  * @category utils
  */
 export const drop: {
-  (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>
+  (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>
 } = internal.drop
 
 /**
@@ -983,8 +980,8 @@ export const drop: {
  * @category utils
  */
 export const dropRight: {
-  (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>
+  (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>
 } = internal.dropRight
 
 /**
@@ -995,8 +992,8 @@ export const dropRight: {
  * @category utils
  */
 export const dropUntil: {
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.dropUntil
 
 /**
@@ -1008,12 +1005,12 @@ export const dropUntil: {
  */
 export const dropUntilEffect: {
   <A, R2, E2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<A, E, R>,
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): Stream<A, E | E2, R | R2>
 } = internal.dropUntilEffect
 
 /**
@@ -1024,8 +1021,8 @@ export const dropUntilEffect: {
  * @category utils
  */
 export const dropWhile: {
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.dropWhile
 
 /**
@@ -1037,12 +1034,12 @@ export const dropWhile: {
  */
 export const dropWhileEffect: {
   <A, R2, E2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Stream<A, E | E2, R | R2>
 } = internal.dropWhileEffect
 
 /**
@@ -1055,7 +1052,7 @@ export const dropWhileEffect: {
  * @since 2.0.0
  * @category utils
  */
-export const either: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, Either.Either<E, A>> = internal.either
+export const either: <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<E, A>, never, R> = internal.either
 
 /**
  * The empty stream.
@@ -1063,7 +1060,7 @@ export const either: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, Either
  * @since 2.0.0
  * @category constructors
  */
-export const empty: Stream<never, never, never> = internal.empty
+export const empty: Stream<never> = internal.empty
 
 /**
  * Executes the provided finalizer after this stream's finalizers run.
@@ -1072,8 +1069,8 @@ export const empty: Stream<never, never, never> = internal.empty
  * @category utils
  */
 export const ensuring: {
-  <R2, _>(finalizer: Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, E, A, R2, _>(self: Stream<R, E, A>, finalizer: Effect.Effect<R2, never, _>): Stream<R | R2, E, A>
+  <R2, _>(finalizer: Effect.Effect<_, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, A, R2, _>(self: Stream<A, E, R>, finalizer: Effect.Effect<_, never, R2>): Stream<A, E, R | R2>
 } = internal.ensuring
 
 /**
@@ -1084,12 +1081,12 @@ export const ensuring: {
  */
 export const ensuringWith: {
   <E, R2>(
-    finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
+    finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   <R, E, A, R2>(
-    self: Stream<R, E, A>,
-    finalizer: (exit: Exit.Exit<E, unknown>) => Effect.Effect<R2, never, unknown>
-  ): Stream<R | R2, E, A>
+    self: Stream<A, E, R>,
+    finalizer: (exit: Exit.Exit<unknown, E>) => Effect.Effect<unknown, never, R2>
+  ): Stream<A, E, R | R2>
 } = internal.ensuringWith
 
 /**
@@ -1098,7 +1095,7 @@ export const ensuringWith: {
  * @since 2.0.0
  * @category context
  */
-export const context: <R>() => Stream<R, never, Context.Context<R>> = internal.context
+export const context: <R>() => Stream<Context.Context<R>, never, R> = internal.context
 
 /**
  * Accesses the context of the stream.
@@ -1106,7 +1103,7 @@ export const context: <R>() => Stream<R, never, Context.Context<R>> = internal.c
  * @since 2.0.0
  * @category context
  */
-export const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<R, never, A> = internal.contextWith
+export const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<A, never, R> = internal.contextWith
 
 /**
  * Accesses the context of the stream in the context of an effect.
@@ -1115,8 +1112,8 @@ export const contextWith: <R, A>(f: (env: Context.Context<R>) => A) => Stream<R,
  * @category context
  */
 export const contextWithEffect: <R0, R, E, A>(
-  f: (env: Context.Context<R0>) => Effect.Effect<R, E, A>
-) => Stream<R0 | R, E, A> = internal.contextWithEffect
+  f: (env: Context.Context<R0>) => Effect.Effect<A, E, R>
+) => Stream<A, E, R0 | R> = internal.contextWithEffect
 
 /**
  * Accesses the context of the stream in the context of a stream.
@@ -1125,8 +1122,8 @@ export const contextWithEffect: <R0, R, E, A>(
  * @category context
  */
 export const contextWithStream: <R0, R, E, A>(
-  f: (env: Context.Context<R0>) => Stream<R, E, A>
-) => Stream<R0 | R, E, A> = internal.contextWithStream
+  f: (env: Context.Context<R0>) => Stream<A, E, R>
+) => Stream<A, E, R0 | R> = internal.contextWithStream
 
 /**
  * Creates a stream that executes the specified effect but emits no elements.
@@ -1134,7 +1131,7 @@ export const contextWithStream: <R0, R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const execute: <R, E, _>(effect: Effect.Effect<R, E, _>) => Stream<R, E, never> = internal.execute
+export const execute: <R, E, _>(effect: Effect.Effect<_, E, R>) => Stream<never, E, R> = internal.execute
 
 /**
  * Terminates with the specified error.
@@ -1142,7 +1139,7 @@ export const execute: <R, E, _>(effect: Effect.Effect<R, E, _>) => Stream<R, E,
  * @since 2.0.0
  * @category constructors
  */
-export const fail: <E>(error: E) => Stream<never, E, never> = internal.fail
+export const fail: <E>(error: E) => Stream<never, E> = internal.fail
 
 /**
  * Terminates with the specified lazily evaluated error.
@@ -1150,7 +1147,7 @@ export const fail: <E>(error: E) => Stream<never, E, never> = internal.fail
  * @since 2.0.0
  * @category constructors
  */
-export const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E, never> = internal.failSync
+export const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E> = internal.failSync
 
 /**
  * The stream that always fails with the specified `Cause`.
@@ -1158,7 +1155,7 @@ export const failSync: <E>(evaluate: LazyArg<E>) => Stream<never, E, never> = in
  * @since 2.0.0
  * @category constructors
  */
-export const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E, never> = internal.failCause
+export const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E> = internal.failCause
 
 /**
  * The stream that always fails with the specified lazily evaluated `Cause`.
@@ -1166,7 +1163,7 @@ export const failCause: <E>(cause: Cause.Cause<E>) => Stream<never, E, never> =
  * @since 2.0.0
  * @category constructors
  */
-export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<never, E, never> = internal.failCauseSync
+export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<never, E> = internal.failCauseSync
 
 /**
  * Filters the elements emitted by this stream using the provided function.
@@ -1175,10 +1172,10 @@ export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<nev
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <A, B extends A>(predicate: Predicate<B>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.filter
 
 /**
@@ -1189,12 +1186,9 @@ export const filter: {
  */
 export const filterEffect: {
   <A, R2, E2>(
-    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): Stream<R | R2, E | E2, A>
+    f: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2>(self: Stream<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.filterEffect
 
 /**
@@ -1204,8 +1198,8 @@ export const filterEffect: {
  * @category utils
  */
 export const filterMap: {
-  <A, B>(pf: (a: A) => Option.Option<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <R, E, A, B>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<B>): Stream<R, E, B>
+  <A, B>(pf: (a: A) => Option.Option<B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <R, E, A, B>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<B>): Stream<B, E, R>
 } = internal.filterMap
 
 /**
@@ -1216,12 +1210,12 @@ export const filterMap: {
  */
 export const filterMapEffect: {
   <A, R2, E2, A2>(
-    pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.filterMapEffect
 
 /**
@@ -1232,8 +1226,8 @@ export const filterMapEffect: {
  * @category utils
  */
 export const filterMapWhile: {
-  <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>
-  <R, E, A, A2>(self: Stream<R, E, A>, pf: (a: A) => Option.Option<A2>): Stream<R, E, A2>
+  <A, A2>(pf: (a: A) => Option.Option<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, pf: (a: A) => Option.Option<A2>): Stream<A2, E, R>
 } = internal.filterMapWhile
 
 /**
@@ -1245,12 +1239,12 @@ export const filterMapWhile: {
  */
 export const filterMapWhileEffect: {
   <A, R2, E2, A2>(
-    pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    pf: (a: A) => Option.Option<Effect.Effect<R2, E2, A2>>
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    pf: (a: A) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.filterMapWhileEffect
 
 /**
@@ -1260,7 +1254,7 @@ export const filterMapWhileEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<R, never, void> = internal.finalizer
+export const finalizer: <R, _>(finalizer: Effect.Effect<_, never, R>) => Stream<void, never, R> = internal.finalizer
 
 /**
  * Finds the first element emitted by this stream that satisfies the provided
@@ -1270,10 +1264,10 @@ export const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<
  * @category elements
  */
 export const find: {
-  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.find
 
 /**
@@ -1285,12 +1279,12 @@ export const find: {
  */
 export const findEffect: {
   <A, R2, E2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<A, E, R>,
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): Stream<A, E | E2, R | R2>
 } = internal.findEffect
 
 /**
@@ -1302,22 +1296,22 @@ export const findEffect: {
  */
 export const flatMap: {
   <A, R2, E2, A2>(
-    f: (a: A) => Stream<R2, E2, A2>,
+    f: (a: A) => Stream<A2, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly bufferSize?: number | undefined
       readonly switch?: boolean | undefined
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    } | undefined
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    f: (a: A) => Stream<A2, E2, R2>,
     options?: {
       readonly concurrency?: number | "unbounded" | undefined
       readonly bufferSize?: number | undefined
       readonly switch?: boolean | undefined
-    }
-  ): Stream<R | R2, E | E2, A2>
+    } | undefined
+  ): Stream<A2, E | E2, R | R2>
 } = internal.flatMap
 
 /**
@@ -1329,18 +1323,16 @@ export const flatMap: {
  */
 export const flatten: {
   (
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): <R, E, R2, E2, A>(self: Stream<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A>
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+      | undefined
+  ): <R, E, R2, E2, A>(self: Stream<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>
   <R, E, R2, E2, A>(
-    self: Stream<R, E, Stream<R2, E2, A>>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<Stream<A, E2, R2>, E, R>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+      | undefined
+  ): Stream<A, E | E2, R | R2>
 } = internal.flatten
 
 /**
@@ -1350,7 +1342,7 @@ export const flatten: {
  * @since 2.0.0
  * @category sequencing
  */
-export const flattenChunks: <R, E, A>(self: Stream<R, E, Chunk.Chunk<A>>) => Stream<R, E, A> = internal.flattenChunks
+export const flattenChunks: <A, E, R>(self: Stream<Chunk.Chunk<A>, E, R>) => Stream<A, E, R> = internal.flattenChunks
 
 /**
  * Flattens `Effect` values into the stream's structure, preserving all
@@ -1361,18 +1353,16 @@ export const flattenChunks: <R, E, A>(self: Stream<R, E, Chunk.Chunk<A>>) => Str
  */
 export const flattenEffect: {
   (
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly unordered?: boolean | undefined
-    }
-  ): <R, E, R2, E2, A>(self: Stream<R, E, Effect.Effect<R2, E2, A>>) => Stream<R | R2, E | E2, A>
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+      | undefined
+  ): <R, E, R2, E2, A>(self: Stream<Effect.Effect<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>
   <R, E, R2, E2, A>(
-    self: Stream<R, E, Effect.Effect<R2, E2, A>>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly unordered?: boolean | undefined
-    }
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<Effect.Effect<A, E2, R2>, E, R>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+      | undefined
+  ): Stream<A, E | E2, R | R2>
 } = internal.flattenEffect
 
 /**
@@ -1388,8 +1378,8 @@ export const flattenEffect: {
  * @category sequencing
  */
 export const flattenExitOption: <R, E, E2, A>(
-  self: Stream<R, E, Exit.Exit<Option.Option<E2>, A>>
-) => Stream<R, E | E2, A> = internal.flattenExitOption
+  self: Stream<Exit.Exit<A, Option.Option<E2>>, E, R>
+) => Stream<A, E | E2, R> = internal.flattenExitOption
 
 /**
  * Submerges the iterables carried by this stream into the stream's structure,
@@ -1398,7 +1388,7 @@ export const flattenExitOption: <R, E, E2, A>(
  * @since 2.0.0
  * @category sequencing
  */
-export const flattenIterables: <R, E, A>(self: Stream<R, E, Iterable<A>>) => Stream<R, E, A> = internal.flattenIterables
+export const flattenIterables: <A, E, R>(self: Stream<Iterable<A>, E, R>) => Stream<A, E, R> = internal.flattenIterables
 
 /**
  * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
@@ -1407,9 +1397,8 @@ export const flattenIterables: <R, E, A>(self: Stream<R, E, Iterable<A>>) => Str
  * @since 2.0.0
  * @category sequencing
  */
-export const flattenTake: <R, E, E2, A>(
-  self: Stream<R, E, Take.Take<E2, A>>
-) => Stream<R, E | E2, A> = internal.flattenTake
+export const flattenTake: <R, E, E2, A>(self: Stream<Take.Take<A, E2>, E, R>) => Stream<A, E | E2, R> =
+  internal.flattenTake
 
 /**
  * Repeats this stream forever.
@@ -1417,7 +1406,7 @@ export const flattenTake: <R, E, E2, A>(
  * @since 2.0.0
  * @category utils
  */
-export const forever: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = internal.forever
+export const forever: <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R> = internal.forever
 
 /**
  * Creates a stream from an `AsyncIterable`.
@@ -1425,10 +1414,8 @@ export const forever: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A> = inte
  * @since 2.0.0
  * @category constructors
  */
-export const fromAsyncIterable: <E, A>(
-  iterable: AsyncIterable<A>,
-  onError: (e: unknown) => E
-) => Stream<never, E, A> = internal.fromAsyncIterable
+export const fromAsyncIterable: <A, E>(iterable: AsyncIterable<A>, onError: (e: unknown) => E) => Stream<A, E> =
+  internal.fromAsyncIterable
 
 /**
  * Creates a stream from a `Channel`.
@@ -1436,9 +1423,9 @@ export const fromAsyncIterable: <E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromChannel: <R, E, A>(
-  channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
-) => Stream<R, E, A> = internal.fromChannel
+export const fromChannel: <A, E, R>(
+  channel: Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R>
+) => Stream<A, E, R> = internal.fromChannel
 
 /**
  * Creates a channel from a `Stream`.
@@ -1446,9 +1433,9 @@ export const fromChannel: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const toChannel: <R, E, A>(
-  stream: Stream<R, E, A>
-) => Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown> = internal.toChannel
+export const toChannel: <A, E, R>(
+  stream: Stream<A, E, R>
+) => Channel.Channel<Chunk.Chunk<A>, unknown, E, unknown, unknown, unknown, R> = internal.toChannel
 
 /**
  * Creates a stream from a `Chunk` of values.
@@ -1456,7 +1443,7 @@ export const toChannel: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<never, never, A> = internal.fromChunk
+export const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<A> = internal.fromChunk
 
 /**
  * Creates a stream from a subscription to a `PubSub`.
@@ -1468,18 +1455,12 @@ export const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Stream<never, never, A> =
 export const fromChunkPubSub: {
   <A>(
     pubsub: PubSub.PubSub<Chunk.Chunk<A>>,
-    options: {
-      readonly scoped: true
-      readonly shutdown?: boolean | undefined
-    }
-  ): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>
+    options: { readonly scoped: true; readonly shutdown?: boolean | undefined }
+  ): Effect.Effect<Stream<A>, never, Scope.Scope>
   <A>(
     pubsub: PubSub.PubSub<Chunk.Chunk<A>>,
-    options?: {
-      readonly scoped?: false | undefined
-      readonly shutdown?: boolean | undefined
-    }
-  ): Stream<never, never, A>
+    options?: { readonly scoped?: false | undefined; readonly shutdown?: boolean | undefined } | undefined
+  ): Stream<A>
 } = internal.fromChunkPubSub
 
 /**
@@ -1494,7 +1475,7 @@ export const fromChunkQueue: <A>(
   options?: {
     readonly shutdown?: boolean | undefined
   }
-) => Stream<never, never, A> = internal.fromChunkQueue
+) => Stream<A> = internal.fromChunkQueue
 
 /**
  * Creates a stream from an arbitrary number of chunks.
@@ -1502,7 +1483,7 @@ export const fromChunkQueue: <A>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<never, never, A> = internal.fromChunks
+export const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<A> = internal.fromChunks
 
 /**
  * Either emits the success value of this effect or terminates the stream
@@ -1511,7 +1492,7 @@ export const fromChunks: <A>(...chunks: Array<Chunk.Chunk<A>>) => Stream<never,
  * @since 2.0.0
  * @category constructors
  */
-export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A> = internal.fromEffect
+export const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R> = internal.fromEffect
 
 /**
  * Creates a stream from an effect producing a value of type `A` or an empty
@@ -1520,7 +1501,7 @@ export const fromEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R,
  * @since 2.0.0
  * @category constructors
  */
-export const fromEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A> =
+export const fromEffectOption: <A, E, R>(effect: Effect.Effect<A, Option.Option<E>, R>) => Stream<A, E, R> =
   internal.fromEffectOption
 
 /**
@@ -1538,15 +1519,15 @@ export const fromPubSub: {
       readonly maxChunkSize?: number | undefined
       readonly shutdown?: boolean | undefined
     }
-  ): Effect.Effect<Scope.Scope, never, Stream<never, never, A>>
+  ): Effect.Effect<Stream<A>, never, Scope.Scope>
   <A>(
     pubsub: PubSub.PubSub<A>,
     options?: {
       readonly scoped?: false | undefined
       readonly maxChunkSize?: number | undefined
       readonly shutdown?: boolean | undefined
-    }
-  ): Stream<never, never, A>
+    } | undefined
+  ): Stream<A>
 } = internal.fromPubSub
 
 /**
@@ -1555,7 +1536,7 @@ export const fromPubSub: {
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterable: <A>(iterable: Iterable<A>) => Stream<never, never, A> = internal.fromIterable
+export const fromIterable: <A>(iterable: Iterable<A>) => Stream<A> = internal.fromIterable
 
 /**
  * Creates a stream from an effect producing a value of type `Iterable<A>`.
@@ -1563,7 +1544,7 @@ export const fromIterable: <A>(iterable: Iterable<A>) => Stream<never, never, A>
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterableEffect: <R, E, A>(effect: Effect.Effect<R, E, Iterable<A>>) => Stream<R, E, A> =
+export const fromIterableEffect: <A, E, R>(effect: Effect.Effect<Iterable<A>, E, R>) => Stream<A, E, R> =
   internal.fromIterableEffect
 
 /**
@@ -1572,7 +1553,7 @@ export const fromIterableEffect: <R, E, A>(effect: Effect.Effect<R, E, Iterable<
  * @since 2.0.0
  * @category constructors
  */
-export const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSize?: number) => Stream<never, never, A> =
+export const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSize?: number) => Stream<A> =
   internal.fromIteratorSucceed
 
 /**
@@ -1584,8 +1565,8 @@ export const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, maxChunkSiz
  * @category constructors
  */
 export const fromPull: <R, R2, E, A>(
-  effect: Effect.Effect<Scope.Scope | R, never, Effect.Effect<R2, Option.Option<E>, Chunk.Chunk<A>>>
-) => Stream<Exclude<R, Scope.Scope> | R2, E, A> = internal.fromPull
+  effect: Effect.Effect<Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R2>, never, Scope.Scope | R>
+) => Stream<A, E, R2 | Exclude<R, Scope.Scope>> = internal.fromPull
 
 /**
  * Creates a stream from a queue of values
@@ -1601,7 +1582,7 @@ export const fromQueue: <A>(
     readonly maxChunkSize?: number | undefined
     readonly shutdown?: boolean | undefined
   }
-) => Stream<never, never, A> = internal.fromQueue
+) => Stream<A> = internal.fromQueue
 
 /**
  * Creates a stream from a `ReadableStream`.
@@ -1614,7 +1595,7 @@ export const fromQueue: <A>(
 export const fromReadableStream: <A, E>(
   evaluate: LazyArg<ReadableStream<A>>,
   onError: (error: unknown) => E
-) => Stream<never, E, A> = internal.fromReadableStream
+) => Stream<A, E> = internal.fromReadableStream
 
 /**
  * Creates a stream from a `ReadableStreamBYOBReader`.
@@ -1629,7 +1610,7 @@ export const fromReadableStreamByob: <E>(
   evaluate: LazyArg<ReadableStream<Uint8Array>>,
   onError: (error: unknown) => E,
   allocSize?: number
-) => Stream<never, E, Uint8Array> = internal.fromReadableStreamByob
+) => Stream<Uint8Array, E> = internal.fromReadableStreamByob
 
 /**
  * Creates a stream from a `Schedule` that does not require any further
@@ -1639,7 +1620,7 @@ export const fromReadableStreamByob: <E>(
  * @since 2.0.0
  * @category constructors
  */
-export const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<R, never, A> =
+export const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) => Stream<A, never, R> =
   internal.fromSchedule
 
 /**
@@ -1650,8 +1631,8 @@ export const fromSchedule: <R, A>(schedule: Schedule.Schedule<R, unknown, A>) =>
  * @category grouping
  */
 export const groupAdjacentBy: {
-  <A, K>(f: (a: A) => K): <R, E>(self: Stream<R, E, A>) => Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>
-  <R, E, A, K>(self: Stream<R, E, A>, f: (a: A) => K): Stream<R, E, [K, Chunk.NonEmptyChunk<A>]>
+  <A, K>(f: (a: A) => K): <R, E>(self: Stream<A, E, R>) => Stream<[K, Chunk.NonEmptyChunk<A>], E, R>
+  <R, E, A, K>(self: Stream<A, E, R>, f: (a: A) => K): Stream<[K, Chunk.NonEmptyChunk<A>], E, R>
 } = internal.groupAdjacentBy
 
 /**
@@ -1662,17 +1643,13 @@ export const groupAdjacentBy: {
  */
 export const groupBy: {
   <A, R2, E2, K, V>(
-    f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
-  ): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
+    f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): <R, E>(self: Stream<A, E, R>) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
   <R, E, A, R2, E2, K, V>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<readonly [K, V], E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
   ): GroupBy.GroupBy<R | R2, E | E2, K, V>
 } = _groupBy.groupBy
 
@@ -1719,9 +1696,9 @@ export const groupByKey: {
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): <R, E>(self: Stream<R, E, A>) => GroupBy.GroupBy<R, E, K, A>
+  ): <R, E>(self: Stream<A, E, R>) => GroupBy.GroupBy<R, E, K, A>
   <R, E, A, K>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     f: (a: A) => K,
     options?: {
       readonly bufferSize?: number | undefined
@@ -1736,8 +1713,8 @@ export const groupByKey: {
  * @category utils
  */
 export const grouped: {
-  (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>
+  (chunkSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number): Stream<Chunk.Chunk<A>, E, R>
 } = internal.grouped
 
 /**
@@ -1751,8 +1728,8 @@ export const groupedWithin: {
   (
     chunkSize: number,
     duration: Duration.DurationInput
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, chunkSize: number, duration: Duration.DurationInput): Stream<R, E, Chunk.Chunk<A>>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Chunk.Chunk<A>, E, R>
 } = internal.groupedWithin
 
 /**
@@ -1766,8 +1743,8 @@ export const groupedWithin: {
  * @category utils
  */
 export const haltAfter: {
-  (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>
+  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
 } = internal.haltAfter
 
 /**
@@ -1784,8 +1761,8 @@ export const haltAfter: {
  * @category utils
  */
 export const haltWhen: {
-  <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>
+  <R2, E2, _>(effect: Effect.Effect<_, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, _>(self: Stream<A, E, R>, effect: Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.haltWhen
 
 /**
@@ -1797,8 +1774,8 @@ export const haltWhen: {
  * @category utils
  */
 export const haltWhenDeferred: {
-  <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>
-  <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>
+  <E2, _>(deferred: Deferred.Deferred<_, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
+  <R, E, A, E2, _>(self: Stream<A, E, R>, deferred: Deferred.Deferred<_, E2>): Stream<A, E | E2, R>
 } = internal.haltWhenDeferred
 
 /**
@@ -1807,7 +1784,7 @@ export const haltWhenDeferred: {
  * @since 2.0.0
  * @category utils
  */
-export const identity: <R, E, A>() => Stream<R, E, A> = internal.identityStream
+export const identity: <A, E = never, R = never>() => Stream<A, E, R> = internal.identityStream
 
 /**
  * Interleaves this stream and the specified stream deterministically by
@@ -1819,8 +1796,8 @@ export const identity: <R, E, A>() => Stream<R, E, A> = internal.identityStream
  * @category utils
  */
 export const interleave: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A | A2>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>
 } = internal.interleave
 
 /**
@@ -1837,14 +1814,14 @@ export const interleave: {
  */
 export const interleaveWith: {
   <R2, E2, A2, R3, E3>(
-    that: Stream<R2, E2, A2>,
-    decider: Stream<R3, E3, boolean>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R3 | R, E2 | E3 | E, A2 | A>
+    that: Stream<A2, E2, R2>,
+    decider: Stream<boolean, E3, R3>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E3 | E, R2 | R3 | R>
   <R, E, A, R2, E2, A2, R3, E3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
-    decider: Stream<R3, E3, boolean>
-  ): Stream<R | R2 | R3, E | E2 | E3, A | A2>
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
+    decider: Stream<boolean, E3, R3>
+  ): Stream<A | A2, E | E2 | E3, R | R2 | R3>
 } = internal.interleaveWith
 
 /**
@@ -1854,8 +1831,8 @@ export const interleaveWith: {
  * @category utils
  */
 export const intersperse: {
-  <A2>(element: A2): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>
-  <R, E, A, A2>(self: Stream<R, E, A>, element: A2): Stream<R, E, A | A2>
+  <A2>(element: A2): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, element: A2): Stream<A | A2, E, R>
 } = internal.intersperse
 
 /**
@@ -1867,11 +1844,11 @@ export const intersperse: {
 export const intersperseAffixes: {
   <A2, A3, A4>(
     options: { readonly start: A2; readonly middle: A3; readonly end: A4 }
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A3 | A4 | A>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A3 | A4 | A, E, R>
   <R, E, A, A2, A3, A4>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     options: { readonly start: A2; readonly middle: A3; readonly end: A4 }
-  ): Stream<R, E, A | A2 | A3 | A4>
+  ): Stream<A | A2 | A3 | A4, E, R>
 } = internal.intersperseAffixes
 
 /**
@@ -1882,8 +1859,8 @@ export const intersperseAffixes: {
  * @category utils
  */
 export const interruptAfter: {
-  (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>
+  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
 } = internal.interruptAfter
 
 /**
@@ -1899,8 +1876,8 @@ export const interruptAfter: {
  * @category utils
  */
 export const interruptWhen: {
-  <R2, E2, _>(effect: Effect.Effect<R2, E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, _>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>
+  <R2, E2, _>(effect: Effect.Effect<_, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, _>(self: Stream<A, E, R>, effect: Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.interruptWhen
 
 /**
@@ -1914,8 +1891,8 @@ export const interruptWhen: {
  * @category utils
  */
 export const interruptWhenDeferred: {
-  <E2, _>(deferred: Deferred.Deferred<E2, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>
-  <R, E, A, E2, _>(self: Stream<R, E, A>, deferred: Deferred.Deferred<E2, _>): Stream<R, E | E2, A>
+  <E2, _>(deferred: Deferred.Deferred<_, E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
+  <R, E, A, E2, _>(self: Stream<A, E, R>, deferred: Deferred.Deferred<_, E2>): Stream<A, E | E2, R>
 } = internal.interruptWhenDeferred
 
 /**
@@ -1925,7 +1902,7 @@ export const interruptWhenDeferred: {
  * @since 2.0.0
  * @category constructors
  */
-export const iterate: <A>(value: A, next: (value: A) => A) => Stream<never, never, A> = internal.iterate
+export const iterate: <A>(value: A, next: (value: A) => A) => Stream<A> = internal.iterate
 
 /**
  * Creates a stream from an sequence of values.
@@ -1933,7 +1910,7 @@ export const iterate: <A>(value: A, next: (value: A) => A) => Stream<never, neve
  * @since 2.0.0
  * @category constructors
  */
-export const make: <As extends Array<any>>(...as: As) => Stream<never, never, As[number]> = internal.make
+export const make: <As extends Array<any>>(...as: As) => Stream<As[number]> = internal.make
 
 /**
  * Transforms the elements of this stream using the supplied function.
@@ -1942,8 +1919,8 @@ export const make: <As extends Array<any>>(...as: As) => Stream<never, never, As
  * @category mapping
  */
 export const map: {
-  <A, B>(f: (a: A) => B): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <R, E, A, B>(self: Stream<R, E, A>, f: (a: A) => B): Stream<R, E, B>
+  <A, B>(f: (a: A) => B): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <R, E, A, B>(self: Stream<A, E, R>, f: (a: A) => B): Stream<B, E, R>
 } = internal.map
 
 /**
@@ -1953,8 +1930,8 @@ export const map: {
  * @category mapping
  */
 export const mapAccum: {
-  <S, A, A2>(s: S, f: (s: S, a: A) => readonly [S, A2]): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>
-  <R, E, S, A, A2>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<R, E, A2>
+  <S, A, A2>(s: S, f: (s: S, a: A) => readonly [S, A2]): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>
+  <R, E, S, A, A2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => readonly [S, A2]): Stream<A2, E, R>
 } = internal.mapAccum
 
 /**
@@ -1965,15 +1942,15 @@ export const mapAccum: {
  * @category mapping
  */
 export const mapAccumEffect: {
-  <S, A, R2, E2, A2>(
+  <S, A, A2, E2, R2>(
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, S, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
+    f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <R, E, A, S, A2, E2, R2>(
+    self: Stream<A, E, R>,
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, readonly [S, A2]>
-  ): Stream<R | R2, E | E2, A2>
+    f: (s: S, a: A) => Effect.Effect<readonly [S, A2], E2, R2>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.mapAccumEffect
 
 /**
@@ -1985,18 +1962,12 @@ export const mapAccumEffect: {
  */
 export const mapBoth: {
   <E, E2, A, A2>(
-    options: {
-      readonly onFailure: (e: E) => E2
-      readonly onSuccess: (a: A) => A2
-    }
-  ): <R>(self: Stream<R, E, A>) => Stream<R, E2, A2>
+    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+  ): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R>
   <R, E, E2, A, A2>(
-    self: Stream<R, E, A>,
-    options: {
-      readonly onFailure: (e: E) => E2
-      readonly onSuccess: (a: A) => A2
-    }
-  ): Stream<R, E2, A2>
+    self: Stream<A, E, R>,
+    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+  ): Stream<A2, E2, R>
 } = internal.mapBoth
 
 /**
@@ -2006,8 +1977,8 @@ export const mapBoth: {
  * @category mapping
  */
 export const mapChunks: {
-  <A, B>(f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <R, E, A, B>(self: Stream<R, E, A>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<R, E, B>
+  <A, B>(f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <R, E, A, B>(self: Stream<A, E, R>, f: (chunk: Chunk.Chunk<A>) => Chunk.Chunk<B>): Stream<B, E, R>
 } = internal.mapChunks
 
 /**
@@ -2018,12 +1989,12 @@ export const mapChunks: {
  */
 export const mapChunksEffect: {
   <A, R2, E2, B>(
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, B>
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<B, E2 | E, R2 | R>
   <R, E, A, R2, E2, B>(
-    self: Stream<R, E, A>,
-    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, Chunk.Chunk<B>>
-  ): Stream<R | R2, E | E2, B>
+    self: Stream<A, E, R>,
+    f: (chunk: Chunk.Chunk<A>) => Effect.Effect<Chunk.Chunk<B>, E2, R2>
+  ): Stream<B, E | E2, R | R2>
 } = internal.mapChunksEffect
 
 /**
@@ -2034,8 +2005,8 @@ export const mapChunksEffect: {
  * @category mapping
  */
 export const mapConcat: {
-  <A, A2>(f: (a: A) => Iterable<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>
-  <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Iterable<A2>): Stream<R, E, A2>
+  <A, A2>(f: (a: A) => Iterable<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, f: (a: A) => Iterable<A2>): Stream<A2, E, R>
 } = internal.mapConcat
 
 /**
@@ -2046,8 +2017,8 @@ export const mapConcat: {
  * @category mapping
  */
 export const mapConcatChunk: {
-  <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2>
-  <R, E, A, A2>(self: Stream<R, E, A>, f: (a: A) => Chunk.Chunk<A2>): Stream<R, E, A2>
+  <A, A2>(f: (a: A) => Chunk.Chunk<A2>): <R, E>(self: Stream<A, E, R>) => Stream<A2, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, f: (a: A) => Chunk.Chunk<A2>): Stream<A2, E, R>
 } = internal.mapConcatChunk
 
 /**
@@ -2059,12 +2030,12 @@ export const mapConcatChunk: {
  */
 export const mapConcatChunkEffect: {
   <A, R2, E2, A2>(
-    f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, Chunk.Chunk<A2>>
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<Chunk.Chunk<A2>, E2, R2>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.mapConcatChunkEffect
 
 /**
@@ -2076,12 +2047,12 @@ export const mapConcatChunkEffect: {
  */
 export const mapConcatEffect: {
   <A, R2, E2, A2>(
-    f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, Iterable<A2>>
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<Iterable<A2>, E2, R2>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.mapConcatEffect
 
 /**
@@ -2092,35 +2063,27 @@ export const mapConcatEffect: {
  */
 export const mapEffect: {
   <A, R2, E2, A2>(
-    f: (a: A) => Effect.Effect<R2, E2, A2>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly unordered?: boolean | undefined
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    f: (a: A) => Effect.Effect<A2, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+      | undefined
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <A, R2, E2, A2, K>(
-    f: (a: A) => Effect.Effect<R2, E2, A2>,
-    options: {
-      readonly key: (a: A) => K
-      readonly bufferSize?: number | undefined
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    f: (a: A) => Effect.Effect<A2, E2, R2>,
+    options: { readonly key: (a: A) => K; readonly bufferSize?: number | undefined }
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, A2>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly unordered?: boolean | undefined
-    }
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<A2, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+      | undefined
+  ): Stream<A2, E | E2, R | R2>
   <R, E, A, R2, E2, A2, K>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, A2>,
-    options: {
-      readonly key: (a: A) => K
-      readonly bufferSize?: number | undefined
-    }
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<A2, E2, R2>,
+    options: { readonly key: (a: A) => K; readonly bufferSize?: number | undefined }
+  ): Stream<A2, E | E2, R | R2>
 } = _groupBy.mapEffectOptions
 
 /**
@@ -2130,8 +2093,8 @@ export const mapEffect: {
  * @category mapping
  */
 export const mapError: {
-  <E, E2>(f: (error: E) => E2): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>
-  <R, A, E, E2>(self: Stream<R, E, A>, f: (error: E) => E2): Stream<R, E2, A>
+  <E, E2>(f: (error: E) => E2): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <R, A, E, E2>(self: Stream<A, E, R>, f: (error: E) => E2): Stream<A, E2, R>
 } = internal.mapError
 
 /**
@@ -2141,8 +2104,8 @@ export const mapError: {
  * @category mapping
  */
 export const mapErrorCause: {
-  <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>
-  <R, A, E, E2>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<R, E2, A>
+  <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <R, A, E, E2>(self: Stream<A, E, R>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Stream<A, E2, R>
 } = internal.mapErrorCause
 
 /**
@@ -2156,18 +2119,14 @@ export const mapErrorCause: {
  */
 export const merge: {
   <R2, E2, A2>(
-    that: Stream<R2, E2, A2>,
-    options?: {
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
-    }
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>
+    that: Stream<A2, E2, R2>,
+    options?: { readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined } | undefined
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
-    options?: {
-      readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
-    }
-  ): Stream<R | R2, E | E2, A | A2>
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
+    options?: { readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined } | undefined
+  ): Stream<A | A2, E | E2, R | R2>
 } = internal.merge
 
 /**
@@ -2184,14 +2143,14 @@ export const mergeAll: {
       readonly concurrency: number | "unbounded"
       readonly bufferSize?: number | undefined
     }
-  ): <R, E, A>(streams: Iterable<Stream<R, E, A>>) => Stream<R, E, A>
-  <R, E, A>(
-    streams: Iterable<Stream<R, E, A>>,
+  ): <A, E, R>(streams: Iterable<Stream<A, E, R>>) => Stream<A, E, R>
+  <A, E, R>(
+    streams: Iterable<Stream<A, E, R>>,
     options: {
       readonly concurrency: number | "unbounded"
       readonly bufferSize?: number | undefined
     }
-  ): Stream<R, E, A>
+  ): Stream<A, E, R>
 } = internal.mergeAll
 
 /**
@@ -2206,22 +2165,22 @@ export const mergeAll: {
  */
 export const mergeWith: {
   <R2, E2, A2, A, A3, A4>(
-    other: Stream<R2, E2, A2>,
+    other: Stream<A2, E2, R2>,
     options: {
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A4
       readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3 | A4>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A3 | A4, E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, A3, A4>(
-    self: Stream<R, E, A>,
-    other: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    other: Stream<A2, E2, R2>,
     options: {
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A4
       readonly haltStrategy?: HaltStrategy.HaltStrategyInput | undefined
     }
-  ): Stream<R | R2, E | E2, A3 | A4>
+  ): Stream<A3 | A4, E | E2, R | R2>
 } = internal.mergeWith
 
 /**
@@ -2233,9 +2192,9 @@ export const mergeWith: {
  */
 export const mergeEither: {
   <R2, E2, A2>(
-    that: Stream<R2, E2, A2>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Either.Either<A, A2>>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, Either.Either<A, A2>>
+    that: Stream<A2, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, A2>, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<Either.Either<A, A2>, E | E2, R | R2>
 } = internal.mergeEither
 
 /**
@@ -2246,8 +2205,8 @@ export const mergeEither: {
  * @category utils
  */
 export const mergeLeft: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.mergeLeft
 
 /**
@@ -2258,8 +2217,8 @@ export const mergeLeft: {
  * @category utils
  */
 export const mergeRight: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.mergeRight
 
 /**
@@ -2269,7 +2228,7 @@ export const mergeRight: {
  * @since 2.0.0
  * @category utils
  */
-export const mkString: <R, E>(self: Stream<R, E, string>) => Effect.Effect<R, E, string> = internal.mkString
+export const mkString: <R, E>(self: Stream<string, E, R>) => Effect.Effect<string, E, R> = internal.mkString
 
 /**
  * The stream that never produces any value or fails with any error.
@@ -2277,7 +2236,7 @@ export const mkString: <R, E>(self: Stream<R, E, string>) => Effect.Effect<R, E,
  * @since 2.0.0
  * @category constructors
  */
-export const never: Stream<never, never, never> = internal.never
+export const never: Stream<never> = internal.never
 
 /**
  * Runs the specified effect if this stream fails, providing the error to the
@@ -2291,12 +2250,12 @@ export const never: Stream<never, never, never> = internal.never
  */
 export const onError: {
   <E, R2, _>(
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
+    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<_, never, R2>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
   <R, A, E, R2, _>(
-    self: Stream<R, E, A>,
-    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<R2, never, _>
-  ): Stream<R | R2, E, A>
+    self: Stream<A, E, R>,
+    cleanup: (cause: Cause.Cause<E>) => Effect.Effect<_, never, R2>
+  ): Stream<A, E, R | R2>
 } = internal.onError
 
 /**
@@ -2306,8 +2265,8 @@ export const onError: {
  * @category utils
  */
 export const onDone: {
-  <R2, _>(cleanup: () => Effect.Effect<R2, never, _>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, E, A, R2, _>(self: Stream<R, E, A>, cleanup: () => Effect.Effect<R2, never, _>): Stream<R | R2, E, A>
+  <R2, _>(cleanup: () => Effect.Effect<_, never, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, A, R2, _>(self: Stream<A, E, R>, cleanup: () => Effect.Effect<_, never, R2>): Stream<A, E, R | R2>
 } = internal.onDone
 
 /**
@@ -2317,7 +2276,7 @@ export const onDone: {
  * @since 2.0.0
  * @category error handling
  */
-export const orDie: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A> = internal.orDie
+export const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R> = internal.orDie
 
 /**
  * Keeps none of the errors, and terminates the stream with them, using the
@@ -2327,8 +2286,8 @@ export const orDie: <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A> = in
  * @category error handling
  */
 export const orDieWith: {
-  <E>(f: (e: E) => unknown): <R, A>(self: Stream<R, E, A>) => Stream<R, never, A>
-  <R, A, E>(self: Stream<R, E, A>, f: (e: E) => unknown): Stream<R, never, A>
+  <E>(f: (e: E) => unknown): <R, A>(self: Stream<A, E, R>) => Stream<A, never, R>
+  <R, A, E>(self: Stream<A, E, R>, f: (e: E) => unknown): Stream<A, never, R>
 } = internal.orDieWith
 
 /**
@@ -2340,8 +2299,8 @@ export const orDieWith: {
  * @category error handling
  */
 export const orElse: {
-  <R2, E2, A2>(that: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2 | A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E2, A | A2>
+  <R2, E2, A2>(that: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E2, R | R2>
 } = internal.orElse
 
 /**
@@ -2354,12 +2313,12 @@ export const orElse: {
  */
 export const orElseEither: {
   <R2, E2, A2>(
-    that: LazyArg<Stream<R2, E2, A2>>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2, Either.Either<A, A2>>
+    that: LazyArg<Stream<A2, E2, R2>>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<A, A2>, E2, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    that: LazyArg<Stream<R2, E2, A2>>
-  ): Stream<R | R2, E2, Either.Either<A, A2>>
+    self: Stream<A, E, R>,
+    that: LazyArg<Stream<A2, E2, R2>>
+  ): Stream<Either.Either<A, A2>, E2, R | R2>
 } = internal.orElseEither
 
 /**
@@ -2371,8 +2330,8 @@ export const orElseEither: {
  * @category error handling
  */
 export const orElseFail: {
-  <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2, A>
-  <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>): Stream<R, E2, A>
+  <E2>(error: LazyArg<E2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <R, E, A, E2>(self: Stream<A, E, R>, error: LazyArg<E2>): Stream<A, E2, R>
 } = internal.orElseFail
 
 /**
@@ -2382,8 +2341,8 @@ export const orElseFail: {
  * @category error handling
  */
 export const orElseIfEmpty: {
-  <A2>(element: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>
-  <R, E, A, A2>(self: Stream<R, E, A>, element: LazyArg<A2>): Stream<R, E, A | A2>
+  <A2>(element: LazyArg<A2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, element: LazyArg<A2>): Stream<A | A2, E, R>
 } = internal.orElseIfEmpty
 
 /**
@@ -2393,8 +2352,8 @@ export const orElseIfEmpty: {
  * @category error handling
  */
 export const orElseIfEmptyChunk: {
-  <A2>(chunk: LazyArg<Chunk.Chunk<A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>
-  <R, E, A, A2>(self: Stream<R, E, A>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<R, E, A | A2>
+  <A2>(chunk: LazyArg<Chunk.Chunk<A2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, chunk: LazyArg<Chunk.Chunk<A2>>): Stream<A | A2, E, R>
 } = internal.orElseIfEmptyChunk
 
 /**
@@ -2404,8 +2363,8 @@ export const orElseIfEmptyChunk: {
  * @category error handling
  */
 export const orElseIfEmptyStream: {
-  <R2, E2, A2>(stream: LazyArg<Stream<R2, E2, A2>>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, stream: LazyArg<Stream<R2, E2, A2>>): Stream<R | R2, E | E2, A | A2>
+  <R2, E2, A2>(stream: LazyArg<Stream<A2, E2, R2>>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, stream: LazyArg<Stream<A2, E2, R2>>): Stream<A | A2, E | E2, R | R2>
 } = internal.orElseIfEmptyStream
 
 /**
@@ -2415,8 +2374,8 @@ export const orElseIfEmptyStream: {
  * @category error handling
  */
 export const orElseSucceed: {
-  <A2>(value: LazyArg<A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, never, A2 | A>
-  <R, E, A, A2>(self: Stream<R, E, A>, value: LazyArg<A2>): Stream<R, never, A | A2>
+  <A2>(value: LazyArg<A2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, never, R>
+  <R, E, A, A2>(self: Stream<A, E, R>, value: LazyArg<A2>): Stream<A | A2, never, R>
 } = internal.orElseSucceed
 
 /**
@@ -2427,8 +2386,7 @@ export const orElseSucceed: {
  * @since 2.0.0
  * @category constructors
  */
-export const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>]) => Stream<never, never, A> =
-  internal.paginate
+export const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>]) => Stream<A> = internal.paginate
 
 /**
  * Like `Stream.unfoldChunk`, but allows the emission of values to end one step
@@ -2441,7 +2399,7 @@ export const paginate: <S, A>(s: S, f: (s: S) => readonly [A, Option.Option<S>])
 export const paginateChunk: <S, A>(
   s: S,
   f: (s: S) => readonly [Chunk.Chunk<A>, Option.Option<S>]
-) => Stream<never, never, A> = internal.paginateChunk
+) => Stream<A> = internal.paginateChunk
 
 /**
  * Like `Stream.unfoldChunkEffect`, but allows the emission of values to end one step
@@ -2453,8 +2411,8 @@ export const paginateChunk: <S, A>(
  */
 export const paginateChunkEffect: <S, R, E, A>(
   s: S,
-  f: (s: S) => Effect.Effect<R, E, readonly [Chunk.Chunk<A>, Option.Option<S>]>
-) => Stream<R, E, A> = internal.paginateChunkEffect
+  f: (s: S) => Effect.Effect<readonly [Chunk.Chunk<A>, Option.Option<S>], E, R>
+) => Stream<A, E, R> = internal.paginateChunkEffect
 
 /**
  * Like `Stream.unfoldEffect` but allows the emission of values to end one step
@@ -2466,8 +2424,8 @@ export const paginateChunkEffect: <S, R, E, A>(
  */
 export const paginateEffect: <S, R, E, A>(
   s: S,
-  f: (s: S) => Effect.Effect<R, E, readonly [A, Option.Option<S>]>
-) => Stream<R, E, A> = internal.paginateEffect
+  f: (s: S) => Effect.Effect<readonly [A, Option.Option<S>], E, R>
+) => Stream<A, E, R> = internal.paginateEffect
 
 /**
  * Partition a stream using a predicate. The first stream will contain all
@@ -2481,34 +2439,26 @@ export const paginateEffect: <S, R, E, A>(
 export const partition: {
   <C extends A, B extends A, A = C>(
     refinement: Refinement<NoInfer<A>, B>,
-    options?: {
-      bufferSize?: number | undefined
-    }
+    options?: { bufferSize?: number | undefined } | undefined
   ): <R, E>(
-    self: Stream<R, E, C>
-  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<C, B>>, satisfying: Stream<never, E, B>]>
+    self: Stream<C, E, R>
+  ) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>
   <A>(
     predicate: Predicate<A>,
-    options?: {
-      bufferSize?: number | undefined
-    }
-  ): <R, E, B extends A>(
-    self: Stream<R, E, B>
-  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, B>, satisfying: Stream<never, E, B>]>
-  <R, E, A, B extends A>(
-    self: Stream<R, E, A>,
+    options?: { bufferSize?: number | undefined } | undefined
+  ): <R, E>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<[excluded: Stream<A, E>, satisfying: Stream<A, E>], E, Scope.Scope | R>
+  <R, E, C extends A, B extends A, A = C>(
+    self: Stream<C, E, R>,
     refinement: Refinement<A, B>,
-    options?: {
-      bufferSize?: number | undefined
-    }
-  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<A, B>>, satisfying: Stream<never, E, B>]>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+    options?: { bufferSize?: number | undefined } | undefined
+  ): Effect.Effect<[excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>], E, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     predicate: Predicate<A>,
-    options?: {
-      bufferSize?: number | undefined
-    }
-  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, A>, satisfying: Stream<never, E, A>]>
+    options?: { bufferSize?: number | undefined } | undefined
+  ): Effect.Effect<[excluded: Stream<A, E>, satisfying: Stream<A, E>], E, Scope.Scope | R>
 } = internal.partition
 
 /**
@@ -2520,20 +2470,16 @@ export const partition: {
  */
 export const partitionEither: {
   <A, R2, E2, A2, A3>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
+    predicate: (a: NoInfer<A>) => Effect.Effect<Either.Either<A2, A3>, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
   ): <R, E>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [left: Stream<never, E2 | E, A2>, right: Stream<never, E2 | E, A3>]>
+    self: Stream<A, E, R>
+  ) => Effect.Effect<[left: Stream<A2, E2 | E>, right: Stream<A3, E2 | E>], E2 | E, Scope.Scope | R2 | R>
   <R, E, A, R2, E2, A2, A3>(
-    self: Stream<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, [left: Stream<never, E | E2, A2>, right: Stream<never, E | E2, A3>]>
+    self: Stream<A, E, R>,
+    predicate: (a: A) => Effect.Effect<Either.Either<A2, A3>, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): Effect.Effect<[left: Stream<A2, E | E2>, right: Stream<A3, E | E2>], E | E2, Scope.Scope | R | R2>
 } = internal.partitionEither
 
 /**
@@ -2546,13 +2492,13 @@ export const partitionEither: {
  * @category utils
  */
 export const peel: {
-  <R2, E2, A, Z>(
-    sink: Sink.Sink<R2, E2, A, A, Z>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [Z, Stream<never, E, A>]>
-  <R, E, R2, E2, A, Z>(
-    self: Stream<R, E, A>,
-    sink: Sink.Sink<R2, E2, A, A, Z>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, [Z, Stream<never, E, A>]>
+  <A2, A, E2, R2>(
+    sink: Sink.Sink<A2, A, A, E2, R2>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[A2, Stream<A, E, never>], E2 | E, Scope.Scope | R2 | R>
+  <A, E, R, A2, E2, R2>(
+    self: Stream<A, E, R>,
+    sink: Sink.Sink<A2, A, A, E2, R2>
+  ): Effect.Effect<[A2, Stream<A, E, never>], E | E2, Scope.Scope | R | R2>
 } = internal.peel
 
 /**
@@ -2564,8 +2510,8 @@ export const peel: {
  * @category utils
  */
 export const pipeThrough: {
-  <R2, E2, A, L, Z>(sink: Sink.Sink<R2, E2, A, L, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, L>
-  <R, E, R2, E2, A, L, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, L, Z>): Stream<R | R2, E | E2, L>
+  <A2, A, L, E2, R2>(sink: Sink.Sink<A2, A, L, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<L, E2 | E, R2 | R>
+  <A, E, R, A2, L, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, L, E2, R2>): Stream<L, E | E2, R | R2>
 } = internal.pipeThrough
 
 /**
@@ -2576,12 +2522,12 @@ export const pipeThrough: {
  */
 export const pipeThroughChannel: {
   <R2, E, E2, A, A2>(
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
-  ): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E2, A2>
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
+  ): <R>(self: Stream<A, E, R>) => Stream<A2, E2, R2 | R>
   <R, R2, E, E2, A, A2>(
-    self: Stream<R, E, A>,
-    channel: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
-  ): Stream<R | R2, E2, A2>
+    self: Stream<A, E, R>,
+    channel: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
+  ): Stream<A2, E2, R | R2>
 } = internal.pipeThroughChannel
 
 /**
@@ -2593,12 +2539,12 @@ export const pipeThroughChannel: {
  */
 export const pipeThroughChannelOrFail: {
   <R2, E, E2, A, A2>(
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
-  ): <R>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A2>
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
+  ): <R>(self: Stream<A, E, R>) => Stream<A2, E | E2, R2 | R>
   <R, R2, E, E2, A, A2>(
-    self: Stream<R, E, A>,
-    chan: Channel.Channel<R2, E, Chunk.Chunk<A>, unknown, E2, Chunk.Chunk<A2>, unknown>
-  ): Stream<R | R2, E | E2, A2>
+    self: Stream<A, E, R>,
+    chan: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E2, E, unknown, unknown, R2>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.pipeThroughChannelOrFail
 
 /**
@@ -2608,8 +2554,8 @@ export const pipeThroughChannelOrFail: {
  * @category utils
  */
 export const prepend: {
-  <B>(values: Chunk.Chunk<B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, B | A>
-  <R, E, A, B>(self: Stream<R, E, A>, values: Chunk.Chunk<B>): Stream<R, E, A | B>
+  <B>(values: Chunk.Chunk<B>): <A, E, R>(self: Stream<A, E, R>) => Stream<B | A, E, R>
+  <R, E, A, B>(self: Stream<A, E, R>, values: Chunk.Chunk<B>): Stream<A | B, E, R>
 } = internal.prepend
 
 /**
@@ -2620,8 +2566,8 @@ export const prepend: {
  * @category context
  */
 export const provideContext: {
-  <R>(context: Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<never, E, A>
-  <E, A, R>(self: Stream<R, E, A>, context: Context.Context<R>): Stream<never, E, A>
+  <R>(context: Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E>
+  <A, E, R>(self: Stream<A, E, R>, context: Context.Context<R>): Stream<A, E>
 } = internal.provideContext
 
 /**
@@ -2631,8 +2577,8 @@ export const provideContext: {
  * @category context
  */
 export const provideLayer: {
-  <RIn, E2, ROut>(layer: Layer.Layer<RIn, E2, ROut>): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E2 | E, A>
-  <E, A, RIn, E2, ROut>(self: Stream<ROut, E, A>, layer: Layer.Layer<RIn, E2, ROut>): Stream<RIn, E | E2, A>
+  <RIn, E2, ROut>(layer: Layer.Layer<ROut, E2, RIn>): <A, E>(self: Stream<A, E, ROut>) => Stream<A, E2 | E, RIn>
+  <A, E, RIn, E2, ROut>(self: Stream<A, E, ROut>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn>
 } = internal.provideLayer
 
 /**
@@ -2646,12 +2592,12 @@ export const provideService: {
   <T extends Context.Tag<any, any>>(
     tag: T,
     resource: Context.Tag.Service<T>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>
   <R, E, A, T extends Context.Tag<any, any>>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     tag: T,
     resource: Context.Tag.Service<T>
-  ): Stream<Exclude<R, Context.Tag.Identifier<T>>, E, A>
+  ): Stream<A, E, Exclude<R, Context.Tag.Identifier<T>>>
 } = internal.provideService
 
 /**
@@ -2664,13 +2610,13 @@ export const provideService: {
 export const provideServiceEffect: {
   <T extends Context.Tag<any, any>, R2, E2>(
     tag: T,
-    effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>
+    effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>
   <R, E, A, T extends Context.Tag<any, any>, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     tag: T,
-    effect: Effect.Effect<R2, E2, Context.Tag.Service<T>>
-  ): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>
+    effect: Effect.Effect<Context.Tag.Service<T>, E2, R2>
+  ): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>
 } = internal.provideServiceEffect
 
 /**
@@ -2683,13 +2629,13 @@ export const provideServiceEffect: {
 export const provideServiceStream: {
   <T extends Context.Tag<any, any>, R2, E2>(
     tag: T,
-    stream: Stream<R2, E2, Context.Tag.Service<T>>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E2 | E, A>
+    stream: Stream<Context.Tag.Service<T>, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | Exclude<R, Context.Tag.Identifier<T>>>
   <R, E, A, T extends Context.Tag<any, any>, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     tag: T,
-    stream: Stream<R2, E2, Context.Tag.Service<T>>
-  ): Stream<R2 | Exclude<R, Context.Tag.Identifier<T>>, E | E2, A>
+    stream: Stream<Context.Tag.Service<T>, E2, R2>
+  ): Stream<A, E | E2, R2 | Exclude<R, Context.Tag.Identifier<T>>>
 } = internal.provideServiceStream
 
 /**
@@ -2700,8 +2646,8 @@ export const provideServiceStream: {
  * @category context
  */
 export const mapInputContext: {
-  <R0, R>(f: (env: Context.Context<R0>) => Context.Context<R>): <E, A>(self: Stream<R, E, A>) => Stream<R0, E, A>
-  <E, A, R0, R>(self: Stream<R, E, A>, f: (env: Context.Context<R0>) => Context.Context<R>): Stream<R0, E, A>
+  <R0, R>(f: (env: Context.Context<R0>) => Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R0>
+  <A, E, R0, R>(self: Stream<A, E, R>, f: (env: Context.Context<R0>) => Context.Context<R>): Stream<A, E, R0>
 } = internal.mapInputContext
 
 /**
@@ -2713,12 +2659,12 @@ export const mapInputContext: {
  */
 export const provideSomeLayer: {
   <RIn, E2, ROut>(
-    layer: Layer.Layer<RIn, E2, ROut>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E2 | E, A>
+    layer: Layer.Layer<ROut, E2, RIn>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, RIn | Exclude<R, ROut>>
   <R, E, A, RIn, E2, ROut>(
-    self: Stream<R, E, A>,
-    layer: Layer.Layer<RIn, E2, ROut>
-  ): Stream<RIn | Exclude<R, ROut>, E | E2, A>
+    self: Stream<A, E, R>,
+    layer: Layer.Layer<ROut, E2, RIn>
+  ): Stream<A, E | E2, RIn | Exclude<R, ROut>>
 } = internal.provideSomeLayer
 
 /**
@@ -2727,7 +2673,7 @@ export const provideSomeLayer: {
  * @since 2.0.0
  * @category constructors
  */
-export const range: (min: number, max: number, chunkSize?: number) => Stream<never, never, number> = internal.range
+export const range: (min: number, max: number, chunkSize?: number) => Stream<number> = internal.range
 
 /**
  * Re-chunks the elements of the stream into chunks of `n` elements each. The
@@ -2737,8 +2683,8 @@ export const range: (min: number, max: number, chunkSize?: number) => Stream<nev
  * @category utils
  */
 export const rechunk: {
-  (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>
+  (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>
 } = internal.rechunk
 
 /**
@@ -2748,8 +2694,8 @@ export const rechunk: {
  * @category error handling
  */
 export const refineOrDie: {
-  <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>
-  <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>): Stream<R, E2, A>
+  <E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <R, A, E, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>): Stream<A, E2, R>
 } = internal.refineOrDie
 
 /**
@@ -2763,8 +2709,8 @@ export const refineOrDieWith: {
   <E, E2>(
     pf: (error: E) => Option.Option<E2>,
     f: (error: E) => unknown
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R, E2, A>
-  <R, A, E, E2>(self: Stream<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<R, E2, A>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E2, R>
+  <R, A, E, E2>(self: Stream<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Stream<A, E2, R>
 } = internal.refineOrDieWith
 
 /**
@@ -2775,8 +2721,8 @@ export const refineOrDieWith: {
  * @category utils
  */
 export const repeat: {
-  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>
+  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>
 } = internal.repeat
 
 /**
@@ -2786,7 +2732,7 @@ export const repeat: {
  * @since 2.0.0
  * @category constructors
  */
-export const repeatEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R, E, A> = internal.repeatEffect
+export const repeatEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R> = internal.repeatEffect
 
 /**
  * Creates a stream from an effect producing chunks of `A` values which
@@ -2795,7 +2741,7 @@ export const repeatEffect: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<R
  * @since 2.0.0
  * @category constructors
  */
-export const repeatEffectChunk: <R, E, A>(effect: Effect.Effect<R, E, Chunk.Chunk<A>>) => Stream<R, E, A> =
+export const repeatEffectChunk: <A, E, R>(effect: Effect.Effect<Chunk.Chunk<A>, E, R>) => Stream<A, E, R> =
   internal.repeatEffectChunk
 
 /**
@@ -2805,9 +2751,9 @@ export const repeatEffectChunk: <R, E, A>(effect: Effect.Effect<R, E, Chunk.Chun
  * @since 2.0.0
  * @category constructors
  */
-export const repeatEffectChunkOption: <R, E, A>(
-  effect: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>
-) => Stream<R, E, A> = internal.repeatEffectChunkOption
+export const repeatEffectChunkOption: <A, E, R>(
+  effect: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>
+) => Stream<A, E, R> = internal.repeatEffectChunkOption
 
 /**
  * Creates a stream from an effect producing values of type `A` until it fails
@@ -2816,7 +2762,7 @@ export const repeatEffectChunkOption: <R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const repeatEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Option<E>, A>) => Stream<R, E, A> =
+export const repeatEffectOption: <A, E, R>(effect: Effect.Effect<A, Option.Option<E>, R>) => Stream<A, E, R> =
   internal.repeatEffectOption
 
 /**
@@ -2827,9 +2773,9 @@ export const repeatEffectOption: <R, E, A>(effect: Effect.Effect<R, Option.Optio
  * @category constructors
  */
 export const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(
-  effect: Effect.Effect<R, E, A>,
+  effect: Effect.Effect<A, E, R>,
   schedule: Schedule.Schedule<R2, A0, _>
-) => Stream<R | R2, E, A> = internal.repeatEffectWithSchedule
+) => Stream<A, E, R | R2> = internal.repeatEffectWithSchedule
 
 /**
  * Repeats the entire stream using the specified schedule. The stream will
@@ -2842,11 +2788,11 @@ export const repeatEffectWithSchedule: <R, E, A, A0 extends A, R2, _>(
 export const repeatEither: {
   <R2, B>(
     schedule: Schedule.Schedule<R2, unknown, B>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, Either.Either<B, A>>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<Either.Either<B, A>, E, R2 | R>
   <R, E, A, R2, B>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, B>
-  ): Stream<R | R2, E, Either.Either<B, A>>
+  ): Stream<Either.Either<B, A>, E, R | R2>
 } = internal.repeatEither
 
 /**
@@ -2860,8 +2806,8 @@ export const repeatEither: {
  * @category utils
  */
 export const repeatElements: {
-  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, E, A, R2, B>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<R | R2, E, A>
+  <R2, B>(schedule: Schedule.Schedule<R2, unknown, B>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, A, R2, B>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, unknown, B>): Stream<A, E, R | R2>
 } = internal.repeatElements
 
 /**
@@ -2882,19 +2828,13 @@ export const repeatElements: {
 export const repeatElementsWith: {
   <R2, B, A, C>(
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
   <R, E, R2, B, A, C>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): Stream<R | R2, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): Stream<C, E, R | R2>
 } = internal.repeatElementsWith
 
 /**
@@ -2903,7 +2843,7 @@ export const repeatElementsWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const repeatValue: <A>(value: A) => Stream<never, never, A> = internal.repeatValue
+export const repeatValue: <A>(value: A) => Stream<A> = internal.repeatValue
 
 /**
  * Repeats the entire stream using the specified schedule. The stream will
@@ -2917,19 +2857,13 @@ export const repeatValue: <A>(value: A) => Stream<never, never, A> = internal.re
 export const repeatWith: {
   <R2, B, A, C>(
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
   <R, E, R2, B, A, C>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): Stream<R | R2, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): Stream<C, E, R | R2>
 } = internal.repeatWith
 
 /**
@@ -2948,8 +2882,8 @@ export const repeatWith: {
 export const retry: {
   <R2, E, E0 extends E, _>(
     schedule: Schedule.Schedule<R2, E0, _>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, A, R2, E, E0 extends E, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, E0, _>): Stream<R | R2, E, A>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, A, R2, E, E0 extends E, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, E0, _>): Stream<A, E, R | R2>
 } = internal.retry
 
 /**
@@ -2959,10 +2893,13 @@ export const retry: {
  * @category destructors
  */
 export const run: {
-  <R2, E2, A, Z>(
-    sink: Sink.Sink<R2, E2, A, unknown, Z>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, Z>
-  <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, Z>): Effect.Effect<R | R2, E | E2, Z>
+  <A2, A, E2, R2>(
+    sink: Sink.Sink<A2, A, unknown, E2, R2>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, R2 | R>
+  <A, E, R, A2, E2, R2>(
+    self: Stream<A, E, R>,
+    sink: Sink.Sink<A2, A, unknown, E2, R2>
+  ): Effect.Effect<A2, E | E2, R | R2>
 } = internal.run
 
 /**
@@ -2971,7 +2908,7 @@ export const run: {
  * @since 2.0.0
  * @category destructors
  */
-export const runCollect: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>> = internal.runCollect
+export const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R> = internal.runCollect
 
 /**
  * Runs the stream and emits the number of elements processed
@@ -2979,7 +2916,7 @@ export const runCollect: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E,
  * @since 2.0.0
  * @category destructors
  */
-export const runCount: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, number> = internal.runCount
+export const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R> = internal.runCount
 
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
@@ -2987,7 +2924,7 @@ export const runCount: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, n
  * @since 2.0.0
  * @category destructors
  */
-export const runDrain: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, void> = internal.runDrain
+export const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R> = internal.runDrain
 
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
@@ -2997,8 +2934,8 @@ export const runDrain: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, v
  * @category destructors
  */
 export const runFold: {
-  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R, E, S>
-  <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<R, E, S>
+  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
+  <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
 } = internal.runFold
 
 /**
@@ -3010,13 +2947,13 @@ export const runFold: {
 export const runFoldEffect: {
   <S, A, R2, E2>(
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>
   <R, E, S, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): Effect.Effect<R | R2, E | E2, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): Effect.Effect<S, E | E2, R | R2>
 } = internal.runFoldEffect
 
 /**
@@ -3027,8 +2964,8 @@ export const runFoldEffect: {
  * @category destructors
  */
 export const runFoldScoped: {
-  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, E, S>
-  <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Effect.Effect<Scope.Scope | R, E, S>
+  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>
+  <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Scope.Scope | R>
 } = internal.runFoldScoped
 
 /**
@@ -3041,13 +2978,13 @@ export const runFoldScoped: {
 export const runFoldScopedEffect: {
   <S, A, R2, E2>(
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>
   <R, E, S, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): Effect.Effect<S, E | E2, Scope.Scope | R | R2>
 } = internal.runFoldScopedEffect
 
 /**
@@ -3058,8 +2995,8 @@ export const runFoldScopedEffect: {
  * @category destructors
  */
 export const runFoldWhile: {
-  <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R, E, S>
-  <R, E, S, A>(self: Stream<R, E, A>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<R, E, S>
+  <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>
+  <R, E, S, A>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>
 } = internal.runFoldWhile
 
 /**
@@ -3073,14 +3010,14 @@ export const runFoldWhileEffect: {
   <S, A, R2, E2>(
     s: S,
     cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>
   <R, E, S, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
     cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): Effect.Effect<R | R2, E | E2, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): Effect.Effect<S, E | E2, R | R2>
 } = internal.runFoldWhileEffect
 
 /**
@@ -3096,13 +3033,13 @@ export const runFoldWhileScoped: {
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => S
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R | Scope.Scope, E, S>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E, Scope.Scope | R>
   <R, E, S, A>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => S
-  ): Effect.Effect<Scope.Scope | R, E, S>
+  ): Effect.Effect<S, E, Scope.Scope | R>
 } = internal.runFoldWhileScoped
 
 /**
@@ -3117,14 +3054,14 @@ export const runFoldWhileScopedEffect: {
   <S, A, R2, E2>(
     s: S,
     cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Scope.Scope | R2 | R>
   <R, E, S, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
     cont: Predicate<S>,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): Effect.Effect<S, E | E2, Scope.Scope | R | R2>
 } = internal.runFoldWhileScopedEffect
 
 /**
@@ -3136,12 +3073,12 @@ export const runFoldWhileScopedEffect: {
  */
 export const runForEach: {
   <A, R2, E2, _>(
-    f: (a: A) => Effect.Effect<R2, E2, _>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>
+    f: (a: A) => Effect.Effect<_, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   <R, E, A, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, _>
-  ): Effect.Effect<R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<_, E2, R2>
+  ): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEach
 
 /**
@@ -3153,12 +3090,12 @@ export const runForEach: {
  */
 export const runForEachChunk: {
   <A, R2, E2, _>(
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>
+    f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   <R, E, A, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>
-  ): Effect.Effect<R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>
+  ): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEachChunk
 
 /**
@@ -3170,12 +3107,12 @@ export const runForEachChunk: {
  */
 export const runForEachChunkScoped: {
   <A, R2, E2, _>(
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>
+    f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   <R, E, A, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (a: Chunk.Chunk<A>) => Effect.Effect<R2, E2, _>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: Chunk.Chunk<A>) => Effect.Effect<_, E2, R2>
+  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachChunkScoped
 
 /**
@@ -3187,12 +3124,12 @@ export const runForEachChunkScoped: {
  */
 export const runForEachScoped: {
   <A, R2, E2, _>(
-    f: (a: A) => Effect.Effect<R2, E2, _>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>
+    f: (a: A) => Effect.Effect<_, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   <R, E, A, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, _>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<_, E2, R2>
+  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachScoped
 
 /**
@@ -3204,12 +3141,12 @@ export const runForEachScoped: {
  */
 export const runForEachWhile: {
   <A, R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<R2 | R, E2 | E, void>
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Effect.Effect<R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Effect.Effect<void, E | E2, R | R2>
 } = internal.runForEachWhile
 
 /**
@@ -3221,12 +3158,12 @@ export const runForEachWhile: {
  */
 export const runForEachWhileScoped: {
   <A, R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, void>
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Effect.Effect<void, E2 | E, Scope.Scope | R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, void>
+    self: Stream<A, E, R>,
+    f: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Effect.Effect<void, E | E2, Scope.Scope | R | R2>
 } = internal.runForEachWhileScoped
 
 /**
@@ -3236,7 +3173,7 @@ export const runForEachWhileScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export const runHead: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>> = internal.runHead
+export const runHead: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Option.Option<A>, E, R> = internal.runHead
 
 /**
  * Publishes elements of this stream to a `PubSub`. Stream failure and ending will
@@ -3246,8 +3183,8 @@ export const runHead: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Op
  * @category destructors
  */
 export const runIntoPubSub: {
-  <E, A>(pubsub: PubSub.PubSub<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>
-  <R, E, A>(self: Stream<R, E, A>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<R, never, void>
+  <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
+  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, R>
 } = internal.runIntoPubSub
 
 /**
@@ -3258,10 +3195,10 @@ export const runIntoPubSub: {
  * @category destructors
  */
 export const runIntoPubSubScoped: {
-  <E, A>(
-    pubsub: PubSub.PubSub<Take.Take<E, A>>
-  ): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>
-  <R, E, A>(self: Stream<R, E, A>, pubsub: PubSub.PubSub<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>
+  <A, E>(
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
+  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E, R>(self: Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>
 } = internal.runIntoPubSubScoped
 
 /**
@@ -3272,8 +3209,8 @@ export const runIntoPubSubScoped: {
  * @category destructors
  */
 export const runIntoQueue: {
-  <E, A>(queue: Queue.Enqueue<Take.Take<E, A>>): <R>(self: Stream<R, E, A>) => Effect.Effect<R, never, void>
-  <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<R, never, void>
+  <A, E>(queue: Queue.Enqueue<Take.Take<A, E>>): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, R>
+  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, R>
 } = internal.runIntoQueue
 
 /**
@@ -3284,13 +3221,13 @@ export const runIntoQueue: {
  * @category destructors
  */
 export const runIntoQueueElementsScoped: {
-  <E, A>(
-    queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>
-  ): <R>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, void>
-  <R, E, A>(
-    self: Stream<R, E, A>,
-    queue: Queue.Enqueue<Exit.Exit<Option.Option<E>, A>>
-  ): Effect.Effect<Scope.Scope | R, never, void>
+  <A, E>(
+    queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>
+  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    queue: Queue.Enqueue<Exit.Exit<A, Option.Option<E>>>
+  ): Effect.Effect<void, never, Scope.Scope | R>
 } = internal.runIntoQueueElementsScoped
 
 /**
@@ -3301,10 +3238,10 @@ export const runIntoQueueElementsScoped: {
  * @category destructors
  */
 export const runIntoQueueScoped: {
-  <E, A>(
-    queue: Queue.Enqueue<Take.Take<E, A>>
-  ): <R>(self: Stream<R, E, A>) => Effect.Effect<R | Scope.Scope, never, void>
-  <R, E, A>(self: Stream<R, E, A>, queue: Queue.Enqueue<Take.Take<E, A>>): Effect.Effect<Scope.Scope | R, never, void>
+  <A, E>(
+    queue: Queue.Enqueue<Take.Take<A, E>>
+  ): <R>(self: Stream<A, E, R>) => Effect.Effect<void, never, Scope.Scope | R>
+  <A, E, R>(self: Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, Scope.Scope | R>
 } = internal.runIntoQueueScoped
 
 /**
@@ -3314,20 +3251,20 @@ export const runIntoQueueScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export const runLast: <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<R, E, Option.Option<A>> = internal.runLast
+export const runLast: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Option.Option<A>, E, R> = internal.runLast
 
 /**
  * @since 2.0.0
  * @category destructors
  */
 export const runScoped: {
-  <R2, E2, A, A2>(
-    sink: Sink.Sink<R2, E2, A, unknown, A2>
-  ): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, A2>
-  <R, E, R2, E2, A, A2>(
-    self: Stream<R, E, A>,
-    sink: Sink.Sink<R2, E2, A, unknown, A2>
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, A2>
+  <A2, A, E2, R2>(
+    sink: Sink.Sink<A2, A, unknown, E2, R2>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Scope.Scope | R2 | R>
+  <A, E, R, A2, E2, R2>(
+    self: Stream<A, E, R>,
+    sink: Sink.Sink<A2, A, unknown, E2, R2>
+  ): Effect.Effect<A2, E | E2, Scope.Scope | R | R2>
 } = internal.runScoped
 
 /**
@@ -3336,7 +3273,7 @@ export const runScoped: {
  * @since 2.0.0
  * @category destructors
  */
-export const runSum: <R, E>(self: Stream<R, E, number>) => Effect.Effect<R, E, number> = internal.runSum
+export const runSum: <R, E>(self: Stream<number, E, R>) => Effect.Effect<number, E, R> = internal.runSum
 
 /**
  * Statefully maps over the elements of this stream to produce all
@@ -3346,8 +3283,8 @@ export const runSum: <R, E>(self: Stream<R, E, number>) => Effect.Effect<R, E, n
  * @category utils
  */
 export const scan: {
-  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<R, E, A>) => Stream<R, E, S>
-  <R, E, S, A>(self: Stream<R, E, A>, s: S, f: (s: S, a: A) => S): Stream<R, E, S>
+  <S, A>(s: S, f: (s: S, a: A) => S): <R, E>(self: Stream<A, E, R>) => Stream<S, E, R>
+  <R, E, S, A>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Stream<S, E, R>
 } = internal.scan
 
 /**
@@ -3360,13 +3297,13 @@ export const scan: {
 export const scanEffect: {
   <S, A, R2, E2>(
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<S, E2 | E, R2 | R>
   <R, E, S, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     s: S,
-    f: (s: S, a: A) => Effect.Effect<R2, E2, S>
-  ): Stream<R | R2, E | E2, S>
+    f: (s: S, a: A) => Effect.Effect<S, E2, R2>
+  ): Stream<S, E | E2, R | R2>
 } = internal.scanEffect
 
 /**
@@ -3379,8 +3316,8 @@ export const scanEffect: {
  * @category utils
  */
 export const scanReduce: {
-  <A2, A>(f: (a2: A2 | A, a: A) => A2): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A2 | A>
-  <R, E, A2, A>(self: Stream<R, E, A>, f: (a2: A2 | A, a: A) => A2): Stream<R, E, A2 | A>
+  <A2, A>(f: (a2: A2 | A, a: A) => A2): <R, E>(self: Stream<A, E, R>) => Stream<A2 | A, E, R>
+  <R, E, A2, A>(self: Stream<A, E, R>, f: (a2: A2 | A, a: A) => A2): Stream<A2 | A, E, R>
 } = internal.scanReduce
 
 /**
@@ -3392,9 +3329,7 @@ export const scanReduce: {
  * @since 2.0.0
  * @category utils
  */
-export const scanReduceEffect: <A2, A, R2, E2>(
-  f: (a2: A2 | A, a: A) => Effect.Effect<R2, E2, A2 | A>
-) => <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A> = internal.scanReduceEffect
+export const scanReduceEffect = internal.scanReduceEffect
 
 /**
  * Schedules the output of the stream using the provided `schedule`.
@@ -3405,8 +3340,8 @@ export const scanReduceEffect: <A2, A, R2, E2>(
 export const schedule: {
   <R2, A, A0 extends A, _>(
     schedule: Schedule.Schedule<R2, A0, _>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, A>
-  <R, E, R2, A, A0 extends A, _>(self: Stream<R, E, A>, schedule: Schedule.Schedule<R2, A0, _>): Stream<R | R2, E, A>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R2 | R>
+  <R, E, R2, A, A0 extends A, _>(self: Stream<A, E, R>, schedule: Schedule.Schedule<R2, A0, _>): Stream<A, E, R | R2>
 } = internal.schedule
 
 /**
@@ -3420,19 +3355,13 @@ export const schedule: {
 export const scheduleWith: {
   <R2, A, A0 extends A, B, C>(
     schedule: Schedule.Schedule<R2, A0, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): <R, E>(self: Stream<A, E, R>) => Stream<C, E, R2 | R>
   <R, E, R2, A, A0 extends A, B, C>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     schedule: Schedule.Schedule<R2, A0, B>,
-    options: {
-      readonly onElement: (a: A) => C
-      readonly onSchedule: (b: B) => C
-    }
-  ): Stream<R | R2, E, C>
+    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+  ): Stream<C, E, R | R2>
 } = internal.scheduleWith
 
 /**
@@ -3441,7 +3370,7 @@ export const scheduleWith: {
  * @since 2.0.0
  * @category constructors
  */
-export const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<Exclude<R, Scope.Scope>, E, A> =
+export const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, Exclude<R, Scope.Scope>> =
   internal.scoped
 
 /**
@@ -3463,8 +3392,8 @@ export const scoped: <R, E, A>(effect: Effect.Effect<R, E, A>) => Stream<Exclude
  * @category utils
  */
 export const sliding: {
-  (chunkSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, chunkSize: number): Stream<R, E, Chunk.Chunk<A>>
+  (chunkSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number): Stream<Chunk.Chunk<A>, E, R>
 } = internal.sliding
 
 /**
@@ -3474,8 +3403,8 @@ export const sliding: {
  * @category utils
  */
 export const slidingSize: {
-  (chunkSize: number, stepSize: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, chunkSize: number, stepSize: number): Stream<R, E, Chunk.Chunk<A>>
+  (chunkSize: number, stepSize: number): <A, E, R>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, chunkSize: number, stepSize: number): Stream<Chunk.Chunk<A>, E, R>
 } = internal.slidingSize
 
 /**
@@ -3484,7 +3413,7 @@ export const slidingSize: {
  * @since 2.0.0
  * @category utils
  */
-export const some: <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, Option.Option<E>, A> = internal.some
+export const some: <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A, Option.Option<E>, R> = internal.some
 
 /**
  * Extracts the optional value, or returns the given 'default'.
@@ -3493,8 +3422,8 @@ export const some: <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R,
  * @category utils
  */
 export const someOrElse: {
-  <A2>(fallback: LazyArg<A2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E, A2 | A>
-  <R, E, A, A2>(self: Stream<R, E, Option.Option<A>>, fallback: LazyArg<A2>): Stream<R, E, A | A2>
+  <A2>(fallback: LazyArg<A2>): <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A2 | A, E, R>
+  <R, E, A, A2>(self: Stream<Option.Option<A>, E, R>, fallback: LazyArg<A2>): Stream<A | A2, E, R>
 } = internal.someOrElse
 
 /**
@@ -3504,8 +3433,8 @@ export const someOrElse: {
  * @category utils
  */
 export const someOrFail: {
-  <E2>(error: LazyArg<E2>): <R, E, A>(self: Stream<R, E, Option.Option<A>>) => Stream<R, E2 | E, A>
-  <R, E, A, E2>(self: Stream<R, E, Option.Option<A>>, error: LazyArg<E2>): Stream<R, E | E2, A>
+  <E2>(error: LazyArg<E2>): <A, E, R>(self: Stream<Option.Option<A>, E, R>) => Stream<A, E2 | E, R>
+  <R, E, A, E2>(self: Stream<Option.Option<A>, E, R>, error: LazyArg<E2>): Stream<A, E | E2, R>
 } = internal.someOrFail
 
 /**
@@ -3527,8 +3456,8 @@ export const someOrFail: {
  * @category utils
  */
 export const split: {
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<Chunk.Chunk<A>, E, R>
 } = internal.split
 
 /**
@@ -3538,8 +3467,8 @@ export const split: {
  * @category utils
  */
 export const splitOnChunk: {
-  <A>(delimiter: Chunk.Chunk<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
-  <R, E, A>(self: Stream<R, E, A>, delimiter: Chunk.Chunk<A>): Stream<R, E, Chunk.Chunk<A>>
+  <A>(delimiter: Chunk.Chunk<A>): <R, E>(self: Stream<A, E, R>) => Stream<Chunk.Chunk<A>, E, R>
+  <A, E, R>(self: Stream<A, E, R>, delimiter: Chunk.Chunk<A>): Stream<Chunk.Chunk<A>, E, R>
 } = internal.splitOnChunk
 
 /**
@@ -3549,7 +3478,7 @@ export const splitOnChunk: {
  * @since 2.0.0
  * @category combinators
  */
-export const splitLines: <R, E>(self: Stream<R, E, string>) => Stream<R, E, string> = internal.splitLines
+export const splitLines: <R, E>(self: Stream<string, E, R>) => Stream<string, E, R> = internal.splitLines
 
 /**
  * Creates a single-valued pure stream.
@@ -3557,7 +3486,7 @@ export const splitLines: <R, E>(self: Stream<R, E, string>) => Stream<R, E, stri
  * @since 2.0.0
  * @category constructors
  */
-export const succeed: <A>(value: A) => Stream<never, never, A> = internal.succeed
+export const succeed: <A>(value: A) => Stream<A> = internal.succeed
 
 /**
  * Creates a single-valued pure stream.
@@ -3565,7 +3494,7 @@ export const succeed: <A>(value: A) => Stream<never, never, A> = internal.succee
  * @since 2.0.0
  * @category constructors
  */
-export const sync: <A>(evaluate: LazyArg<A>) => Stream<never, never, A> = internal.sync
+export const sync: <A>(evaluate: LazyArg<A>) => Stream<A> = internal.sync
 
 /**
  * Returns a lazily constructed stream.
@@ -3573,7 +3502,7 @@ export const sync: <A>(evaluate: LazyArg<A>) => Stream<never, never, A> = intern
  * @since 2.0.0
  * @category constructors
  */
-export const suspend: <R, E, A>(stream: LazyArg<Stream<R, E, A>>) => Stream<R, E, A> = internal.suspend
+export const suspend: <A, E, R>(stream: LazyArg<Stream<A, E, R>>) => Stream<A, E, R> = internal.suspend
 
 /**
  * Takes the specified number of elements from this stream.
@@ -3582,8 +3511,8 @@ export const suspend: <R, E, A>(stream: LazyArg<Stream<R, E, A>>) => Stream<R, E
  * @category utils
  */
 export const take: {
-  (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>
+  (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>
 } = internal.take
 
 /**
@@ -3593,8 +3522,8 @@ export const take: {
  * @category utils
  */
 export const takeRight: {
-  (n: number): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, n: number): Stream<R, E, A>
+  (n: number): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, n: number): Stream<A, E, R>
 } = internal.takeRight
 
 /**
@@ -3605,8 +3534,8 @@ export const takeRight: {
  * @category utils
  */
 export const takeUntil: {
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.takeUntil
 
 /**
@@ -3618,12 +3547,12 @@ export const takeUntil: {
  */
 export const takeUntilEffect: {
   <A, R2, E2>(
-    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
+    predicate: (a: NoInfer<A>) => Effect.Effect<boolean, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<A, E, R>,
+    predicate: (a: A) => Effect.Effect<boolean, E2, R2>
+  ): Stream<A, E | E2, R | R2>
 } = internal.takeUntilEffect
 
 /**
@@ -3634,10 +3563,10 @@ export const takeUntilEffect: {
  * @category utils
  */
 export const takeWhile: {
-  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
-  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<A, E, R>) => Stream<B, E, R>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <R, E, A, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>): Stream<B, E, R>
+  <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>
 } = internal.takeWhile
 
 /**
@@ -3648,12 +3577,9 @@ export const takeWhile: {
  */
 export const tap: {
   <A, R2, E2, _>(
-    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
-  ): Stream<R | R2, E | E2, A>
+    f: (a: NoInfer<A>) => Effect.Effect<_, E2, R2>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, _>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.tap
 
 /**
@@ -3666,17 +3592,17 @@ export const tap: {
 export const tapBoth: {
   <E, R2, E2, X1, A, R3, E3, X2>(
     options: {
-      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
-      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X1, E2, R2>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X2, E3, R3>
     }
-  ): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>
+  ): <R>(self: Stream<A, E, R>) => Stream<A, E | E2 | E3, R2 | R3 | R>
   <R, E, A, R2, E2, X1, R3, E3, X2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     options: {
-      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
-      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<X1, E2, R2>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<X2, E3, R3>
     }
-  ): Stream<R | R2 | R3, E | E2 | E3, A>
+  ): Stream<A, E | E2 | E3, R | R2 | R3>
 } = internal.tapBoth
 
 /**
@@ -3687,12 +3613,9 @@ export const tapBoth: {
  */
 export const tapError: {
   <E, R2, E2, _>(
-    f: (error: NoInfer<E>) => Effect.Effect<R2, E2, _>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
-  <R, A, E, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (error: E) => Effect.Effect<R2, E2, _>
-  ): Stream<R | R2, E | E2, A>
+    f: (error: NoInfer<E>) => Effect.Effect<_, E2, R2>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
+  <R, A, E, R2, E2, _>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<_, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.tapError
 
 /**
@@ -3704,12 +3627,12 @@ export const tapError: {
  */
 export const tapErrorCause: {
   <E, R2, E2, _>(
-    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<R2, E2, _>
-  ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
+    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<_, E2, R2>
+  ): <R, A>(self: Stream<A, E, R>) => Stream<A, E | E2, R2 | R>
   <R, A, E, R2, E2, _>(
-    self: Stream<R, E, A>,
-    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, _>
-  ): Stream<R | R2, E | E2, A>
+    self: Stream<A, E, R>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<_, E2, R2>
+  ): Stream<A, E | E2, R | R2>
 } = internal.tapErrorCause
 
 /**
@@ -3720,8 +3643,8 @@ export const tapErrorCause: {
  * @category sequencing
  */
 export const tapSink: {
-  <R2, E2, A>(sink: Sink.Sink<R2, E2, A, unknown, unknown>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, R2, E2, A>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, unknown, unknown>): Stream<R | R2, E | E2, A>
+  <A, E2, R2>(sink: Sink.Sink<unknown, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <A, E, R, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<unknown, A, unknown, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.tapSink
 
 /**
@@ -3749,9 +3672,9 @@ export const throttle: {
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     options: {
       readonly cost: (chunk: Chunk.Chunk<A>) => number
       readonly units: number
@@ -3759,7 +3682,7 @@ export const throttle: {
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
-  ): Stream<R, E, A>
+  ): Stream<A, E, R>
 } = internal.throttle
 
 /**
@@ -3781,23 +3704,23 @@ export const throttle: {
 export const throttleEffect: {
   <A, R2, E2>(
     options: {
-      readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>
+      readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
       readonly duration: Duration.DurationInput
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
   <R, E, A, R2, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     options: {
-      readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<R2, E2, number>
+      readonly cost: (chunk: Chunk.Chunk<A>) => Effect.Effect<number, E2, R2>
       readonly units: number
       readonly duration: Duration.DurationInput
       readonly burst?: number | undefined
       readonly strategy?: "enforce" | "shape" | undefined
     }
-  ): Stream<R | R2, E | E2, A>
+  ): Stream<A, E | E2, R | R2>
 } = internal.throttleEffect
 
 /**
@@ -3806,7 +3729,7 @@ export const throttleEffect: {
  * @since 2.0.0
  * @category constructors
  */
-export const tick: (interval: Duration.DurationInput) => Stream<never, never, void> = internal.tick
+export const tick: (interval: Duration.DurationInput) => Stream<void> = internal.tick
 
 /**
  * Ends the stream if it does not produce a value after the specified duration.
@@ -3815,8 +3738,8 @@ export const tick: (interval: Duration.DurationInput) => Stream<never, never, vo
  * @category utils
  */
 export const timeout: {
-  (duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, duration: Duration.DurationInput): Stream<R, E, A>
+  (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>
 } = internal.timeout
 
 /**
@@ -3827,8 +3750,8 @@ export const timeout: {
  * @category utils
  */
 export const timeoutFail: {
-  <E2>(error: LazyArg<E2>, duration: Duration.DurationInput): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>
-  <R, E, A, E2>(self: Stream<R, E, A>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<R, E | E2, A>
+  <E2>(error: LazyArg<E2>, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
+  <R, E, A, E2>(self: Stream<A, E, R>, error: LazyArg<E2>, duration: Duration.DurationInput): Stream<A, E | E2, R>
 } = internal.timeoutFail
 
 /**
@@ -3842,12 +3765,12 @@ export const timeoutFailCause: {
   <E2>(
     cause: LazyArg<Cause.Cause<E2>>,
     duration: Duration.DurationInput
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E2 | E, A>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R>
   <R, E, A, E2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     cause: LazyArg<Cause.Cause<E2>>,
     duration: Duration.DurationInput
-  ): Stream<R, E | E2, A>
+  ): Stream<A, E | E2, R>
 } = internal.timeoutFailCause
 
 /**
@@ -3860,13 +3783,13 @@ export const timeoutFailCause: {
 export const timeoutTo: {
   <R2, E2, A2>(
     duration: Duration.DurationInput,
-    that: Stream<R2, E2, A2>
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2 | A>
+    that: Stream<A2, E2, R2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2 | A, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     duration: Duration.DurationInput,
-    that: Stream<R2, E2, A2>
-  ): Stream<R | R2, E | E2, A | A2>
+    that: Stream<A2, E2, R2>
+  ): Stream<A | A2, E | E2, R | R2>
 } = internal.timeoutTo
 
 /**
@@ -3879,11 +3802,11 @@ export const timeoutTo: {
 export const toPubSub: {
   (
     capacity: number
-  ): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, PubSub.PubSub<Take.Take<E, A>>>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     capacity: number
-  ): Effect.Effect<Scope.Scope | R, never, PubSub.PubSub<Take.Take<E, A>>>
+  ): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
 } = internal.toPubSub
 
 /**
@@ -3895,9 +3818,9 @@ export const toPubSub: {
  * @since 2.0.0
  * @category destructors
  */
-export const toPull: <R, E, A>(
-  self: Stream<R, E, A>
-) => Effect.Effect<Scope.Scope | R, never, Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>> = internal.toPull
+export const toPull: <A, E, R>(
+  self: Stream<A, E, R>
+) => Effect.Effect<Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R>, never, Scope.Scope | R> = internal.toPull
 
 /**
  * Converts the stream to a scoped queue of chunks. After the scope is closed,
@@ -3910,22 +3833,18 @@ export const toPull: <R, E, A>(
  */
 export const toQueue: {
   (
-    options?: {
-      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-      readonly capacity?: number | undefined
-    } | {
-      readonly strategy: "unbounded"
-    }
-  ): <R, E, A>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>
-  <R, E, A>(
-    self: Stream<R, E, A>,
-    options?: {
-      readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-      readonly capacity?: number | undefined
-    } | {
-      readonly strategy: "unbounded"
-    }
-  ): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Take.Take<E, A>>>
+    options?:
+      | { readonly strategy?: "dropping" | "sliding" | "suspend" | undefined; readonly capacity?: number | undefined }
+      | { readonly strategy: "unbounded" }
+      | undefined
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    options?:
+      | { readonly strategy?: "dropping" | "sliding" | "suspend" | undefined; readonly capacity?: number | undefined }
+      | { readonly strategy: "unbounded" }
+      | undefined
+  ): Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope | R>
 } = internal.toQueue
 
 /**
@@ -3939,18 +3858,14 @@ export const toQueue: {
  */
 export const toQueueOfElements: {
   (
-    options?: {
-      readonly capacity?: number | undefined
-    }
-  ): <R, E, A>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>
-  <R, E, A>(
-    self: Stream<R, E, A>,
-    options?: {
-      readonly capacity?: number | undefined
-    }
-  ): Effect.Effect<Scope.Scope | R, never, Queue.Dequeue<Exit.Exit<Option.Option<E>, A>>>
+    options?: { readonly capacity?: number | undefined } | undefined
+  ): <A, E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, never, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    options?: { readonly capacity?: number | undefined } | undefined
+  ): Effect.Effect<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, never, Scope.Scope | R>
 } = internal.toQueueOfElements
 
 /**
@@ -3961,7 +3876,7 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <E, A>(source: Stream<never, E, A>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
 
 /**
  * Applies the transducer to the stream and emits its outputs.
@@ -3970,8 +3885,8 @@ export const toReadableStream: <E, A>(source: Stream<never, E, A>) => ReadableSt
  * @category utils
  */
 export const transduce: {
-  <R2, E2, A, Z>(sink: Sink.Sink<R2, E2, A, A, Z>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, Z>
-  <R, E, R2, E2, A, Z>(self: Stream<R, E, A>, sink: Sink.Sink<R2, E2, A, A, Z>): Stream<R | R2, E | E2, Z>
+  <A2, A, E2, R2>(sink: Sink.Sink<A2, A, A, E2, R2>): <E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, A, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.transduce
 
 /**
@@ -3980,8 +3895,7 @@ export const transduce: {
  * @since 2.0.0
  * @category constructors
  */
-export const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) => Stream<never, never, A> =
-  internal.unfold
+export const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) => Stream<A> = internal.unfold
 
 /**
  * Creates a stream by peeling off the "layers" of a value of type `S`.
@@ -3992,7 +3906,7 @@ export const unfold: <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>) =
 export const unfoldChunk: <S, A>(
   s: S,
   f: (s: S) => Option.Option<readonly [Chunk.Chunk<A>, S]>
-) => Stream<never, never, A> = internal.unfoldChunk
+) => Stream<A> = internal.unfoldChunk
 
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type
@@ -4003,8 +3917,8 @@ export const unfoldChunk: <S, A>(
  */
 export const unfoldChunkEffect: <R, E, A, S>(
   s: S,
-  f: (s: S) => Effect.Effect<R, E, Option.Option<readonly [Chunk.Chunk<A>, S]>>
-) => Stream<R, E, A> = internal.unfoldChunkEffect
+  f: (s: S) => Effect.Effect<Option.Option<readonly [Chunk.Chunk<A>, S]>, E, R>
+) => Stream<A, E, R> = internal.unfoldChunkEffect
 
 /**
  * Creates a stream by effectfully peeling off the "layers" of a value of type
@@ -4015,8 +3929,8 @@ export const unfoldChunkEffect: <R, E, A, S>(
  */
 export const unfoldEffect: <S, R, E, A>(
   s: S,
-  f: (s: S) => Effect.Effect<R, E, Option.Option<readonly [A, S]>>
-) => Stream<R, E, A> = internal.unfoldEffect
+  f: (s: S) => Effect.Effect<Option.Option<readonly [A, S]>, E, R>
+) => Stream<A, E, R> = internal.unfoldEffect
 
 /**
  * A stream that contains a single `Unit` value.
@@ -4024,7 +3938,7 @@ export const unfoldEffect: <S, R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const unit: Stream<never, never, void> = internal.unit
+export const unit: Stream<void> = internal.unit
 
 /**
  * Creates a stream produced from an `Effect`.
@@ -4032,7 +3946,7 @@ export const unit: Stream<never, never, void> = internal.unit
  * @since 2.0.0
  * @category constructors
  */
-export const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Stream<R2, E2, A>>) => Stream<R | R2, E | E2, A> =
+export const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2> =
   internal.unwrap
 
 /**
@@ -4042,8 +3956,8 @@ export const unwrap: <R, E, R2, E2, A>(effect: Effect.Effect<R, E, Stream<R2, E2
  * @category constructors
  */
 export const unwrapScoped: <R, E, R2, E2, A>(
-  effect: Effect.Effect<R, E, Stream<R2, E2, A>>
-) => Stream<R2 | Exclude<R, Scope.Scope>, E | E2, A> = internal.unwrapScoped
+  effect: Effect.Effect<Stream<A, E2, R2>, E, R>
+) => Stream<A, E | E2, R2 | Exclude<R, Scope.Scope>> = internal.unwrapScoped
 
 /**
  * Updates the specified service within the context of the `Stream`.
@@ -4061,8 +3975,8 @@ export const updateService = internal.updateService
  * @category utils
  */
 export const when: {
-  (test: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, test: LazyArg<boolean>): Stream<R, E, A>
+  (test: LazyArg<boolean>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  <A, E, R>(self: Stream<A, E, R>, test: LazyArg<boolean>): Stream<A, E, R>
 } = internal.when
 
 /**
@@ -4074,8 +3988,8 @@ export const when: {
  */
 export const whenCase: <A, R, E, A2>(
   evaluate: LazyArg<A>,
-  pf: (a: A) => Option.Option<Stream<R, E, A2>>
-) => Stream<R, E, A2> = internal.whenCase
+  pf: (a: A) => Option.Option<Stream<A2, E, R>>
+) => Stream<A2, E, R> = internal.whenCase
 
 /**
  * Returns the stream when the given partial function is defined for the given
@@ -4086,12 +4000,12 @@ export const whenCase: <A, R, E, A2>(
  */
 export const whenCaseEffect: {
   <A, R2, E2, A2>(
-    pf: (a: A) => Option.Option<Stream<R2, E2, A2>>
-  ): <R, E>(self: Effect.Effect<R, E, A>) => Stream<R2 | R, E2 | E, A2>
+    pf: (a: A) => Option.Option<Stream<A2, E2, R2>>
+  ): <R, E>(self: Effect.Effect<A, E, R>) => Stream<A2, E2 | E, R2 | R>
   <R, E, A, R2, E2, A2>(
-    self: Effect.Effect<R, E, A>,
-    pf: (a: A) => Option.Option<Stream<R2, E2, A2>>
-  ): Stream<R | R2, E | E2, A2>
+    self: Effect.Effect<A, E, R>,
+    pf: (a: A) => Option.Option<Stream<A2, E2, R2>>
+  ): Stream<A2, E | E2, R | R2>
 } = internal.whenCaseEffect
 
 /**
@@ -4102,8 +4016,8 @@ export const whenCaseEffect: {
  * @category utils
  */
 export const whenEffect: {
-  <R2, E2>(effect: Effect.Effect<R2, E2, boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2>(self: Stream<R, E, A>, effect: Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>
+  <R2, E2>(effect: Effect.Effect<boolean, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2>(self: Stream<A, E, R>, effect: Effect.Effect<boolean, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.whenEffect
 
 /**
@@ -4121,10 +4035,10 @@ export const withSpan: {
       readonly parent?: Tracer.ParentSpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
-    }
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(
-    self: Stream<R, E, A>,
+    } | undefined
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(
+    self: Stream<A, E, R>,
     name: string,
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
@@ -4132,8 +4046,8 @@ export const withSpan: {
       readonly parent?: Tracer.ParentSpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
-    }
-  ): Stream<R, E, A>
+    } | undefined
+  ): Stream<A, E, Exclude<R, Tracer.ParentSpan>>
 } = internal.withSpan
 
 /**
@@ -4146,8 +4060,8 @@ export const withSpan: {
  * @category zipping
  */
 export const zip: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
 } = internal.zip
 
 /**
@@ -4161,12 +4075,12 @@ export const zip: {
  */
 export const zipFlatten: {
   <R2, E2, A2>(
-    that: Stream<R2, E2, A2>
-  ): <R, E, A extends ReadonlyArray<any>>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [...A, A2]>
+    that: Stream<A2, E2, R2>
+  ): <R, E, A extends ReadonlyArray<any>>(self: Stream<A, E, R>) => Stream<[...A, A2], E2 | E, R2 | R>
   <R, E, A extends ReadonlyArray<any>, R2, E2, A2>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>
-  ): Stream<R | R2, E | E2, [...A, A2]>
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>
+  ): Stream<[...A, A2], E | E2, R | R2>
 } = internal.zipFlatten
 
 /**
@@ -4181,20 +4095,12 @@ export const zipFlatten: {
  */
 export const zipAll: {
   <R2, E2, A2, A>(
-    options: {
-      readonly other: Stream<R2, E2, A2>
-      readonly defaultSelf: A
-      readonly defaultOther: A2
-    }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>
+    options: { readonly other: Stream<A2, E2, R2>; readonly defaultSelf: A; readonly defaultOther: A2 }
+  ): <R, E>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
   <R, E, R2, E2, A2, A>(
-    self: Stream<R, E, A>,
-    options: {
-      readonly other: Stream<R2, E2, A2>
-      readonly defaultSelf: A
-      readonly defaultOther: A2
-    }
-  ): Stream<R | R2, E | E2, [A, A2]>
+    self: Stream<A, E, R>,
+    options: { readonly other: Stream<A2, E2, R2>; readonly defaultSelf: A; readonly defaultOther: A2 }
+  ): Stream<[A, A2], E | E2, R | R2>
 } = internal.zipAll
 
 /**
@@ -4208,8 +4114,8 @@ export const zipAll: {
  * @category zipping
  */
 export const zipAllLeft: {
-  <R2, E2, A2, A>(that: Stream<R2, E2, A2>, defaultLeft: A): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, R2, E2, A2, A>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultLeft: A): Stream<R | R2, E | E2, A>
+  <R2, E2, A2, A>(that: Stream<A2, E2, R2>, defaultLeft: A): <R, E>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, R2, E2, A2, A>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultLeft: A): Stream<A, E | E2, R | R2>
 } = internal.zipAllLeft
 
 /**
@@ -4224,10 +4130,10 @@ export const zipAllLeft: {
  */
 export const zipAllRight: {
   <R2, E2, A2>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     defaultRight: A2
-  ): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>, defaultRight: A2): Stream<R | R2, E | E2, A2>
+  ): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>, defaultRight: A2): Stream<A2, E | E2, R | R2>
 } = internal.zipAllRight
 
 /**
@@ -4247,21 +4153,21 @@ export const zipAllRight: {
 export const zipAllSortedByKey: {
   <R2, E2, A2, A, K>(
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultSelf: A
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, [A, A2]]>
+  ): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, [A, A2]], E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, K>(
-    self: Stream<R, E, readonly [K, A]>,
+    self: Stream<readonly [K, A], E, R>,
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultSelf: A
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): Stream<R | R2, E | E2, [K, [A, A2]]>
+  ): Stream<[K, [A, A2]], E | E2, R | R2>
 } = internal.zipAllSortedByKey
 
 /**
@@ -4280,19 +4186,19 @@ export const zipAllSortedByKey: {
 export const zipAllSortedByKeyLeft: {
   <R2, E2, A2, A, K>(
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultSelf: A
       readonly order: Order.Order<K>
     }
-  ): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A]>
+  ): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A], E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, K>(
-    self: Stream<R, E, readonly [K, A]>,
+    self: Stream<readonly [K, A], E, R>,
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultSelf: A
       readonly order: Order.Order<K>
     }
-  ): Stream<R | R2, E | E2, [K, A]>
+  ): Stream<[K, A], E | E2, R | R2>
 } = internal.zipAllSortedByKeyLeft
 
 /**
@@ -4311,19 +4217,19 @@ export const zipAllSortedByKeyLeft: {
 export const zipAllSortedByKeyRight: {
   <R2, E2, A2, K>(
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): <R, E, A>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A2]>
+  ): <A, E, R>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A2], E2 | E, R2 | R>
   <R, E, A, R2, E2, A2, K>(
-    self: Stream<R, E, readonly [K, A]>,
+    self: Stream<readonly [K, A], E, R>,
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly defaultOther: A2
       readonly order: Order.Order<K>
     }
-  ): Stream<R | R2, E | E2, [K, A2]>
+  ): Stream<[K, A2], E | E2, R | R2>
 } = internal.zipAllSortedByKeyRight
 
 /**
@@ -4343,23 +4249,23 @@ export const zipAllSortedByKeyRight: {
 export const zipAllSortedByKeyWith: {
   <R2, E2, A, A3, A2, K>(
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A3
       readonly onBoth: (a: A, a2: A2) => A3
       readonly order: Order.Order<K>
     }
-  ): <R, E>(self: Stream<R, E, readonly [K, A]>) => Stream<R2 | R, E2 | E, [K, A3]>
+  ): <R, E>(self: Stream<readonly [K, A], E, R>) => Stream<[K, A3], E2 | E, R2 | R>
   <R, E, R2, E2, A, A3, A2, K>(
-    self: Stream<R, E, readonly [K, A]>,
+    self: Stream<readonly [K, A], E, R>,
     options: {
-      readonly other: Stream<R2, E2, readonly [K, A2]>
+      readonly other: Stream<readonly [K, A2], E2, R2>
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A3
       readonly onBoth: (a: A, a2: A2) => A3
       readonly order: Order.Order<K>
     }
-  ): Stream<R | R2, E | E2, [K, A3]>
+  ): Stream<[K, A3], E | E2, R | R2>
 } = internal.zipAllSortedByKeyWith
 
 /**
@@ -4375,21 +4281,21 @@ export const zipAllSortedByKeyWith: {
 export const zipAllWith: {
   <R2, E2, A2, A, A3>(
     options: {
-      readonly other: Stream<R2, E2, A2>
+      readonly other: Stream<A2, E2, R2>
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A3
       readonly onBoth: (a: A, a2: A2) => A3
     }
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, A3>(
-    self: Stream<R, E, A>,
+    self: Stream<A, E, R>,
     options: {
-      readonly other: Stream<R2, E2, A2>
+      readonly other: Stream<A2, E2, R2>
       readonly onSelf: (a: A) => A3
       readonly onOther: (a2: A2) => A3
       readonly onBoth: (a: A, a2: A2) => A3
     }
-  ): Stream<R | R2, E | E2, A3>
+  ): Stream<A3, E | E2, R | R2>
 } = internal.zipAllWith
 
 /**
@@ -4405,8 +4311,8 @@ export const zipAllWith: {
  * @category zipping
  */
 export const zipLatest: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, [A, A2]>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, [A, A2]>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<[A, A2], E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<[A, A2], E | E2, R | R2>
 } = internal.zipLatest
 
 /**
@@ -4423,14 +4329,14 @@ export const zipLatest: {
  */
 export const zipLatestWith: {
   <R2, E2, A2, A, A3>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     f: (a: A, a2: A2) => A3
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, A3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
     f: (a: A, a2: A2) => A3
-  ): Stream<R | R2, E | E2, A3>
+  ): Stream<A3, E | E2, R | R2>
 } = internal.zipLatestWith
 
 /**
@@ -4443,8 +4349,8 @@ export const zipLatestWith: {
  * @category zipping
  */
 export const zipLeft: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>
 } = internal.zipLeft
 
 /**
@@ -4457,8 +4363,8 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
-  <R2, E2, A2>(that: Stream<R2, E2, A2>): <R, E, A>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A2>
-  <R, E, A, R2, E2, A2>(self: Stream<R, E, A>, that: Stream<R2, E2, A2>): Stream<R | R2, E | E2, A2>
+  <R2, E2, A2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>
+  <R, E, A, R2, E2, A2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>
 } = internal.zipRight
 
 /**
@@ -4472,14 +4378,14 @@ export const zipRight: {
  */
 export const zipWith: {
   <R2, E2, A2, A, A3>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     f: (a: A, a2: A2) => A3
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, A3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
     f: (a: A, a2: A2) => A3
-  ): Stream<R | R2, E | E2, A3>
+  ): Stream<A3, E | E2, R | R2>
 } = internal.zipWith
 
 /**
@@ -4493,20 +4399,20 @@ export const zipWith: {
  */
 export const zipWithChunks: {
   <R2, E2, A2, A, A3>(
-    that: Stream<R2, E2, A2>,
+    that: Stream<A2, E2, R2>,
     f: (
       left: Chunk.Chunk<A>,
       right: Chunk.Chunk<A2>
     ) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]
-  ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A3>
+  ): <R, E>(self: Stream<A, E, R>) => Stream<A3, E2 | E, R2 | R>
   <R, E, R2, E2, A2, A, A3>(
-    self: Stream<R, E, A>,
-    that: Stream<R2, E2, A2>,
+    self: Stream<A, E, R>,
+    that: Stream<A2, E2, R2>,
     f: (
       left: Chunk.Chunk<A>,
       right: Chunk.Chunk<A2>
     ) => readonly [Chunk.Chunk<A3>, Either.Either<Chunk.Chunk<A>, Chunk.Chunk<A2>>]
-  ): Stream<R | R2, E | E2, A3>
+  ): Stream<A3, E | E2, R | R2>
 } = internal.zipWithChunks
 
 /**
@@ -4515,7 +4421,7 @@ export const zipWithChunks: {
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A, Option.Option<A>]> = internal.zipWithNext
+export const zipWithNext: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, Option.Option<A>], E, R> = internal.zipWithNext
 
 /**
  * Zips each element with the previous element. Initially accompanied by
@@ -4524,7 +4430,7 @@ export const zipWithNext: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A, O
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithPrevious: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [Option.Option<A>, A]> =
+export const zipWithPrevious: <A, E, R>(self: Stream<A, E, R>) => Stream<[Option.Option<A>, A], E, R> =
   internal.zipWithPrevious
 
 /**
@@ -4533,9 +4439,9 @@ export const zipWithPrevious: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithPreviousAndNext: <R, E, A>(
-  self: Stream<R, E, A>
-) => Stream<R, E, [Option.Option<A>, A, Option.Option<A>]> = internal.zipWithPreviousAndNext
+export const zipWithPreviousAndNext: <A, E, R>(
+  self: Stream<A, E, R>
+) => Stream<[Option.Option<A>, A, Option.Option<A>], E, R> = internal.zipWithPreviousAndNext
 
 /**
  * Zips this stream together with the index of elements.
@@ -4543,7 +4449,7 @@ export const zipWithPreviousAndNext: <R, E, A>(
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithIndex: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A, number]> = internal.zipWithIndex
+export const zipWithIndex: <A, E, R>(self: Stream<A, E, R>) => Stream<[A, number], E, R> = internal.zipWithIndex
 
 // -------------------------------------------------------------------------------------
 // Do notation
@@ -4553,7 +4459,7 @@ export const zipWithIndex: <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, [A,
  * @since 2.0.0
  * @category do notation
  */
-export const Do: Stream<never, never, {}> = internal.Do
+export const Do: Stream<{}> = internal.Do
 
 /**
  * Binds a value from a stream in a `do` scope
@@ -4564,21 +4470,19 @@ export const Do: Stream<never, never, {}> = internal.Do
 export const bind: {
   <N extends string, K, R2, E2, A>(
     tag: Exclude<N, keyof K>,
-    f: (_: K) => Stream<R2, E2, A>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, { [k in N]: A }>>
+    f: (_: K) => Stream<A, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+      | undefined
+  ): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
   <R, E, N extends string, K, R2, E2, A>(
-    self: Stream<R, E, K>,
+    self: Stream<K, E, R>,
     tag: Exclude<N, keyof K>,
-    f: (_: K) => Stream<R2, E2, A>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): Stream<R | R2, E | E2, Effect.MergeRecord<K, { [k in N]: A }>>
+    f: (_: K) => Stream<A, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+      | undefined
+  ): Stream<Effect.MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
 } = internal.bind
 
 /**
@@ -4590,21 +4494,19 @@ export const bind: {
 export const bindEffect: {
   <N extends string, K, R2, E2, A>(
     tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<R2, E2, A>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): <R, E>(self: Stream<R, E, K>) => Stream<R2 | R, E2 | E, Effect.MergeRecord<K, { [k in N]: A }>>
+    f: (_: K) => Effect.Effect<A, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly bufferSize?: number | undefined }
+      | undefined
+  ): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
   <R, E, N extends string, K, R2, E2, A>(
-    self: Stream<R, E, K>,
+    self: Stream<K, E, R>,
     tag: Exclude<N, keyof K>,
-    f: (_: K) => Effect.Effect<R2, E2, A>,
-    options?: {
-      readonly concurrency?: number | "unbounded" | undefined
-      readonly bufferSize?: number | undefined
-    }
-  ): Stream<R | R2, E | E2, Effect.MergeRecord<K, { [k in N]: A }>>
+    f: (_: K) => Effect.Effect<A, E2, R2>,
+    options?:
+      | { readonly concurrency?: number | "unbounded" | undefined; readonly unordered?: boolean | undefined }
+      | undefined
+  ): Stream<Effect.MergeRecord<K, { [k in N]: A }>, E | E2, R | R2>
 } = _groupBy.bindEffect
 
 /**
@@ -4612,20 +4514,20 @@ export const bindEffect: {
  * @category do notation
  */
 export const bindTo: {
-  <N extends string>(tag: N): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, Record<N, A>>
-  <R, E, A, N extends string>(self: Stream<R, E, A>, tag: N): Stream<R, E, Record<N, A>>
+  <N extends string>(tag: N): <A, E, R>(self: Stream<A, E, R>) => Stream<Record<N, A>, E, R>
+  <R, E, A, N extends string>(self: Stream<A, E, R>, tag: N): Stream<Record<N, A>, E, R>
 } = internal.bindTo
 
 const let_: {
   <N extends string, K, A>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ): <R, E>(self: Stream<R, E, K>) => Stream<R, E, Effect.MergeRecord<K, { [k in N]: A }>>
+  ): <R, E>(self: Stream<K, E, R>) => Stream<Effect.MergeRecord<K, { [k in N]: A }>, E, R>
   <R, E, K, N extends string, A>(
-    self: Stream<R, E, K>,
+    self: Stream<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ): Stream<R, E, Effect.MergeRecord<K, { [k in N]: A }>>
+  ): Stream<Effect.MergeRecord<K, { [k in N]: A }>, E, R>
 } = internal.let_
 
 export {
@@ -4649,8 +4551,8 @@ export {
  * @category encoding
  */
 export const decodeText: {
-  (encoding?: string): <R, E>(self: Stream<R, E, Uint8Array>) => Stream<R, E, string>
-  <R, E>(self: Stream<R, E, Uint8Array>, encoding?: string): Stream<R, E, string>
+  (encoding?: string | undefined): <R, E>(self: Stream<Uint8Array, E, R>) => Stream<string, E, R>
+  <R, E>(self: Stream<Uint8Array, E, R>, encoding?: string | undefined): Stream<string, E, R>
 } = internal.decodeText
 
 /**
@@ -4659,4 +4561,4 @@ export const decodeText: {
  * @since 2.0.0
  * @category encoding
  */
-export const encodeText: <R, E>(self: Stream<R, E, string>) => Stream<R, E, Uint8Array> = internal.encodeText
+export const encodeText: <R, E>(self: Stream<string, E, R>) => Stream<Uint8Array, E, R> = internal.encodeText