effect 3.4.9 → 3.5.1

package/src/internal/stream.ts

@@ -31,7 +31,7 @@ import * as HaltStrategy from "../StreamHaltStrategy.js"
 import type * as Take from "../Take.js"
 import type * as Tracer from "../Tracer.js"
 import * as Tuple from "../Tuple.js"
-import type { NoInfer } from "../Types.js"
+import type { NoInfer, TupleOf } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as MergeStrategy from "./channel/mergeStrategy.js"
@@ -461,15 +461,39 @@ export const as = dual<
   <A, E, R, B>(self: Stream.Stream<A, E, R>, value: B) => Stream.Stream<B, E, R>
 >(2, <A, E, R, B>(self: Stream.Stream<A, E, R>, value: B): Stream.Stream<B, E, R> => map(self, () => value))
 
+const queueFromBufferOptions = <A, E>(
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
+): Effect.Effect<Queue.Queue<Take.Take<A, E>>> => {
+  if (bufferSize === "unbounded") {
+    return Queue.unbounded()
+  } else if (typeof bufferSize === "number" || bufferSize === undefined) {
+    return Queue.bounded(bufferSize ?? 16)
+  }
+  switch (bufferSize.strategy) {
+    case "dropping":
+      return Queue.dropping(bufferSize.bufferSize ?? 16)
+    case "sliding":
+      return Queue.sliding(bufferSize.bufferSize ?? 16)
+    default:
+      return Queue.bounded(bufferSize.bufferSize ?? 16)
+  }
+}
+
 /** @internal */
 export const _async = <A, E = never, R = never>(
   register: (
     emit: Emit.Emit<R, E, A, void>
   ) => Effect.Effect<void, never, R> | void,
-  outputBuffer = 16
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ): Stream.Stream<A, E, R> =>
   Effect.acquireRelease(
-    Queue.bounded<Take.Take<A, E>>(outputBuffer),
+    queueFromBufferOptions<A, E>(bufferSize),
     (queue) => Queue.shutdown(queue)
   ).pipe(
     Effect.flatMap((output) =>
@@ -518,11 +542,14 @@ export const _async = <A, E = never, R = never>(
 /** @internal */
 export const asyncEffect = <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>,
-  outputBuffer = 16
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ): Stream.Stream<A, E, R> =>
   pipe(
     Effect.acquireRelease(
-      Queue.bounded<Take.Take<A, E>>(outputBuffer),
+      queueFromBufferOptions<A, E>(bufferSize),
       (queue) => Queue.shutdown(queue)
     ),
     Effect.flatMap((output) =>
@@ -573,11 +600,14 @@ export const asyncEffect = <A, E = never, R = never>(
 /** @internal */
 export const asyncScoped = <A, E = never, R = never>(
   register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>,
-  outputBuffer = 16
+  bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
+  } | undefined
 ): Stream.Stream<A, E, Exclude<R, Scope.Scope>> =>
   pipe(
     Effect.acquireRelease(
-      Queue.bounded<Take.Take<A, E>>(outputBuffer),
+      queueFromBufferOptions<A, E>(bufferSize),
       (queue) => Queue.shutdown(queue)
     ),
     Effect.flatMap((output) =>
@@ -682,72 +712,128 @@ export const branchAfter = dual<
 export const broadcast = dual<
   <N extends number>(
     n: N,
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R>,
+  ) => Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R>,
   <A, E, R, N extends number>(
     self: Stream.Stream<A, E, R>,
     n: N,
-    maximumLag: number
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R>
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
+  ) => Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R>
 >(3, <A, E, R, N extends number>(
   self: Stream.Stream<A, E, R>,
   n: N,
-  maximumLag: number
-): Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R> =>
+  maximumLag: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
+): Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R> =>
   pipe(
     self,
     broadcastedQueues(n, maximumLag),
     Effect.map((tuple) =>
-      tuple.map((queue) => flattenTake(fromQueue(queue, { shutdown: true }))) as Stream.Stream.DynamicTuple<
-        Stream.Stream<A, E>,
-        N
-      >
+      tuple.map((queue) => flattenTake(fromQueue(queue, { shutdown: true }))) as TupleOf<N, Stream.Stream<A, E>>
     )
   ))
 
 /** @internal */
 export const broadcastDynamic = dual<
   (
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<Stream.Stream<A, E>, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => Effect.Effect<Stream.Stream<A, E>, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
-  maximumLag: number
+  maximumLag: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
 ): Effect.Effect<Stream.Stream<A, E>, never, Scope.Scope | R> =>
-  pipe(
-    self,
-    broadcastedQueuesDynamic(maximumLag),
-    Effect.map((effect) => flattenTake(flatMap(scoped(effect), fromQueue)))
-  ))
+  Effect.map(toPubSub(self, maximumLag), (pubsub) => flattenTake(fromPubSub(pubsub))))
 
 /** @internal */
 export const broadcastedQueues = dual<
   <N extends number>(
     n: N,
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>,
+  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>,
   <A, E, R, N extends number>(
     self: Stream.Stream<A, E, R>,
     n: N,
-    maximumLag: number
-  ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
+  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
 >(3, <A, E, R, N extends number>(
   self: Stream.Stream<A, E, R>,
   n: N,
-  maximumLag: number
-): Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R> =>
-  Effect.flatMap(PubSub.bounded<Take.Take<A, E>>(maximumLag), (pubsub) =>
+  maximumLag: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
+): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R> =>
+  Effect.flatMap(pubsubFromOptions(maximumLag), (pubsub) =>
     pipe(
       Effect.all(Array.from({ length: n }, () => PubSub.subscribe(pubsub))) as Effect.Effect<
-        Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>,
+        TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>,
         never,
         R
       >,
@@ -757,17 +843,38 @@ export const broadcastedQueues = dual<
 /** @internal */
 export const broadcastedQueuesDynamic = dual<
   (
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => <A, E, R>(
     self: Stream.Stream<A, E, R>
   ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
-    maximumLag: number
+    maximumLag: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
-  maximumLag: number
+  maximumLag: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
 ): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R> =>
   Effect.map(toPubSub(self, maximumLag), PubSub.subscribe))
 
@@ -1764,7 +1871,7 @@ export const distributedWith = dual<
   ) => <E, R>(
     self: Stream.Stream<A, E, R>
   ) => Effect.Effect<
-    Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+    TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
     never,
     Scope.Scope | R
   >,
@@ -1776,7 +1883,7 @@ export const distributedWith = dual<
       readonly decide: (a: A) => Effect.Effect<Predicate<number>>
     }
   ) => Effect.Effect<
-    Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+    TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
     never,
     Scope.Scope | R
   >
@@ -1790,7 +1897,7 @@ export const distributedWith = dual<
       readonly decide: (a: A) => Effect.Effect<Predicate<number>>
     }
   ): Effect.Effect<
-    Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+    TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
     never,
     Scope.Scope | R
   > =>
@@ -1829,7 +1936,7 @@ export const distributedWith = dual<
                   Deferred.succeed(deferred, (a: A) =>
                     Effect.map(options.decide(a), (f) => (key: number) => pipe(f(mappings.get(key)!)))),
                   Effect.as(
-                    Array.from(queues) as Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>
+                    Array.from(queues) as TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>
                   )
                 )
               })
@@ -3921,36 +4028,36 @@ export const mergeEither = dual<
 
 /** @internal */
 export const mergeLeft = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A, E2 | E, R2 | R>
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ) => <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AL, ER | EL, RR | RL>,
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ) => Stream.Stream<AL, ER | EL, RR | RL>
 >(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A, E | E2, R | R2> => pipe(self, merge(drain(that)))
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AL, EL | ER, RL | RR> => pipe(left, merge(drain(right)))
 )
 
 /** @internal */
 export const mergeRight = dual<
-  <A2, E2, R2>(
-    that: Stream.Stream<A2, E2, R2>
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A2, E2 | E, R2 | R>,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ) => Stream.Stream<A2, E2 | E, R2 | R>
+  <AR, ER, RR>(
+    right: Stream.Stream<AR, ER, RR>
+  ) => <AL, EL, RL>(left: Stream.Stream<AL, EL, RL>) => Stream.Stream<AR, ER | EL, RR | RL>,
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ) => Stream.Stream<AR, ER | EL, RR | RL>
 >(
   2,
-  <A, E, R, A2, E2, R2>(
-    self: Stream.Stream<A, E, R>,
-    that: Stream.Stream<A2, E2, R2>
-  ): Stream.Stream<A2, E | E2, R | R2> => pipe(drain(self), merge(that))
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream.Stream<AL, EL, RL>,
+    right: Stream.Stream<AR, ER, RR>
+  ): Stream.Stream<AR, EL | ER, RL | RR> => pipe(drain(left), merge(right))
 )
 
 /** @internal */
@@ -4686,6 +4793,40 @@ export const range = (min: number, max: number, chunkSize = DefaultChunkSize): S
     return new StreamImpl(go(min, max, chunkSize))
   })
 
+export const raceAll = <S extends ReadonlyArray<Stream.Stream<any, any, any>>>(
+  ...streams: S
+): Stream.Stream<
+  Stream.Stream.Success<S[number]>,
+  Stream.Stream.Error<S[number]>,
+  Stream.Stream.Context<S[number]>
+> =>
+  Deferred.make<void>().pipe(
+    Effect.map((halt) => {
+      let winner: number | null = null
+      return mergeAll(
+        streams.map((stream, index) =>
+          stream.pipe(
+            takeWhile(() => {
+              if (winner === null) {
+                winner = index
+                Deferred.unsafeDone(halt, Exit.void)
+                return true
+              }
+              return winner === index
+            }),
+            interruptWhen(
+              Deferred.await(halt).pipe(
+                Effect.flatMap(() => winner === index ? Effect.never : Effect.void)
+              )
+            )
+          )
+        ),
+        { concurrency: streams.length }
+      )
+    }),
+    unwrap
+  )
+
 /** @internal */
 export const rechunk = dual<
   (n: number) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>,
@@ -5097,37 +5238,44 @@ export const retry = dual<
 export const run = dual<
   <A2, A, E2, R2>(
     sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<A2, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, A2, E2, R2>(
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ) => Effect.Effect<A2, E2 | E, R2 | R>
+  ) => Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(2, <A, E, R, A2, E2, R2>(
   self: Stream.Stream<A, E, R>,
   sink: Sink.Sink<A2, A, unknown, E2, R2>
-): Effect.Effect<A2, E2 | E, R2 | R> =>
+): Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>> =>
   pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink)), channel.runDrain))
 
 /** @internal */
-export const runCollect = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Chunk.Chunk<A>, E, R> =>
-  pipe(self, run(_sink.collectAll()))
+export const runCollect = <A, E, R>(
+  self: Stream.Stream<A, E, R>
+): Effect.Effect<Chunk.Chunk<A>, E, Exclude<R, Scope.Scope>> => pipe(self, run(_sink.collectAll()))
 
 /** @internal */
-export const runCount = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<number, E, R> =>
+export const runCount = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<number, E, Exclude<R, Scope.Scope>> =>
   pipe(self, run(_sink.count))
 
 /** @internal */
-export const runDrain = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<void, E, R> =>
+export const runDrain = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<void, E, Exclude<R, Scope.Scope>> =>
   pipe(self, run(_sink.drain))
 
 /** @internal */
 export const runFold = dual<
-  <S, A>(s: S, f: (s: S, a: A) => S) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E, R>,
-  <A, E, R, S>(self: Stream.Stream<A, E, R>, s: S, f: (s: S, a: A) => S) => Effect.Effect<S, E, R>
+  <S, A>(
+    s: S,
+    f: (s: S, a: A) => S
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>,
+  <A, E, R, S>(self: Stream.Stream<A, E, R>, s: S, f: (s: S, a: A) => S) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
 >(
   3,
-  <A, E, R, S>(self: Stream.Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R> =>
-    pipe(self, runFoldWhileScoped(s, constTrue, f), Effect.scoped)
+  <A, E, R, S>(
+    self: Stream.Stream<A, E, R>,
+    s: S,
+    f: (s: S, a: A) => S
+  ): Effect.Effect<S, E, Exclude<R, Scope.Scope>> => pipe(self, runFoldWhileScoped(s, constTrue, f), Effect.scoped)
 )
 
 /** @internal */
@@ -5135,17 +5283,18 @@ export const runFoldEffect = dual<
   <S, A, E2, R2>(
     s: S,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, S, E2, R2>(
     self: Stream.Stream<A, E, R>,
     s: S,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ) => Effect.Effect<S, E2 | E, R2 | R>
+  ) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(3, <A, E, R, S, E2, R2>(
   self: Stream.Stream<A, E, R>,
   s: S,
   f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-): Effect.Effect<S, E2 | E, R2 | R> => pipe(self, runFoldWhileScopedEffect(s, constTrue, f), Effect.scoped))
+): Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>> =>
+  pipe(self, runFoldWhileScopedEffect(s, constTrue, f), Effect.scoped))
 
 /** @internal */
 export const runFoldScoped = dual<
@@ -5180,14 +5329,19 @@ export const runFoldWhile = dual<
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => S
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E, R>,
-  <A, E, R, S>(self: Stream.Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S) => Effect.Effect<S, E, R>
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>,
+  <A, E, R, S>(
+    self: Stream.Stream<A, E, R>,
+    s: S,
+    cont: Predicate<S>,
+    f: (s: S, a: A) => S
+  ) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>
 >(4, <A, E, R, S>(
   self: Stream.Stream<A, E, R>,
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => S
-): Effect.Effect<S, E, R> => pipe(self, runFoldWhileScoped(s, cont, f), Effect.scoped))
+): Effect.Effect<S, E, Exclude<R, Scope.Scope>> => pipe(self, runFoldWhileScoped(s, cont, f), Effect.scoped))
 
 /** @internal */
 export const runFoldWhileEffect = dual<
@@ -5195,19 +5349,20 @@ export const runFoldWhileEffect = dual<
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, S, E2, R2>(
     self: Stream.Stream<A, E, R>,
     s: S,
     cont: Predicate<S>,
     f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-  ) => Effect.Effect<S, E2 | E, R2 | R>
+  ) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(4, <A, E, R, S, E2, R2>(
   self: Stream.Stream<A, E, R>,
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-): Effect.Effect<S, E2 | E, R2 | R> => pipe(self, runFoldWhileScopedEffect(s, cont, f), Effect.scoped))
+): Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>> =>
+  pipe(self, runFoldWhileScopedEffect(s, cont, f), Effect.scoped))
 
 /** @internal */
 export const runFoldWhileScoped = dual<
@@ -5253,29 +5408,29 @@ export const runFoldWhileScopedEffect = dual<
 export const runForEach = dual<
   <A, X, E2, R2>(
     f: (a: A) => Effect.Effect<X, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, X, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<X, E2, R2>
-  ) => Effect.Effect<void, E2 | E, R2 | R>
+  ) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, R2 | R> => pipe(self, run(_sink.forEach(f))))
+): Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>> => pipe(self, run(_sink.forEach(f))))
 
 /** @internal */
 export const runForEachChunk = dual<
   <A, X, E2, R2>(
     f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, X, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-  ) => Effect.Effect<void, E2 | E, R2 | R>
+  ) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, R2 | R> => pipe(self, run(_sink.forEachChunk(f))))
+): Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>> => pipe(self, run(_sink.forEachChunk(f))))
 
 /** @internal */
 export const runForEachChunkScoped = dual<
@@ -5309,15 +5464,15 @@ export const runForEachScoped = dual<
 export const runForEachWhile = dual<
   <A, E2, R2>(
     f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, R2 | R>,
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>,
   <A, E, R, E2, R2>(
     self: Stream.Stream<A, E, R>,
     f: (a: A) => Effect.Effect<boolean, E2, R2>
-  ) => Effect.Effect<void, E2 | E, R2 | R>
+  ) => Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>>
 >(2, <A, E, R, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<boolean, E2, R2>
-): Effect.Effect<void, E2 | E, R2 | R> => pipe(self, run(_sink.forEachWhile(f))))
+): Effect.Effect<void, E2 | E, Exclude<R | R2, Scope.Scope>> => pipe(self, run(_sink.forEachWhile(f))))
 
 /** @internal */
 export const runForEachWhileScoped = dual<
@@ -5334,17 +5489,25 @@ export const runForEachWhileScoped = dual<
 ): Effect.Effect<void, E2 | E, R2 | R | Scope.Scope> => pipe(self, runScoped(_sink.forEachWhile(f))))
 
 /** @internal */
-export const runHead = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
-  pipe(self, run(_sink.head<A>()))
+export const runHead = <A, E, R>(
+  self: Stream.Stream<A, E, R>
+): Effect.Effect<Option.Option<A>, E, Exclude<R, Scope.Scope>> => pipe(self, run(_sink.head<A>()))
 
 /** @internal */
 export const runIntoPubSub = dual<
-  <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
-  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>) => Effect.Effect<void, never, R>
+  <A, E>(
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
+  ) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, Exclude<R, Scope.Scope>>,
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
+  ) => Effect.Effect<void, never, Exclude<R, Scope.Scope>>
 >(
   2,
-  <A, E, R>(self: Stream.Stream<A, E, R>, pubsub: PubSub.PubSub<Take.Take<A, E>>): Effect.Effect<void, never, R> =>
-    pipe(self, runIntoQueue(pubsub))
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    pubsub: PubSub.PubSub<Take.Take<A, E>>
+  ): Effect.Effect<void, never, Exclude<R, Scope.Scope>> => pipe(self, runIntoQueue(pubsub))
 )
 
 /** @internal */
@@ -5363,12 +5526,19 @@ export const runIntoPubSubScoped = dual<
 
 /** @internal */
 export const runIntoQueue = dual<
-  <A, E>(queue: Queue.Enqueue<Take.Take<A, E>>) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R>,
-  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>) => Effect.Effect<void, never, R>
+  <A, E>(
+    queue: Queue.Enqueue<Take.Take<A, E>>
+  ) => <R>(self: Stream.Stream<A, E, R>) => Effect.Effect<void, never, Exclude<R, Scope.Scope>>,
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    queue: Queue.Enqueue<Take.Take<A, E>>
+  ) => Effect.Effect<void, never, Exclude<R, Scope.Scope>>
 >(
   2,
-  <A, E, R>(self: Stream.Stream<A, E, R>, queue: Queue.Enqueue<Take.Take<A, E>>): Effect.Effect<void, never, R> =>
-    pipe(self, runIntoQueueScoped(queue), Effect.scoped)
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    queue: Queue.Enqueue<Take.Take<A, E>>
+  ): Effect.Effect<void, never, Exclude<R, Scope.Scope>> => pipe(self, runIntoQueueScoped(queue), Effect.scoped)
 )
 
 /** @internal */
@@ -5431,8 +5601,9 @@ export const runIntoQueueScoped = dual<
 })
 
 /** @internal */
-export const runLast = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
-  pipe(self, run(_sink.last()))
+export const runLast = <A, E, R>(
+  self: Stream.Stream<A, E, R>
+): Effect.Effect<Option.Option<A>, E, Exclude<R, Scope.Scope>> => pipe(self, run(_sink.last()))
 
 /** @internal */
 export const runScoped = dual<
@@ -5455,7 +5626,7 @@ export const runScoped = dual<
   ))
 
 /** @internal */
-export const runSum = <E, R>(self: Stream.Stream<number, E, R>): Effect.Effect<number, E, R> =>
+export const runSum = <E, R>(self: Stream.Stream<number, E, R>): Effect.Effect<number, E, Exclude<R, Scope.Scope>> =>
   pipe(self, run(_sink.sum))
 
 /** @internal */
@@ -6435,24 +6606,67 @@ export const timeoutTo = dual<
   }
 )
 
+const pubsubFromOptions = <A, E>(
+  options: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
+): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>> => {
+  if (typeof options === "number") {
+    return PubSub.bounded(options)
+  } else if (options.capacity === "unbounded") {
+    return PubSub.unbounded({ replay: options.replay })
+  }
+  switch (options.strategy) {
+    case "dropping":
+      return PubSub.dropping(options)
+    case "sliding":
+      return PubSub.sliding(options)
+    default:
+      return PubSub.bounded(options)
+  }
+}
+
 /** @internal */
 export const toPubSub = dual<
   (
-    capacity: number
+    capacity: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>,
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
-    capacity: number
+    capacity: number | {
+      readonly capacity: "unbounded"
+      readonly replay?: number | undefined
+    } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
 >(2, <A, E, R>(
   self: Stream.Stream<A, E, R>,
-  capacity: number
+  capacity: number | {
+    readonly capacity: "unbounded"
+    readonly replay?: number | undefined
+  } | {
+    readonly capacity: number
+    readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+    readonly replay?: number | undefined
+  }
 ): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R> =>
   pipe(
-    Effect.acquireRelease(
-      PubSub.bounded<Take.Take<A, E>>(capacity),
-      (pubsub) => PubSub.shutdown(pubsub)
-    ),
+    Effect.acquireRelease(pubsubFromOptions<A, E>(capacity), (pubsub) => PubSub.shutdown(pubsub)),
     Effect.tap((pubsub) => pipe(self, runIntoPubSubScoped(pubsub), Effect.forkScoped))
   ))