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

package/src/Stream.ts

@@ -6,13 +6,14 @@ import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Channel from "./Channel.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import * as ExecutionPlan from "./ExecutionPlan.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
-import * as Filter from "./Filter.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constTrue, constVoid, dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
@@ -22,7 +23,7 @@ import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
 import * as Latch from "./Latch.ts"
 import type * as Layer from "./Layer.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import * as MutableList from "./MutableList.ts"
 import * as Option from "./Option.ts"
@@ -37,7 +38,6 @@ import * as RcRef from "./RcRef.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 { isString } from "./String.ts"
 import type * as Take from "./Take.ts"
@@ -48,14 +48,26 @@ import type {
   ExcludeTag,
   ExtractReason,
   ExtractTag,
+  NarrowReason,
   NoInfer,
+  OmitReason,
   ReasonTags,
   Tags,
   unassigned
 } from "./Types.ts"
 import type * as Unify from "./Unify.ts"
 
-const TypeId = "~effect/Stream"
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type TypeId = "~effect/Stream"
+
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId: TypeId = "~effect/Stream"
 
 /**
  * A `Stream<A, E, R>` describes a program that can emit many `A` values, fail
@@ -130,7 +142,7 @@ export interface StreamUnify<A extends { [Unify.typeSymbol]?: any }> extends Eff
  * @category Models
  * @since 2.0.0
  */
-export interface StreamUnifyIgnore extends Effect.EffectUnifyIgnore {
+export interface StreamUnifyIgnore {
   Effect?: true
 }
 
@@ -342,6 +354,79 @@ export const fromChannel: <Arr extends Arr.NonEmptyReadonlyArray<any>, E, R>(
 export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Stream<A, E, R> =>
   fromChannel(Channel.fromEffect(Effect.map(effect, Arr.of)))
 
+/**
+ * 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 const service = <I, S>(service: Context.Key<I, S>): Stream<S, never, I> => fromEffect(Effect.service(service))
+
+/**
+ * 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 const serviceOption = <I, S>(service: Context.Key<I, S>): Stream<Option.Option<S>> =>
+  fromEffect(Effect.serviceOption(service))
+
 /**
  * Creates a stream that runs the effect and emits no elements.
  *
@@ -472,7 +557,7 @@ export const fromEffectSchedule = <A, E, R, X, AS extends A, ES, RS>(
  * @since 2.0.0
  * @category Constructors
  */
-export const tick = (interval: Duration.DurationInput): Stream<void> =>
+export const tick = (interval: Duration.Input): Stream<void> =>
   fromPull(Effect.sync(() => {
     let first = true
     const effect = Effect.succeed(Arr.of<void>(undefined))
@@ -961,6 +1046,10 @@ export const fromIteratorSucceed = <A>(iterator: IterableIterator<A>, maxChunkSi
 /**
  * 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"
@@ -980,19 +1069,24 @@ export const fromIteratorSucceed = <A>(iterator: IterableIterator<A>, maxChunkSi
  * @since 2.0.0
  * @category Constructors
  */
-export const fromIterable = <A>(iterable: Iterable<A>): Stream<A> =>
-  Array.isArray(iterable)
+export const fromIterable = <A>(
+  iterable: Iterable<A>,
+  options?: {
+    readonly chunkSize?: number | undefined
+  }
+): Stream<A> =>
+  Array.isArray(iterable) && options?.chunkSize === undefined
     ? fromArray(iterable)
-    : fromChannel(Channel.fromIterableArray(iterable))
+    : fromChannel(Channel.fromIterableArray(iterable, options?.chunkSize))
 
 /**
  * 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") {}
  *
@@ -1243,7 +1337,9 @@ export const fromPubSubTake = <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): St
  *
  * @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) {
@@ -1257,7 +1353,7 @@ export const fromPubSubTake = <A, E>(pubsub: PubSub.PubSub<Take.Take<A, E>>): St
  * 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)
@@ -1299,7 +1395,9 @@ export const fromReadableStream = <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 iterable = (async function*() {
  *   yield 1
@@ -1308,7 +1406,7 @@ export const fromReadableStream = <A, E>(
  * })()
  *
  * 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)
  * })
@@ -1335,7 +1433,7 @@ export const fromAsyncIterable = <A, E>(
  *
  * 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)
@@ -3317,7 +3415,7 @@ export 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.
    *
@@ -3341,15 +3439,97 @@ export 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>
 } = dual(
   2,
-  <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R> =>
-    transformPull(self, (pull, _scope) =>
-      Effect.succeed(Effect.timeoutOrElse(pull, {
-        duration,
-        onTimeout: () => Cause.done()
-      })))
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
+    timeoutOrElse(self, {
+      duration,
+      orElse: () => empty
+    })
+)
+
+/**
+ * @since 2.0.0
+ * @category Rate Limiting
+ */
+export 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>
+} = dual(
+  2,
+  <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> => {
+    const duration = Duration.fromInputUnsafe(options.duration)
+    if (!Duration.isFinite(duration)) return self
+    if (Duration.isZero(duration)) return suspend(options.orElse)
+    const timeoutSymbol = Symbol()
+    return catchCause(
+      suspend(() => {
+        const parent = Fiber.getCurrent()!
+        const clock = parent.getRef(Clock)
+        const durationMs = Duration.toMillis(duration)
+        let deadline: number | undefined = undefined
+        const latch = Latch.makeUnsafe(false)
+        return merge(
+          transformPull(self, (pull, _scope) =>
+            Effect.suspend(() => {
+              deadline = clock.currentTimeMillisUnsafe() + durationMs
+              latch.openUnsafe()
+              return pull
+            }).pipe(
+              Effect.map((arr) => {
+                latch.closeUnsafe()
+                deadline = undefined
+                return arr
+              }),
+              Effect.succeed
+            )),
+          fromEffectDrain(Effect.gen(function*() {
+            while (true) {
+              yield* latch.await
+              if (deadline === undefined) continue
+              yield* Effect.sleep(deadline - clock.currentTimeMillisUnsafe())
+              if (deadline === undefined) continue
+              const remaining = deadline - clock.currentTimeMillisUnsafe()
+              if (remaining > 0) continue
+              return yield* Effect.die(timeoutSymbol)
+            }
+          })),
+          { haltStrategy: "left" }
+        )
+      }),
+      (cause): Stream<B, E | E2, R2> => {
+        const isTimeout = cause.reasons.find((r) => r._tag === "Die" && r.defect === timeoutSymbol)
+        if (isTimeout) return options.orElse()
+        return failCause(cause as Cause.Cause<E>)
+      }
+    )
+  }
 )
 
 /**
@@ -3802,7 +3982,7 @@ export const merge: {
     } | undefined
   ): Stream<A | A2, E | E2, R | R2>
 } = dual(
-  2,
+  (args) => isStream(args[0]) && isStream(args[1]),
   <A, E, R, A2, E2, R2>(
     self: Stream<A, E, R>,
     that: Stream<A2, E2, R2>,
@@ -5764,7 +5944,7 @@ export 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.
    *
@@ -5810,27 +5990,52 @@ export 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>
 } = dual(
   2,
-  <A, E, R, Result extends Filter.ResultOrBool>(
+  <A, E, R>(
     self: Stream<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>
-  ): Stream<Filter.Pass<A, Result>, E, R> => fromChannel(Channel.filterArray(toChannel(self), filter))
+    predicate: Predicate<A>
+  ): Stream<A, E, R> => fromChannel(Channel.filterArray(toChannel(self), predicate))
 )
 
 /**
- * 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 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>
+} = dual(
+  2,
+  <A, E, R, B, X>(
+    self: Stream<A, E, R>,
+    filter: Filter.Filter<A, B, X>
+  ): Stream<B, E, R> => fromChannel(Channel.filterMapArray(toChannel(self), filter))
+)
+
+/**
+ * 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)
@@ -5838,7 +6043,7 @@ export const filter: {
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
@@ -5846,17 +6051,13 @@ export const filter: {
  */
 export 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)
@@ -5864,25 +6065,21 @@ export 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)
@@ -5890,35 +6087,65 @@ export 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>
+} = dual(
+  2,
+  <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> => fromChannel(Channel.filterArrayEffect(toChannel(self), predicate))
+)
+
+/**
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export 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>
 } = dual(
   2,
   <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> => fromChannel(Channel.filterArrayEffect(toChannel(self), filter))
+  ): Stream<B, E | EX, R | RX> => fromChannel(Channel.filterMapArrayEffect(toChannel(self), filter))
 )
 
 /**
- * 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)
@@ -5938,63 +6165,17 @@ export const filterEffect: {
  */
 export 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)
@@ -6012,78 +6193,31 @@ export const partitionQueue: {
    * @since 4.0.0
    * @category Filtering
    */
-  <A, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
+  <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>
+      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"
-   *
-   * 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>
-    ],
-    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"
+   * 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)
@@ -6101,16 +6235,16 @@ export const partitionQueue: {
    * @since 4.0.0
    * @category Filtering
    */
-  <A, E, R, Result extends Filter.ResultOrBool>(
+  <A, E, R, Pass, Fail>(
     self: Stream<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
+    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
@@ -6118,16 +6252,16 @@ export const partitionQueue: {
 } = dual(
   (args) => isStream(args[0]),
   Effect.fnUntraced(
-    function*<A, E, R, Result extends Filter.ResultOrBool>(
+    function*<A, E, R, Pass, Fail>(
       self: Stream<A, E, R>,
-      filter: Filter.OrPredicate<NoInfer<A>, Result>,
+      filter: Filter.Filter<NoInfer<A>, Pass, Fail>,
       options?: {
         readonly capacity?: number | "unbounded" | undefined
       }
     ): Effect.fn.Return<
       [
-        passes: Queue.Dequeue<any, E | Cause.Done>,
-        fails: Queue.Dequeue<any, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
       ],
       never,
       R | Scope.Scope
@@ -6136,19 +6270,17 @@ export const partitionQueue: {
       const pull = yield* Channel.toPullScoped(self.channel, scope)
       const capacity = options?.capacity === "unbounded" ? undefined : options?.capacity ?? DefaultChunkSize
       const passes = yield* Queue.make</**
-       * 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)
@@ -6166,20 +6298,18 @@ export const partitionQueue: {
        * @since 4.0.0
        * @category Filtering
        */
-      any, /**
-       * Partitions a stream using a Filter and exposes passing and failing values as queues.
+      Pass, /**
+       * 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)
@@ -6199,19 +6329,17 @@ export const partitionQueue: {
        */
       E | Cause.Done>({ capacity })
       const fails = yield* Queue.make</**
-       * 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)
@@ -6229,20 +6357,18 @@ export const partitionQueue: {
        * @since 4.0.0
        * @category Filtering
        */
-      any, /**
-       * Partitions a stream using a Filter and exposes passing and failing values as queues.
+      Fail, /**
+       * 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)
@@ -6262,12 +6388,19 @@ export const partitionQueue: {
        */
       E | Cause.Done>({ capacity })
 
-      const partitionArr = Arr.partition(filter as any)
-
       yield* Effect.gen(function*() {
         while (true) {
           const chunk = yield* pull
-          const [excluded, satisfying] = partitionArr(chunk)
+          const excluded: Array<Fail> = []
+          const satisfying: Array<Pass> = []
+          for (let i = 0; i < chunk.length; i++) {
+            const result = filter(chunk[i] as NoInfer<A>)
+            if (Result.isFailure(result)) {
+              excluded.push(result.failure)
+            } else {
+              satisfying.push(result.success)
+            }
+          }
           let passFiber: Fiber.Fiber<any> | undefined = undefined
           if (satisfying.length > 0) {
             const leftover = Queue.offerAllUnsafe(passes, satisfying)
@@ -6298,147 +6431,112 @@ export const partitionQueue: {
 )
 
 /**
- * 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 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>,
+  <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>(
+  <A, E, R, Pass, Fail, EX, RX>(
     self: Stream<A, E, R>,
-    filter: Filter.FilterEffect<A, B, X, EX, RX>,
+    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
   >
 } = dual(
   (args) => isStream(args[0]),
-  <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
-    readonly capacity?: number | "unbounded" | undefined
-    readonly concurrency?: number | "unbounded" | undefined
-  }): Effect.Effect<
+  <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
   > =>
     Effect.map(
-      self.pipe(
-        mapEffect(filter, options),
-        partitionQueue(identity as any, options)
+      partitionQueue</**
+       * Splits a stream using an effectful `Filter`, producing pass and fail streams.
+       *
+       * @since 4.0.0
+       * @category Filtering
+       */
+      Result.Result<Pass, Fail>, /**
+       * Splits a stream using an effectful `Filter`, producing pass and fail streams.
+       *
+       * @since 4.0.0
+       * @category Filtering
+       */
+      E | EX, /**
+       * Splits a stream using an effectful `Filter`, producing pass and fail streams.
+       *
+       * @since 4.0.0
+       * @category Filtering
+       */
+      R | RX, /**
+       * Splits a stream using an effectful `Filter`, producing pass and fail streams.
+       *
+       * @since 4.0.0
+       * @category Filtering
+       */
+      Pass, /**
+       * Splits a stream using an effectful `Filter`, producing pass and fail streams.
+       *
+       * @since 4.0.0
+       * @category Filtering
+       */
+      Fail>(
+        mapEffect(self, (a) => filter(a as NoInfer<A>), options),
+        (result) => result,
+        options
       ),
-      ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]
-    ) as any
+      ([passes, fails]) => [fromQueue(passes), fromQueue(fails)] as const
+    )
 )
 
 /**
- * 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.
@@ -6448,12 +6546,12 @@ export 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)
@@ -6466,46 +6564,7 @@ export const partitionEffect: {
  */
 export 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.
@@ -6515,12 +6574,12 @@ export 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)
@@ -6531,56 +6590,18 @@ export const partition: {
    * })
    * ```
    */
-  <A, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
+  <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.
@@ -6590,12 +6611,12 @@ export 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)
@@ -6606,28 +6627,28 @@ export const partition: {
    * })
    * ```
    */
-  <A, E, R, Result extends Filter.ResultOrBool>(
+  <A, E, R, Pass, Fail>(
     self: Stream<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
+    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
   >
 } = dual(
   (args) => isStream(args[0]),
-  <A, E, R, Result extends Filter.ResultOrBool>(
+  <A, E, R, Pass, Fail>(
     self: Stream<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
+    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
   > =>
     Effect.map(
-      partitionQueue(filter, { capacity: options?.bufferSize ?? 16 })(self),
+      partitionQueue(self, filter, { capacity: options?.bufferSize ?? 16 }),
       ([passes, fails]) => [fromQueue(fails), fromQueue(passes)] as const
     )
 )
@@ -7409,7 +7430,7 @@ export const tapError: {
   ))
 
 /**
- * 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
@@ -7423,12 +7444,12 @@ export 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)
  *   )
  * )
@@ -7447,7 +7468,7 @@ export const tapError: {
  */
 export 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
@@ -7461,12 +7482,12 @@ export 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)
    *   )
    * )
@@ -7489,7 +7510,7 @@ export const catchIf: {
     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
@@ -7503,12 +7524,12 @@ export 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)
    *   )
    * )
@@ -7525,13 +7546,13 @@ export 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
@@ -7545,12 +7566,12 @@ export 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)
    *   )
    * )
@@ -7574,7 +7595,7 @@ export const catchIf: {
     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
@@ -7588,12 +7609,12 @@ export 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)
    *   )
    * )
@@ -7610,37 +7631,96 @@ export 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>(
+  <A, E, R, A2, E2, R2, A3 = never, E3 = E, 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
+    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>
 } = dual((args) => isStream(args[0]), <
   A,
   E,
   R,
-  Result extends Filter.ResultOrBool,
   A2,
   E2,
   R2,
   A3 = never,
-  E3 = Filter.Fail<E, Result>,
+  E3 = E,
   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
+  predicate: Predicate<E>,
+  f: (failure: E) => Stream<A2, E2, R2>,
+  orElse?: ((failure: E) => Stream<A3, E3, R3>) | undefined
 ): Stream<A | A2 | A3, E2 | E3, R | R2 | R3> =>
   fromChannel(
     Channel.catchIf(
       toChannel(self),
-      filter as any,
-      (e: any) => f(e).channel,
-      orElse && ((e: any) => orElse(e).channel)
+      predicate,
+      (e) => f(e).channel,
+      orElse && ((e) => orElse(e).channel)
+    )
+  ))
+
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export 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>
+} = dual((args) => isStream(args[0]), <
+  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> =>
+  fromChannel(
+    Channel.catchFilter(
+      toChannel(self),
+      filter,
+      (e) => f(e).channel,
+      orElse && ((e) => orElse(e).channel)
     )
-  ) as any)
+  ))
 
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
@@ -7979,7 +8059,7 @@ export const catchTags: {
   >
 } = dual((args) => isStream(args[0]), (self, cases, orElse) => {
   let keys: Array<string>
-  return catchIf(
+  return catchFilter(
     self,
     (e: any) => {
       keys ??= Object.keys(cases)
@@ -8092,8 +8172,16 @@ export const catchReason: {
   >(
     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
+    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>
@@ -8156,8 +8244,10 @@ export const catchReason: {
     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
+    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>
 } = dual(
   (args) => isStream(args[0]),
@@ -8177,16 +8267,18 @@ export const catchReason: {
     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
+    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> =>
     fromChannel(
       Channel.catchReason(
         toChannel(self),
         errorTag,
         reasonTag,
-        (reason) => f(reason).channel,
-        orElse && ((reason) => orElse(reason).channel)
+        (reason, error) => f(reason, error).channel,
+        orElse && ((reason, error) => orElse(reason, error).channel)
       )
     ) as any
 )
@@ -8279,7 +8371,8 @@ export const catchReasons: {
     E,
     Cases extends {
       [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (
-        reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>
+        reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>,
+        error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>
       ) => Stream<any, any, any>
     },
     A2 = unassigned,
@@ -8289,7 +8382,10 @@ export const catchReasons: {
     errorTag: K,
     cases: Cases,
     orElse?:
-      | ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>)
+      | ((
+        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
@@ -8356,7 +8452,8 @@ export const catchReasons: {
     K extends Tags<E>,
     Cases extends {
       [RK in ReasonTags<ExtractTag<E, K>>]+?: (
-        reason: ExtractReason<ExtractTag<E, K>, RK>
+        reason: ExtractReason<ExtractTag<E, K>, RK>,
+        error: NarrowReason<ExtractTag<E, K>, RK>
       ) => Stream<any, any, any>
     },
     A2 = unassigned,
@@ -8367,7 +8464,10 @@ export const catchReasons: {
     errorTag: K,
     cases: Cases,
     orElse?:
-      | ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>)
+      | ((
+        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
@@ -8387,12 +8487,12 @@ export const catchReasons: {
     }[keyof Cases]
   >
 } = dual((args) => isStream(args[0]), (self, errorTag, cases, orElse) => {
-  const handlers: Record<string, (reason: any) => Channel.Channel<any, any, any, any, any, any, any>> = {}
+  const handlers: Record<string, (reason: any, error: any) => Channel.Channel<any, any, any, any, any, any, any>> = {}
   for (const key of Object.keys(cases)) {
     const handler = (cases as any)[key]
-    handlers[key] = (reason) => handler(reason).channel
+    handlers[key] = (reason, error) => handler(reason, error).channel
   }
-  const orElseHandler = orElse && ((reason: any) => orElse(reason).channel)
+  const orElseHandler = orElse && ((reason: any, error: any) => orElse(reason, error).channel)
   return fromChannel(
     Channel.catchReasons(self.channel, errorTag as any, handlers as any, orElseHandler as any) as Channel.Channel<
       Arr.NonEmptyReadonlyArray<any>,
@@ -8550,12 +8650,12 @@ export 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>
+  <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, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R2 | 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.
@@ -8589,19 +8689,68 @@ export const catchCauseIf: {
    * @since 4.0.0
    * @category Error Handling
    */
-  <A, E, R, A2, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
+  <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>
+} = dual(3, <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> =>
+  fromChannel(
+    Channel.catchCauseIf(
+      self.channel,
+      predicate,
+      (cause) => f(cause).channel
+    )
+  ))
+
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export 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.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>
-} = dual(3, <A, E, R, A2, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
+    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>
+} = dual(3, <A, E, R, EB, A2, E2, R2, X extends 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> =>
+  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> =>
   fromChannel(
-    Channel.catchCauseIf(self.channel, filter as any, (failure: any, cause: any) =>
-      (f as any)(failure, cause).channel) as any
+    Channel.catchCauseFilter(
+      self.channel,
+      filter,
+      (failure, cause) => f(failure, cause).channel
+    )
   ))
 
 /**
@@ -8820,12 +8969,12 @@ export const orDie = <A, E, R>(self: Stream<A, E, R>): Stream<A, never, R> => fr
  */
 export 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> = dual(
@@ -8833,7 +8982,7 @@ export const ignore: <
     <A, E, R>(
       self: Stream<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel | undefined
+        readonly log?: boolean | Severity | undefined
       } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignore(self.channel, options))
   )
@@ -8860,19 +9009,19 @@ export const ignore: <
  */
 export 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> = dual(
     (args) => isStream(args[0]),
     <A, E, R>(
       self: Stream<A, E, R>,
-      options?: { readonly log?: boolean | LogLevel | undefined } | undefined
+      options?: { readonly log?: boolean | Severity | undefined } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignoreCause(self.channel, options))
   )
 
@@ -9007,9 +9156,9 @@ export 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>
  *   })
@@ -9049,9 +9198,9 @@ export 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>
    *   })
@@ -9094,9 +9243,9 @@ export 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>
    *   })
@@ -9169,9 +9318,9 @@ export 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>
      *   })
@@ -9742,7 +9891,7 @@ export 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.
    *
@@ -9766,71 +9915,71 @@ export 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>
+} = dual(
+  2,
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    predicate: (a: A, n: number) => boolean
+  ): Stream<A, E, R> =>
+    transformPull(self, (pull, _scope) =>
+      Effect.sync(() => {
+        let i = 0
+        let done = false
+        const pump: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R> = Effect.flatMap(
+          Effect.suspend(() => done ? Cause.done() : pull),
+          (chunk) => {
+            const out: Array<A> = []
+            for (let j = 0; j < chunk.length; j++) {
+              if (!predicate(chunk[j], i++)) {
+                done = true
+                break
+              }
+              out.push(chunk[j])
+            }
+            return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump
+          }
+        )
+        return pump
+      }))
+)
+
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export 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)
-   * })
-   *
-   * Effect.runPromise(program)
-   * // Output: [ 1, 2 ]
-   * ```
+   * Takes the longest initial prefix of elements that satisfy the filter.
    *
-   * @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.
-   *
-   * @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 ]
-   * ```
+   * Takes the longest initial prefix of elements that satisfy the filter.
    *
-   * @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>
 } = dual(
   2,
-  <A, E, R>(
+  <A, E, R, B, X>(
     self: Stream<A, E, R>,
-    f: Filter.Filter<A, any, any> | ((a: A, n: number) => boolean)
-  ): Stream<any, E, R> =>
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Stream<B, E, R> =>
     transformPull(self, (pull, _scope) =>
       Effect.sync(() => {
-        let i = 0
         let done = false
-        const pump: Pull.Pull<Arr.NonEmptyReadonlyArray<any>, E, void, R> = Effect.flatMap(
+        const pump: Pull.Pull<Arr.NonEmptyReadonlyArray<B>, E, void, R> = Effect.flatMap(
           Effect.suspend(() => done ? Cause.done() : pull),
           (chunk) => {
-            const out: Array<any> = []
+            const out: Array<B> = []
             for (let j = 0; j < chunk.length; j++) {
-              const result = Filter.apply(f as any, chunk[j], i++)
+              const result = filter(chunk[j])
               if (Result.isFailure(result)) {
                 done = true
                 break
@@ -10225,29 +10374,6 @@ export const dropWhile: {
    * @category Filtering
    */
   <A>(predicate: (a: NoInfer<A>, index: number) => boolean): <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 ]
-   * ```
-   *
-   * @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>
   /**
    * Drops elements from the stream while the specified predicate evaluates to `true`.
    *
@@ -10274,39 +10400,53 @@ export const dropWhile: {
     self: Stream<A, E, R>,
     predicate: (a: NoInfer<A>, index: number) => boolean
   ): Stream<A, E, R>
+} = dual(2, <A, E, R>(
+  self: Stream<A, E, R>,
+  predicate: (a: A, index: number) => boolean
+): Stream<A, E, R> =>
+  transformPull(self, (pull, _scope) =>
+    Effect.sync(() => {
+      let dropping = true
+      let index = 0
+      const filtered: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E> = Effect.flatMap(pull, (arr) => {
+        const found = arr.findIndex((a) => !predicate(a, index++))
+        if (found === -1) return filtered
+        dropping = false
+        return Effect.succeed(arr.slice(found) as Arr.NonEmptyArray<A>)
+      })
+      return Effect.suspend(() => dropping ? filtered : pull)
+    })))
+
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export 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)
-   * })
+   * Drops elements while the filter succeeds.
    *
-   * Effect.runPromise(program)
-   * // Output: [ 3, 4, 5 ]
-   * ```
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>
+  /**
+   * 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>
-} = dual(2, <A, E, R>(
+  <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>
+} = dual(2, <A, E, R, B, X>(
   self: Stream<A, E, R>,
-  f: Filter.Filter<A, any, any> | ((a: A, index: number) => boolean)
+  filter: Filter.Filter<NoInfer<A>, B, X>
 ): Stream<A, E, R> =>
   transformPull(self, (pull, _scope) =>
     Effect.sync(() => {
       let dropping = true
-      let index = 0
       const filtered: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E> = Effect.flatMap(pull, (arr) => {
-        const found = arr.findIndex((a) => Result.isFailure(Filter.apply(f as any, a, index++)))
+        const found = arr.findIndex((a) => Result.isFailure(filter(a)))
         if (found === -1) return filtered
         dropping = false
         return Effect.succeed(arr.slice(found) as Arr.NonEmptyArray<A>)
@@ -12175,7 +12315,7 @@ export 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.
    *
@@ -12199,15 +12339,15 @@ export 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>
 } = dual(
   2,
-  <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> =>
     transformPull(
       self,
       Effect.fnUntraced(function*(pull, scope) {
         const clock = yield* Clock
-        const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+        const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
         let lastArr: Arr.NonEmptyReadonlyArray<A> | undefined
         let cause: Cause.Cause<Cause.Done | E> | undefined
         let emitAtMs = Infinity
@@ -12347,7 +12487,7 @@ export const throttleEffect: {
     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
     }
@@ -12393,7 +12533,7 @@ export const throttleEffect: {
     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
     }
@@ -12405,7 +12545,7 @@ export const throttleEffect: {
     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
     }
@@ -12422,12 +12562,12 @@ const throttleEnforceEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12458,12 +12598,12 @@ const throttleShapeEffect = <A, E, R, E2, R2>(
   self: Stream<A, E, R>,
   cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>,
   units: number,
-  duration: Duration.DurationInput,
+  duration: Duration.Input,
   burst: number
 ): Stream<A, E | E2, R | R2> =>
   transformPull(self, (pull) =>
     Effect.clockWith((clock) => {
-      const durationMs = Duration.toMillis(Duration.fromDurationInputUnsafe(duration))
+      const durationMs = Duration.toMillis(Duration.fromInputUnsafe(duration))
       const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst
       let tokens = units
       let timestampMs = clock.currentTimeMillisUnsafe()
@@ -12576,7 +12716,7 @@ export const throttle: {
     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
     }
@@ -12621,7 +12761,7 @@ export const throttle: {
     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
     }
@@ -12633,7 +12773,7 @@ export const throttle: {
     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
     }
@@ -12771,7 +12911,7 @@ export 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.
@@ -12795,11 +12935,11 @@ export 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>
 } = dual(3, <A, E, R>(
   self: Stream<A, E, R>,
   chunkSize: number,
-  duration: Duration.DurationInput
+  duration: Duration.Input
 ): Stream<Array<A>, E, R> =>
   aggregateWithin(
     self,
@@ -12874,7 +13014,7 @@ export const groupBy: {
     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>
   /**
@@ -12913,7 +13053,7 @@ export const groupBy: {
     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>
 } = dual((args) => isStream(args[0]), <A, E, R, K, V, E2, R2>(
@@ -12921,7 +13061,7 @@ export const groupBy: {
   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> =>
   groupByImpl(
@@ -13003,7 +13143,7 @@ export const groupByKey: {
     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>
   /**
@@ -13040,7 +13180,7 @@ export const groupByKey: {
     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>
 } = dual((args) => isStream(args[0]), <A, E, R, K>(
@@ -13048,7 +13188,7 @@ export const groupByKey: {
   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> =>
   suspend(() => {
@@ -13146,7 +13286,7 @@ const groupByImpl = <A, E, R, K, V, E2, R2>(
   ) => Effect.Effect<void, 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> =>
   transformPullBracket(
@@ -13597,11 +13737,9 @@ export const aggregateWithin: {
     })
 
     // upstream -> buffer
-    let hadChunk = false
     yield* pull.pipe(
       pullLatch.whenOpen,
       Effect.flatMap((arr) => {
-        hadChunk = true
         pullLatch.closeUnsafe()
         return Queue.offer(buffer, arr)
       }),
@@ -13638,35 +13776,44 @@ export const aggregateWithin: {
      * @category Aggregation
      */
     B>()
+    let leftover: Arr.NonEmptyReadonlyArray<A2> | undefined
+    let sinkHasInput = false
     const step = yield* Schedule.toStepWithSleep(schedule)
-    const stepToBuffer = Effect.suspend(() => step(lastOutput)).pipe(
-      Effect.flatMap(() => Queue.offer(buffer, scheduleStep)),
-      Effect.flatMap(() => Effect.never),
-      Pull.catchDone(() => Cause.done())
-    )
+    const stepToBuffer = Effect.suspend(function loop(): Pull.Pull<never, E3, void, R3> {
+      return step(lastOutput).pipe(
+        Effect.flatMap(() => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep)),
+        Effect.flatMap(() => Effect.never),
+        Pull.catchDone(() => Cause.done())
+      )
+    })
 
     // buffer -> sink
     const pullFromBuffer: Pull.Pull<
       Arr.NonEmptyReadonlyArray<A>,
       E
     > = Queue.take(buffer).pipe(
-      Effect.flatMap((arr) => arr === scheduleStep ? Cause.done() : Effect.succeed(arr))
+      Effect.flatMap((arr) => {
+        if (arr === scheduleStep) {
+          return Cause.done()
+        }
+        sinkHasInput = true
+        return Effect.succeed(arr)
+      })
     )
 
-    let leftover: Arr.NonEmptyReadonlyArray<A2> | undefined
     const sinkUpstream = Effect.suspend((): Pull.Pull<Arr.NonEmptyReadonlyArray<A | A2>, E> => {
       if (leftover !== undefined) {
         const chunk = leftover
         leftover = undefined
+        sinkHasInput = true
         return Effect.succeed(chunk)
       }
-      hadChunk = false
       pullLatch.openUnsafe()
       return pullFromBuffer
     })
     const catchSinkHalt = Effect.flatMap(([value, leftover_]: Sink.End<B, A2>) => {
-      // ignore the last output if the upsteam only pulled a halt
-      if (!hadChunk && buffer.state._tag === "Done") return Cause.done()
+      // ignore the last output if the upstream only pulled a halt
+      if (!sinkHasInput && buffer.state._tag === "Done") return Cause.done()
       lastOutput = Option.some(value)
       leftover = leftover_
       return Effect.succeed(Arr.of(value))
@@ -13674,9 +13821,10 @@ export const aggregateWithin: {
 
     return Effect.suspend(() => {
       // if the buffer has exited and there is no more data to process
-      if (buffer.state._tag === "Done") {
+      if (buffer.state._tag === "Done" && leftover === undefined) {
         return buffer.state.exit as Exit.Exit<never, Cause.Done<void> | E>
       }
+      sinkHasInput = leftover !== undefined
       return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream as any, scope)))
     }).pipe(
       Effect.flatMap((pull) => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer))
@@ -13880,12 +14028,12 @@ export 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>
   /**
@@ -13924,12 +14072,12 @@ export 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
     }
   ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
 } = dual(2, <A, E, R>(
@@ -13937,12 +14085,12 @@ export 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
   }
 ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R> =>
   Effect.map(
@@ -15807,7 +15955,7 @@ export const ensuring: {
 )
 
 /**
- * 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.
  *
@@ -15815,9 +15963,9 @@ export 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" })
  *
@@ -15844,7 +15992,7 @@ export const ensuring: {
  */
 export 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.
    *
@@ -15852,9 +16000,9 @@ export 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" })
    *
@@ -15880,7 +16028,7 @@ export const provide: {
    * @category Services
    */
   <AL, EL = never, RL = never>(
-    layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+    layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
@@ -15888,7 +16036,7 @@ export const provide: {
     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.
    *
@@ -15896,9 +16044,9 @@ export 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" })
    *
@@ -15925,31 +16073,31 @@ export const provide: {
    */
   <A, E, R, AL, EL = never, RL = never>(
     self: Stream<A, E, R>,
-    layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+    layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Stream<A, E | EL, Exclude<R, AL> | RL>
 } = dual((args) => isStream(args[0]), <A, E, R, AL, EL = never, RL = never>(
   self: Stream<A, E, R>,
-  layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+  layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
   options?: {
     readonly local?: boolean | undefined
   } | undefined
 ): Stream<A, E | EL, Exclude<R, AL> | RL> => fromChannel(Channel.provide(self.channel, layer, options)))
 
 /**
- * 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(
@@ -15961,7 +16109,7 @@ export 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)
  * })
  *
@@ -15972,19 +16120,19 @@ export const provide: {
  * @since 4.0.0
  * @category Services
  */
-export const provideServices: {
+export 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(
@@ -15996,7 +16144,7 @@ export 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)
    * })
    *
@@ -16007,19 +16155,19 @@ export 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(
@@ -16031,7 +16179,7 @@ export 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)
    * })
    *
@@ -16042,11 +16190,11 @@ export 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>>
 } = dual(
   2,
-  <A, E, R, R2>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<R2>): Stream<A, E, Exclude<R, R2>> =>
-    fromChannel(Channel.provideServices(self.channel, services))
+  <A, E, R, R2>(self: Stream<A, E, R>, context: Context.Context<R2>): Stream<A, E, Exclude<R, R2>> =>
+    fromChannel(Channel.provideContext(self.channel, context))
 )
 
 /**
@@ -16055,9 +16203,9 @@ export 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") {}
  *
@@ -16092,9 +16240,9 @@ export 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") {}
    *
@@ -16122,7 +16270,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <A, E, R>(
+  <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, Exclude<R, I>>
   /**
@@ -16131,9 +16279,9 @@ export 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") {}
    *
@@ -16161,10 +16309,10 @@ export 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>>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: Context.Key<I, S>,
   service: NoInfer<S>
 ): Stream<A, E, Exclude<R, I>> => fromChannel(Channel.provideService(self.channel, key, service)))
 
@@ -16173,9 +16321,9 @@ export const provideService: {
  *
  * @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*() {
@@ -16212,9 +16360,9 @@ export 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*() {
@@ -16245,7 +16393,7 @@ export 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>(
+  <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>
   /**
@@ -16253,9 +16401,9 @@ export 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*() {
@@ -16288,25 +16436,25 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, ES, RS>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: Context.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Stream<A, E | ES, Exclude<R, I> | RS>
 } = dual(3, <A, E, R, I, S, ES, RS>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Service<I, S>,
+  key: Context.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Stream<A, E | ES, Exclude<R, I> | RS> => fromChannel(Channel.provideServiceEffect(self.channel, key, service)))
 
 /**
- * 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*() {
@@ -16317,8 +16465,8 @@ export 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" })
  *   )
  * )
  *
@@ -16336,17 +16484,17 @@ export const provideServiceEffect: {
  * @since 2.0.0
  * @category Services
  */
-export const updateServices: {
+export 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*() {
@@ -16357,8 +16505,8 @@ export 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" })
    *   )
    * )
    *
@@ -16376,19 +16524,19 @@ export const updateServices: {
    * @since 2.0.0
    * @category Services
    */
-  <R, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): <A, E>(
+  <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*() {
@@ -16399,8 +16547,8 @@ export 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" })
    *   )
    * )
    *
@@ -16420,21 +16568,21 @@ export const updateServices: {
    */
   <A, E, R, R2>(
     self: Stream<A, E, R>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>
+    f: (context: Context.Context<R2>) => Context.Context<R>
   ): Stream<A, E, R2>
 } = dual(2, <A, E, R, R2>(
   self: Stream<A, E, R>,
-  f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>
-): Stream<A, E, R2> => fromChannel(Channel.updateServices(self.channel, f)))
+  f: (context: Context.Context<R2>) => Context.Context<R>
+): Stream<A, E, R2> => fromChannel(Channel.updateContext(self.channel, f)))
 
 /**
  * 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 }))
@@ -16458,9 +16606,9 @@ export 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 }))
@@ -16478,7 +16626,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(
+  <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>
   /**
@@ -16486,9 +16634,9 @@ export 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 }))
@@ -16508,19 +16656,19 @@ export const updateService: {
    */
   <A, E, R, I, S>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: Context.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Stream<A, E, R | I>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  service: ServiceMap.Service<I, S>,
+  service: Context.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Stream<A, E, R | I> =>
-  updateServices(self, (services) =>
-    ServiceMap.add(
-      services,
+  updateContext(self, (context) =>
+    Context.add(
+      context,
       service,
-      f(ServiceMap.get(services, service))
+      f(Context.get(context, service))
     )))
 
 /**
@@ -16592,7 +16740,7 @@ export const withSpan: {
 } = function() {
   const dataFirst = isStream(arguments[0])
   const name = dataFirst ? arguments[1] : arguments[0]
-  const options = addSpanStackTrace(dataFirst ? arguments[1] : arguments[2])
+  const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
   if (dataFirst) {
     const self = arguments[0] as Stream<any, any, any>
     return fromChannel(Channel.withSpan(self.channel, name, options))
@@ -17662,20 +17810,31 @@ export const mkString = <E, R>(self: Stream<string, E, R>): Effect.Effect<string
  * @category Destructors
  */
 export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effect<Uint8Array, E, R> =>
-  Channel.runFold(
-    self.channel,
-    () => new Uint8Array(0),
-    (acc, chunk) => {
-      let chunkLength = 0
-      for (let i = 0; i < chunk.length; i++) {
-        chunkLength += chunk[i].length
+  Effect.map(
+    Channel.runFold(
+      self.channel,
+      (): {
+        bytes: number
+        readonly arrays: Array<Uint8Array>
+      } => ({
+        bytes: 0,
+        arrays: []
+      }),
+      (acc, chunk) => {
+        for (let i = 0; i < chunk.length; i++) {
+          acc.bytes += chunk[i].length
+          acc.arrays.push(chunk[i])
+        }
+        return acc
       }
-      const result = new Uint8Array(acc.length + chunkLength)
-      result.set(acc, 0)
-      let offset = acc.length
-      for (let i = 0; i < chunk.length; i++) {
-        result.set(chunk[i], offset)
-        offset += chunk[i].length
+    ),
+    ({ arrays, bytes }) => {
+      const result = new Uint8Array(bytes)
+      let offset = 0
+      for (let i = 0; i < arrays.length; i++) {
+        const array = arrays[i]
+        result.set(array, offset)
+        offset += array.length
       }
       return result
     }
@@ -17688,10 +17847,10 @@ export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effec
  *
  * @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
@@ -17705,17 +17864,17 @@ export const toReadableStreamWith = dual<
    *
    * @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
    */
   <A, XR>(
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>,
   /**
@@ -17725,10 +17884,10 @@ export const toReadableStreamWith = dual<
    *
    * @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
@@ -17736,14 +17895,14 @@ export const toReadableStreamWith = dual<
    */
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ) => ReadableStream<A>
 >(
   (args) => isStream(args[0]),
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ): ReadableStream<A> => {
     let currentResolve: (() => void) | undefined = undefined
@@ -17752,7 +17911,7 @@ export const toReadableStreamWith = dual<
 
     return new ReadableStream<A>({
       start(controller) {
-        fiber = Effect.runFork(Effect.provideServices(
+        fiber = Effect.runFork(Effect.provideContext(
           runForEachArray(self, (chunk) =>
             latch.whenOpen(Effect.sync(() => {
               latch.closeUnsafe()
@@ -17762,7 +17921,7 @@ export const toReadableStreamWith = dual<
               currentResolve!()
               currentResolve = undefined
             }))),
-          services
+          context
         ))
         fiber.addObserver((exit) => {
           if (exit._tag === "Failure") {
@@ -17847,7 +18006,7 @@ export const toReadableStream: {
   <A, E>(
     self: Stream<A, E>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
-  ): ReadableStream<A> => toReadableStreamWith(self, ServiceMap.empty(), options)
+  ): ReadableStream<A> => toReadableStreamWith(self, Context.empty(), options)
 )
 
 /**
@@ -17931,7 +18090,7 @@ export const toReadableStreamEffect: {
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ): Effect.Effect<ReadableStream<A>, never, R> =>
     Effect.map(
-      Effect.services</**
+      Effect.context</**
        * Creates an Effect that builds a ReadableStream from the stream.
        *
        * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
@@ -17963,10 +18122,10 @@ export 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> = []
@@ -17986,10 +18145,10 @@ export 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> = []
@@ -18003,16 +18162,16 @@ export 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> = []
@@ -18026,16 +18185,16 @@ export 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>
 } = dual(
   2,
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>
+    context: Context.Context<XR>
   ): AsyncIterable<A> => ({
     [Symbol.asyncIterator]() {
-      const runPromise = Effect.runPromiseWith(services)
-      const runPromiseExit = Effect.runPromiseExitWith(services)
+      const runPromise = Effect.runPromiseWith(context)
+      const runPromiseExit = Effect.runPromiseExitWith(context)
       const scope = Scope.makeUnsafe()
       let pull: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R> | undefined
       let currentIter: Iterator<A> | undefined
@@ -18097,8 +18256,8 @@ export const toAsyncIterableWith: {
  */
 export const toAsyncIterableEffect = <A, E, R>(self: Stream<A, E, R>): Effect.Effect<AsyncIterable<A>, never, R> =>
   Effect.map(
-    Effect.services<R>(),
-    (services) => toAsyncIterableWith(self, services)
+    Effect.context<R>(),
+    (context) => toAsyncIterableWith(self, context)
   )
 
 /**
@@ -18127,7 +18286,7 @@ export const toAsyncIterableEffect = <A, E, R>(self: Stream<A, E, R>): Effect.Ef
  * @category Destructors
  */
 export const toAsyncIterable = <A, E>(self: Stream<A, E>): AsyncIterable<A> =>
-  toAsyncIterableWith(self, ServiceMap.empty())
+  toAsyncIterableWith(self, Context.empty())
 
 /**
  * Runs the stream, publishing elements into the provided PubSub.
@@ -18473,16 +18632,16 @@ export const toPubSubTake: {
 )
 
 /**
- * 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
  * })
  * ```
  *
@@ -18491,16 +18650,16 @@ export const toPubSubTake: {
  */
 export 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
    * })
    * ```
    *
@@ -18516,16 +18675,16 @@ export const toQueue: {
     }
   ): <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
    * })
    * ```
    *
@@ -18540,22 +18699,19 @@ export 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>
 } = dual(
   2,
   <A, E, R>(
     self: Stream<A, E, R>,
     options: {
       readonly capacity: "unbounded"
-      readonly replay?: number | undefined
-      readonly shutdownOnEnd?: boolean | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-      readonly replay?: number | undefined
-      readonly shutdownOnEnd?: boolean | undefined
     }
-  ): Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope> => Channel.toPubSubArray(self.channel, options)
+  ): Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope> =>
+    Channel.toQueueArray(self.channel, options)
 )
 
 /**