effect 4.0.0-beta.6 → 4.0.0-beta.60

package/dist/Stream.d.ts

@@ -4,15 +4,16 @@
 import * as Arr from "./Array.ts";
 import * as Cause from "./Cause.ts";
 import * as Channel from "./Channel.ts";
+import * as Context from "./Context.ts";
 import * as Duration from "./Duration.ts";
 import * as Effect from "./Effect.ts";
 import * as ExecutionPlan from "./ExecutionPlan.ts";
 import * as Exit from "./Exit.ts";
-import * as Filter from "./Filter.ts";
+import type * as Filter from "./Filter.ts";
 import type { LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.ts";
 import type * as Layer from "./Layer.ts";
-import type { LogLevel } from "./LogLevel.ts";
+import type { Severity } from "./LogLevel.ts";
 import * as Option from "./Option.ts";
 import type { Pipeable } from "./Pipeable.ts";
 import type { Predicate, Refinement } from "./Predicate.ts";
@@ -22,13 +23,21 @@ import * as Queue from "./Queue.ts";
 import * as Result from "./Result.ts";
 import * as Schedule from "./Schedule.ts";
 import * as Scope from "./Scope.ts";
-import * as ServiceMap from "./ServiceMap.ts";
 import * as Sink from "./Sink.ts";
 import type * as Take from "./Take.ts";
 import type { ParentSpan, SpanOptions } from "./Tracer.ts";
-import type { Covariant, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NoInfer, ReasonTags, Tags, unassigned } from "./Types.ts";
+import type { Covariant, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NarrowReason, NoInfer, OmitReason, ReasonTags, Tags, unassigned } from "./Types.ts";
 import type * as Unify from "./Unify.ts";
-declare const TypeId = "~effect/Stream";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type TypeId = "~effect/Stream";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export declare const TypeId: TypeId;
 /**
  * A `Stream<A, E, R>` describes a program that can emit many `A` values, fail
  * with `E`, and require `R`.
@@ -102,7 +111,7 @@ export interface StreamUnify<A extends {
  * @category Models
  * @since 2.0.0
  */
-export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
+export interface StreamUnifyIgnore {
     Effect?: true;
 }
 /**
@@ -298,6 +307,76 @@ export declare const fromChannel: <Arr extends Arr.NonEmptyReadonlyArray<any>, E
  * @category Constructors
  */
 export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R>;
+/**
+ * Accesses a service from the context and emits it as a single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.service(Greeter).pipe(
+ *   Stream.map((greeter) => greeter.greet("World"))
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export declare const service: <I, S>(service: Context.Key<I, S>) => Stream<S, never, I>;
+/**
+ * Optionally accesses a service from the context and emits the result as a
+ * single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.serviceOption(Greeter).pipe(
+ *   Stream.map((maybeGreeter) =>
+ *     Option.match(maybeGreeter, {
+ *       onNone: () => "No greeter",
+ *       onSome: (greeter) => greeter.greet("World")
+ *     })
+ *   )
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export declare const serviceOption: <I, S>(service: Context.Key<I, S>) => Stream<Option.Option<S>>;
 /**
  * Creates a stream that runs the effect and emits no elements.
  *
@@ -401,7 +480,7 @@ export declare const fromEffectSchedule: <A, E, R, X, AS extends A, ES, RS>(effe
  * @since 2.0.0
  * @category Constructors
  */
-export declare const tick: (interval: Duration.DurationInput) => Stream<void>;
+export declare const tick: (interval: Duration.Input) => Stream<void>;
 /**
  * Creates a stream from a pull effect, such as one produced by `Stream.toPull`.
  *
@@ -823,6 +902,10 @@ export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, max
 /**
  * Creates a new `Stream` from an iterable collection of values.
  *
+ * **Options**
+ *
+ * - `chunkSize`: Maximum number of values emitted per chunk.
+ *
  * @example
  * ```ts
  * import { Console, Effect, Stream } from "effect"
@@ -842,15 +925,17 @@ export declare const fromIteratorSucceed: <A>(iterator: IterableIterator<A>, max
  * @since 2.0.0
  * @category Constructors
  */
-export declare const fromIterable: <A>(iterable: Iterable<A>) => Stream<A>;
+export declare const fromIterable: <A>(iterable: Iterable<A>, options?: {
+    readonly chunkSize?: number | undefined;
+}) => Stream<A>;
 /**
  * Creates a stream from an effect producing an iterable of values.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class UserRepo extends ServiceMap.Service<UserRepo, {
+ * class UserRepo extends Context.Service<UserRepo, {
  *   readonly list: Effect.Effect<ReadonlyArray<string>>
  * }>()("UserRepo") {}
  *
@@ -1083,7 +1168,9 @@ export declare const fromPubSubTake: <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const readableStream = new ReadableStream({
  *   start(controller) {
@@ -1097,7 +1184,7 @@ export declare const fromPubSubTake: <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E
  * const program = Effect.gen(function*() {
  *   const stream = Stream.fromReadableStream({
  *     evaluate: () => readableStream,
- *     onError: (error) => new Error(String(error))
+ *     onError: (cause) => new StreamError({ cause })
  *   })
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
@@ -1120,7 +1207,9 @@ export declare const fromReadableStream: <A, E>(options: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Data, Effect, Stream } from "effect"
+ *
+ * class StreamError extends Data.TaggedError("StreamError")<{ readonly cause: unknown }> {}
  *
  * const iterable = (async function*() {
  *   yield 1
@@ -1129,7 +1218,7 @@ export declare const fromReadableStream: <A, E>(options: {
  * })()
  *
  * const program = Effect.gen(function*() {
- *   const stream = Stream.fromAsyncIterable(iterable, (error) => new Error(String(error)))
+ *   const stream = Stream.fromAsyncIterable(iterable, (cause) => new StreamError({ cause }))
  *   const values = yield* Stream.runCollect(stream)
  *   yield* Console.log(values)
  * })
@@ -1152,7 +1241,7 @@ export declare const fromAsyncIterable: <A, E>(iterable: AsyncIterable<A>, onErr
  *
  * const program = Effect.gen(function*() {
  *   const schedule = Schedule.spaced("50 millis").pipe(
- *     Schedule.compose(Schedule.recurs(2))
+ *     Schedule.both(Schedule.recurs(2))
  *   )
  *   const stream = Stream.fromSchedule(schedule)
  *   const values = yield* Stream.runCollect(stream)
@@ -2767,7 +2856,7 @@ export declare const timeout: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Ends the stream if it does not produce a value within the specified duration.
      *
@@ -2791,7 +2880,29 @@ export declare const timeout: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
+};
+/**
+ * @since 2.0.0
+ * @category Rate Limiting
+ */
+export declare const timeoutOrElse: {
+    /**
+     * @since 2.0.0
+     * @category Rate Limiting
+     */
+    <B, E2, R2>(options: {
+        readonly duration: Duration.Input;
+        readonly orElse: () => Stream<B, E2, R2>;
+    }): <A, E, R>(self: Stream<A, E, R>) => Stream<A | B, E | E2, R | R2>;
+    /**
+     * @since 2.0.0
+     * @category Rate Limiting
+     */
+    <A, E, R, B, E2, R2>(self: Stream<A, E, R>, options: {
+        readonly duration: Duration.Input;
+        readonly orElse: () => Stream<B, E2, R2>;
+    }): Stream<A | B, E | E2, R | R2>;
 };
 /**
  * Repeats each element of the stream according to the provided schedule,
@@ -4775,7 +4886,7 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>): <E, R>(self: Stream<A, E, R>) => Stream<Filter.Pass<A, Result>, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Filters a stream to the elements that satisfy a predicate.
      *
@@ -4821,20 +4932,38 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>): Stream<Filter.Pass<A, Result>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMap: {
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<A, B, X>): Stream<B, E, R>;
+};
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -4842,7 +4971,7 @@ export declare const filter: {
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
@@ -4850,17 +4979,13 @@ export declare const filter: {
  */
 export declare const filterEffect: {
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4868,25 +4993,21 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    <A, EX, RX>(predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<A, E | EX, R | RX>;
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4894,28 +5015,48 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
+    <A, E, R, EX, RX>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): Stream<A, E | EX, R | RX>;
+};
+/**
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMapEffect: {
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
     <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>): Stream<B, E | EX, R | RX>;
 };
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -4935,56 +5076,17 @@ export declare const filterEffect: {
  */
 export declare const partitionQueue: {
     /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
-     *
-     * Each queue fails with the stream error or `Cause.Done` when the source ends.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
-     *   )
-     *
-     *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
-     *   const failValues = yield* Stream.fromQueue(fails).pipe(Stream.runCollect)
-     *
-     *   yield* Console.log(passValues)
-     *   // Output: [ 2, 4 ]
-     *   yield* Console.log(failValues)
-     *   // Output: [ 1, 3 ]
-     * })
-     *
-     * Effect.runPromise(Effect.scoped(program))
-     * ```
-     *
-     * @since 4.0.0
-     * @category Filtering
-     */
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, options?: {
-        readonly capacity?: number | "unbounded" | undefined;
-    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Queue.Dequeue<B, E | Cause.Done>,
-        fails: Queue.Dequeue<Exclude<A, B>, E | Cause.Done>
-    ], never, R | Scope.Scope>;
-    /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
+     * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
      *
      * Each queue fails with the stream error or `Cause.Done` when the source ends.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
+     *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
      *   )
      *
      *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -5002,63 +5104,24 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
-    ], never, R | Scope.Scope>;
-    /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
-     *
-     * Each queue fails with the stream error or `Cause.Done` when the source ends.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
-     *   )
-     *
-     *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
-     *   const failValues = yield* Stream.fromQueue(fails).pipe(Stream.runCollect)
-     *
-     *   yield* Console.log(passValues)
-     *   // Output: [ 2, 4 ]
-     *   yield* Console.log(failValues)
-     *   // Output: [ 1, 3 ]
-     * })
-     *
-     * Effect.runPromise(Effect.scoped(program))
-     * ```
-     *
-     * @since 4.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>, options?: {
-        readonly capacity?: number | "unbounded" | undefined;
-    }): Effect.Effect<[
-        passes: Queue.Dequeue<B, E | Cause.Done>,
-        fails: Queue.Dequeue<Exclude<A, B>, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
     ], never, R | Scope.Scope>;
     /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
+     * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
      *
      * Each queue fails with the stream error or `Cause.Done` when the source ends.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
+     *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
      *   )
      *
      *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -5076,119 +5139,49 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
     ], never, R | Scope.Scope>;
 };
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
 export declare const partitionEffect: {
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, Pass, Fail, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, E, R, Pass, Fail, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
 };
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -5198,12 +5191,12 @@ export declare const partitionEffect: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -5216,42 +5209,7 @@ export declare const partitionEffect: {
  */
 export declare const partition: {
     /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
-     *
-     * The faster stream may advance up to `bufferSize` elements ahead of the slower
-     * one.
-     *
-     * @since 4.0.0
-     * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [excluded, satisfying] = yield* Stream.partition(
-     *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
-     *   )
-     *   const left = yield* Stream.runCollect(excluded)
-     *   const right = yield* Stream.runCollect(satisfying)
-     *   yield* Console.log(left)
-     *   // Output: [ 1, 3 ]
-     *   yield* Console.log(right)
-     *   // Output: [ 2, 4 ]
-     * })
-     * ```
-     */
-    <C extends A, B extends A, A = C>(refinement: Refinement<NoInfer<A>, B>, options?: {
-        readonly bufferSize?: number | undefined;
-    }): <E, R>(self: Stream<C, E, R>) => Effect.Effect<[
-        excluded: Stream<Exclude<C, B>, E>,
-        satisfying: Stream<B, E>
-    ], never, R | Scope.Scope>;
-    /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
+     * Splits a stream into excluded and satisfying substreams using a `Filter`.
      *
      * The faster stream may advance up to `bufferSize` elements ahead of the slower
      * one.
@@ -5261,12 +5219,12 @@ export declare const partition: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5277,49 +5235,14 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
-    ], never, R | Scope.Scope>;
-    /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
-     *
-     * The faster stream may advance up to `bufferSize` elements ahead of the slower
-     * one.
-     *
-     * @since 4.0.0
-     * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [excluded, satisfying] = yield* Stream.partition(
-     *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
-     *   )
-     *   const left = yield* Stream.runCollect(excluded)
-     *   const right = yield* Stream.runCollect(satisfying)
-     *   yield* Console.log(left)
-     *   // Output: [ 1, 3 ]
-     *   yield* Console.log(right)
-     *   // Output: [ 2, 4 ]
-     * })
-     * ```
-     */
-    <C extends A, E, R, B extends A, A = C>(self: Stream<C, E, R>, refinement: Refinement<A, B>, options?: {
-        readonly bufferSize?: number | undefined;
-    }): Effect.Effect<[
-        excluded: Stream<Exclude<C, B>, E>,
-        satisfying: Stream<B, E>
+        excluded: Stream<Fail, E>,
+        satisfying: Stream<Pass, E>
     ], never, R | Scope.Scope>;
     /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
+     * Splits a stream into excluded and satisfying substreams using a `Filter`.
      *
      * The faster stream may advance up to `bufferSize` elements ahead of the slower
      * one.
@@ -5329,12 +5252,12 @@ export declare const partition: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5345,11 +5268,11 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
+        excluded: Stream<Fail, E>,
+        satisfying: Stream<Pass, E>
     ], never, R | Scope.Scope>;
 };
 /**
@@ -6043,7 +5966,7 @@ export declare const tapError: {
     <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -6057,12 +5980,12 @@ export declare const tapError: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -6081,7 +6004,7 @@ export declare const tapError: {
  */
 export declare const catchIf: {
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6095,12 +6018,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6119,7 +6042,7 @@ export declare const catchIf: {
      */
     <E, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6133,12 +6056,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6155,9 +6078,9 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Stream<A2, E2, R2>, orElse?: ((e: NoInfer<E>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6171,12 +6094,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6195,7 +6118,7 @@ export declare const catchIf: {
      */
     <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(self: Stream<A, E, R>, refinement: Refinement<E, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6209,12 +6132,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6231,7 +6154,32 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(self: Stream<A, E, R>, predicate: Predicate<E>, f: (e: E) => Stream<A2, E2, R2>, orElse?: ((e: E) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+};
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchFilter: {
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
 };
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
@@ -6567,7 +6515,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
+    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>, error: OmitReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
     /**
      * Catches a specific reason within a tagged error.
      *
@@ -6611,7 +6559,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: Stream<A, E, R>, errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<E, K>, RK>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
+    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: Stream<A, E, R>, errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: NarrowReason<ExtractTag<E, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<E, K>, RK>, error: OmitReason<ExtractTag<E, K>, RK>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
 };
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
@@ -6697,8 +6645,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <K extends Tags<E>, E, Cases extends {
-        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | {
+        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<any, any, any>;
+    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<any, infer E, any> ? E : never;
@@ -6747,8 +6695,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <A, E, R, K extends Tags<E>, Cases extends {
-        [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Stream<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | {
+        [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: NarrowReason<ExtractTag<E, K>, RK>) => Stream<any, any, any>;
+    }, A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<any, infer E, any> ? E : never;
@@ -6896,7 +6844,7 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, A2, E2, R2>(filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R2 | R>;
+    <E, A2, E2, R2>(predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, E | E2, R2 | R>;
     /**
      * Recovers from stream failures by filtering the `Cause` and switching to a recovery stream.
      * Non-matching causes are re-emitted as failures.
@@ -6930,7 +6878,32 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, A2, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(self: Stream<A, E, R>, filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+};
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchCauseFilter: {
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X extends Cause.Cause<any>>(filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<X> | E2, R2 | R>;
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X extends Cause.Cause<any>>(self: Stream<A, E, R>, filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<X> | E2, R | R2>;
 };
 /**
  * Switches to a fallback stream if this stream is empty.
@@ -7134,9 +7107,9 @@ export declare const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never,
  * @category Error Handling
  */
 export declare const ignore: <Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined>(selfOrOptions: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R> : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
  * Ignores the stream's failure cause, including defects, and ends the stream.
@@ -7159,9 +7132,9 @@ export declare const ignore: <Arg extends Stream<any, any, any> | {
  * @category Error Handling
  */
 export declare const ignoreCause: <Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined>(streamOrOptions: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R> : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
  * When the stream fails, retry it according to the given schedule.
@@ -7270,9 +7243,9 @@ export declare const retry: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
  *
- * class Service extends ServiceMap.Service<Service>()("Service", {
+ * class Service extends Context.Service<Service>()("Service", {
  *   make: Effect.succeed({
  *     stream: Stream.fail("A") as Stream.Stream<number, string>
  *   })
@@ -7312,9 +7285,9 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
      *
-     * class Service extends ServiceMap.Service<Service>()("Service", {
+     * class Service extends Context.Service<Service>()("Service", {
      *   make: Effect.succeed({
      *     stream: Stream.fail("A") as Stream.Stream<number, string>
      *   })
@@ -7361,9 +7334,9 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
      *
-     * class Service extends ServiceMap.Service<Service>()("Service", {
+     * class Service extends Context.Service<Service>()("Service", {
      *   make: Effect.succeed({
      *     stream: Stream.fail("A") as Stream.Stream<number, string>
      *   })
@@ -7811,7 +7784,7 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
     /**
      * Takes the longest initial prefix of elements that satisfy the predicate.
      *
@@ -7835,52 +7808,26 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, n: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const takeWhileFilter: {
     /**
-     * Takes the longest initial prefix of elements that satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const stream = Stream.range(1, 5).pipe(
-     *   Stream.takeWhile((n) => n % 3 !== 0)
-     * )
-     *
-     * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(stream)
-     *   yield* Console.log(result)
-     * })
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, n: number) => boolean): Stream<A, E, R>;
+    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
     /**
-     * Takes the longest initial prefix of elements that satisfy the predicate.
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const stream = Stream.range(1, 5).pipe(
-     *   Stream.takeWhile((n) => n % 3 !== 0)
-     * )
-     *
-     * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(stream)
-     *   yield* Console.log(result)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
     <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<B, E, R>;
@@ -8236,53 +8183,29 @@ export declare const dropWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const dropWhileFilter: {
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
+     * Drops elements while the filter succeeds.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
+     * Drops elements while the filter succeeds.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
 };
 /**
  * Drops elements while the specified effectful predicate evaluates to `true`.
@@ -9557,7 +9480,7 @@ export declare const debounce: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Drops earlier elements within the debounce window and emits only the latest element after the pause.
      *
@@ -9581,7 +9504,7 @@ export declare const debounce: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
 };
 /**
  * Delays the arrays of this stream according to the given bandwidth
@@ -9659,7 +9582,7 @@ export declare const throttleEffect: {
     <A, E2, R2>(options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
@@ -9702,7 +9625,7 @@ export declare const throttleEffect: {
     <A, E, R, E2, R2>(self: Stream<A, E, R>, options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): Stream<A, E | E2, R | R2>;
@@ -9781,7 +9704,7 @@ export declare const throttle: {
     <A>(options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
@@ -9823,7 +9746,7 @@ export declare const throttle: {
     <A, E, R>(self: Stream<A, E, R>, options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): Stream<A, E, R>;
@@ -9951,7 +9874,7 @@ export declare const groupedWithin: {
      * @since 2.0.0
      * @category Grouping
      */
-    (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>;
+    (chunkSize: number, duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>;
     /**
      * Partitions the stream into arrays, emitting when the chunk size is reached
      * or the duration passes.
@@ -9975,7 +9898,7 @@ export declare const groupedWithin: {
      * @since 2.0.0
      * @category Grouping
      */
-    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Array<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.Input): Stream<Array<A>, E, R>;
 };
 /**
  * Groups elements into keyed substreams using an effectful classifier.
@@ -10042,7 +9965,7 @@ export declare const groupBy: {
      */
     <A, K, V, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<V>], E | E2, R | R2>;
     /**
      * Groups elements into keyed substreams using an effectful classifier.
@@ -10077,7 +10000,7 @@ export declare const groupBy: {
      */
     <A, E, R, K, V, E2, R2>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Stream<readonly [K, Stream<V>], E | E2, R | R2>;
 };
 /**
@@ -10141,7 +10064,7 @@ export declare const groupByKey: {
      */
     <A, K>(f: (a: NoInfer<A>) => K, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<A>], E, R>;
     /**
      * Groups elements by a key and emits a stream per key.
@@ -10174,7 +10097,7 @@ export declare const groupByKey: {
      */
     <A, E, R, K>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => K, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Stream<readonly [K, Stream<A>], E, R>;
 };
 /**
@@ -10559,12 +10482,12 @@ export declare const share: {
     (options: {
         readonly capacity: "unbounded";
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     } | {
         readonly capacity: number;
         readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
     /**
      * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.
@@ -10600,12 +10523,12 @@ export declare const share: {
     <A, E, R>(self: Stream<A, E, R>, options: {
         readonly capacity: "unbounded";
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     } | {
         readonly capacity: number;
         readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
 };
 /**
@@ -12163,7 +12086,7 @@ export declare const ensuring: {
     <A, E, R, R2>(self: Stream<A, E, R>, finalizer: Effect.Effect<unknown, never, R2>): Stream<A, E, R | R2>;
 };
 /**
- * Provides a layer or service map to the stream, removing the corresponding
+ * Provides a layer or context to the stream, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
@@ -12171,9 +12094,9 @@ export declare const ensuring: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Layer, Context, Stream } from "effect"
  *
- * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+ * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
  *
  * const layer = Layer.succeed(Env)({ name: "Ada" })
  *
@@ -12200,7 +12123,7 @@ export declare const ensuring: {
  */
 export declare const provide: {
     /**
-     * Provides a layer or service map to the stream, removing the corresponding
+     * Provides a layer or context to the stream, removing the corresponding
      * service requirements. Use `options.local` to build the layer every time; by
      * default, layers are shared between provide calls.
      *
@@ -12208,9 +12131,9 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Layer, Context, Stream } from "effect"
      *
-     * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+     * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
      *
      * const layer = Layer.succeed(Env)({ name: "Ada" })
      *
@@ -12235,11 +12158,11 @@ export declare const provide: {
      * @since 4.0.0
      * @category Services
      */
-    <AL, EL = never, RL = never>(layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>, options?: {
+    <AL, EL = never, RL = never>(layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>, options?: {
         readonly local?: boolean | undefined;
     } | undefined): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | EL, Exclude<R, AL> | RL>;
     /**
-     * Provides a layer or service map to the stream, removing the corresponding
+     * Provides a layer or context to the stream, removing the corresponding
      * service requirements. Use `options.local` to build the layer every time; by
      * default, layers are shared between provide calls.
      *
@@ -12247,9 +12170,9 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Layer, Context, Stream } from "effect"
      *
-     * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+     * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
      *
      * const layer = Layer.succeed(Env)({ name: "Ada" })
      *
@@ -12274,22 +12197,22 @@ export declare const provide: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, AL, EL = never, RL = never>(self: Stream<A, E, R>, layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>, options?: {
+    <A, E, R, AL, EL = never, RL = never>(self: Stream<A, E, R>, layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>, options?: {
         readonly local?: boolean | undefined;
     } | undefined): Stream<A, E | EL, Exclude<R, AL> | RL>;
 };
 /**
- * Provides multiple services to the stream using a service map.
+ * Provides multiple services to the stream using a context.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
- * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+ * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+ * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
  *
- * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
- *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+ * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+ *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
  * )
  *
  * const stream = Stream.fromEffect(
@@ -12301,7 +12224,7 @@ export declare const provide: {
  * )
  *
  * const program = Effect.gen(function*() {
- *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+ *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
  *   yield* Console.log(result)
  * })
  *
@@ -12312,19 +12235,19 @@ export declare const provide: {
  * @since 4.0.0
  * @category Services
  */
-export declare const provideServices: {
+export declare const provideContext: {
     /**
-     * Provides multiple services to the stream using a service map.
+     * Provides multiple services to the stream using a context.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
-     * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+     * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+     * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
      *
-     * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
-     *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+     * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+     *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
      * )
      *
      * const stream = Stream.fromEffect(
@@ -12336,7 +12259,7 @@ export declare const provideServices: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+     *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
      *   yield* Console.log(result)
      * })
      *
@@ -12347,19 +12270,19 @@ export declare const provideServices: {
      * @since 4.0.0
      * @category Services
      */
-    <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, R2>>;
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, R2>>;
     /**
-     * Provides multiple services to the stream using a service map.
+     * Provides multiple services to the stream using a context.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
-     * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+     * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+     * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
      *
-     * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
-     *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+     * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+     *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
      * )
      *
      * const stream = Stream.fromEffect(
@@ -12371,7 +12294,7 @@ export declare const provideServices: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+     *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
      *   yield* Console.log(result)
      * })
      *
@@ -12382,7 +12305,7 @@ export declare const provideServices: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, R2>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<R2>): Stream<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(self: Stream<A, E, R>, context: Context.Context<R2>): Stream<A, E, Exclude<R, R2>>;
 };
 /**
  * Provides the stream with a single required service, eliminating that
@@ -12390,9 +12313,9 @@ export declare const provideServices: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Greeter extends ServiceMap.Service<Greeter, {
+ * class Greeter extends Context.Service<Greeter, {
  *   greet: (name: string) => string
  * }>()("Greeter") {}
  *
@@ -12427,9 +12350,9 @@ export declare const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Greeter extends ServiceMap.Service<Greeter, {
+     * class Greeter extends Context.Service<Greeter, {
      *   greet: (name: string) => string
      * }>()("Greeter") {}
      *
@@ -12457,16 +12380,16 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
+    <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
     /**
      * Provides the stream with a single required service, eliminating that
      * requirement from its environment.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Greeter extends ServiceMap.Service<Greeter, {
+     * class Greeter extends Context.Service<Greeter, {
      *   greet: (name: string) => string
      * }>()("Greeter") {}
      *
@@ -12494,16 +12417,16 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: Context.Key<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
 };
 /**
  * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+ * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -12540,9 +12463,9 @@ export declare const provideServiceEffect: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+     * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12573,15 +12496,15 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S, ES, RS>(key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
+    <I, S, ES, RS>(key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
     /**
      * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+     * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12612,18 +12535,18 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
+    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
 };
 /**
- * Transforms the stream's required services by mapping the current service map
+ * Transforms the stream's required services by mapping the current context
  * to a new one.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
- * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+ * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+ * class Config extends Context.Service<Config, { name: string }>()("Config") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -12634,8 +12557,8 @@ export declare const provideServiceEffect: {
  * )
  *
  * const updated = stream.pipe(
- *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
- *     ServiceMap.add(services, Config, { name: "World" })
+ *   Stream.updateContext((context: Context.Context<Logger>) =>
+ *     Context.add(context, Config, { name: "World" })
  *   )
  * )
  *
@@ -12653,17 +12576,17 @@ export declare const provideServiceEffect: {
  * @since 2.0.0
  * @category Services
  */
-export declare const updateServices: {
+export declare const updateContext: {
     /**
-     * Transforms the stream's required services by mapping the current service map
+     * Transforms the stream's required services by mapping the current context
      * to a new one.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
-     * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+     * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+     * class Config extends Context.Service<Config, { name: string }>()("Config") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12674,8 +12597,8 @@ export declare const updateServices: {
      * )
      *
      * const updated = stream.pipe(
-     *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Stream.updateContext((context: Context.Context<Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -12693,17 +12616,17 @@ export declare const updateServices: {
      * @since 2.0.0
      * @category Services
      */
-    <R, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R2>;
+    <R, R2>(f: (context: Context.Context<R2>) => Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R2>;
     /**
-     * Transforms the stream's required services by mapping the current service map
+     * Transforms the stream's required services by mapping the current context
      * to a new one.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
-     * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+     * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+     * class Config extends Context.Service<Config, { name: string }>()("Config") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12714,8 +12637,8 @@ export declare const updateServices: {
      * )
      *
      * const updated = stream.pipe(
-     *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Stream.updateContext((context: Context.Context<Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -12733,16 +12656,16 @@ export declare const updateServices: {
      * @since 2.0.0
      * @category Services
      */
-    <A, E, R, R2>(self: Stream<A, E, R>, f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): Stream<A, E, R2>;
+    <A, E, R, R2>(self: Stream<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<R>): Stream<A, E, R2>;
 };
 /**
  * Updates a single service in the stream environment by applying a function.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+ * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
  *
  * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
  *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12766,9 +12689,9 @@ export declare const updateService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+     * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
      *
      * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
      *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12786,15 +12709,15 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
+    <I, S>(key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
     /**
      * Updates a single service in the stream environment by applying a function.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+     * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
      *
      * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
      *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12812,7 +12735,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
 };
 /**
  * Wraps the stream with a new span for tracing.
@@ -13787,18 +13710,18 @@ export declare const mkUint8Array: <E, R>(self: Stream<Uint8Array, E, R>) => Eff
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3, 4, 5)
- * const readableStream = Stream.toReadableStreamWith(stream, ServiceMap.empty())
+ * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
  * ```
  *
  * @since 2.0.0
  * @category Destructors
  */
-export declare const toReadableStreamWith: (<A, XR>(services: ServiceMap.ServiceMap<XR>, options?: {
+export declare const toReadableStreamWith: (<A, XR>(context: Context.Context<XR>, options?: {
     readonly strategy?: QueuingStrategy<A> | undefined;
-}) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<XR>, options?: {
+}) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream<A, E, R>, context: Context.Context<XR>, options?: {
     readonly strategy?: QueuingStrategy<A> | undefined;
 }) => ReadableStream<A>);
 /**
@@ -13936,10 +13859,10 @@ export declare const toReadableStreamEffect: {
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3)
- * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+ * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
  *
  * const collect = async () => {
  *   const results: Array<number> = []
@@ -13959,10 +13882,10 @@ export declare const toAsyncIterableWith: {
      *
      * @example
      * ```ts
-     * import { ServiceMap, Stream } from "effect"
+     * import { Context, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2, 3)
-     * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+     * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
      *
      * const collect = async () => {
      *   const results: Array<number> = []
@@ -13976,16 +13899,16 @@ export declare const toAsyncIterableWith: {
      * @since 2.0.0
      * @category Destructors
      */
-    <XR>(services: ServiceMap.ServiceMap<XR>): <A, E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>;
+    <XR>(context: Context.Context<XR>): <A, E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>;
     /**
      * Converts the stream to an `AsyncIterable` using the provided services.
      *
      * @example
      * ```ts
-     * import { ServiceMap, Stream } from "effect"
+     * import { Context, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2, 3)
-     * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+     * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
      *
      * const collect = async () => {
      *   const results: Array<number> = []
@@ -13999,7 +13922,7 @@ export declare const toAsyncIterableWith: {
      * @since 2.0.0
      * @category Destructors
      */
-    <A, E, XR, R extends XR>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<XR>): AsyncIterable<A>;
+    <A, E, XR, R extends XR>(self: Stream<A, E, R>, context: Context.Context<XR>): AsyncIterable<A>;
 };
 /**
  * Creates an effect that yields an `AsyncIterable` using the current services.
@@ -14345,16 +14268,16 @@ export declare const toPubSubTake: {
     }): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, R | Scope.Scope>;
 };
 /**
- * Converts a stream to a PubSub for concurrent consumption.
+ * Converts a stream to a Queue for concurrent consumption.
  *
  * @example
  * ```ts
- * import { Effect, PubSub, Stream } from "effect"
+ * import { Effect, Queue, Stream } from "effect"
  *
  * const program = Effect.gen(function* () {
- *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
- *   const subscription = yield* PubSub.subscribe(pubSub)
- *   return subscription
+ *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+ *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+ *   return chunk
  * })
  * ```
  *
@@ -14363,16 +14286,16 @@ export declare const toPubSubTake: {
  */
 export declare const toQueue: {
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a Queue for concurrent consumption.
      *
      * @example
      * ```ts
-     * import { Effect, PubSub, Stream } from "effect"
+     * import { Effect, Queue, Stream } from "effect"
      *
      * const program = Effect.gen(function* () {
-     *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
-     *   const subscription = yield* PubSub.subscribe(pubSub)
-     *   return subscription
+     *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+     *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+     *   return chunk
      * })
      * ```
      *
@@ -14386,16 +14309,16 @@ export declare const toQueue: {
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope>;
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a Queue for concurrent consumption.
      *
      * @example
      * ```ts
-     * import { Effect, PubSub, Stream } from "effect"
+     * import { Effect, Queue, Stream } from "effect"
      *
      * const program = Effect.gen(function* () {
-     *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
-     *   const subscription = yield* PubSub.subscribe(pubSub)
-     *   return subscription
+     *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+     *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+     *   return chunk
      * })
      * ```
      *
@@ -14407,7 +14330,7 @@ export declare const toQueue: {
     } | {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope>;
+    }): Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope>;
 };
 /**
  * Runs the stream, offering each element to the provided queue and ending it