effect 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/Stream.d.ts

@@ -8,11 +8,11 @@ import * as Duration from "./Duration.ts";
 import * as Effect from "./Effect.ts";
 import * as ExecutionPlan from "./ExecutionPlan.ts";
 import * as Exit from "./Exit.ts";
-import * as Filter from "./Filter.ts";
+import type * as Filter from "./Filter.ts";
 import type { LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.ts";
 import type * as Layer from "./Layer.ts";
-import type { LogLevel } from "./LogLevel.ts";
+import type { Severity } from "./LogLevel.ts";
 import * as Option from "./Option.ts";
 import type { Pipeable } from "./Pipeable.ts";
 import type { Predicate, Refinement } from "./Predicate.ts";
@@ -26,7 +26,7 @@ import * as ServiceMap from "./ServiceMap.ts";
 import * as Sink from "./Sink.ts";
 import type * as Take from "./Take.ts";
 import type { ParentSpan, SpanOptions } from "./Tracer.ts";
-import type { Covariant, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NoInfer, ReasonTags, Tags, unassigned } from "./Types.ts";
+import type { Covariant, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NarrowReason, NoInfer, OmitReason, ReasonTags, Tags, unassigned } from "./Types.ts";
 import type * as Unify from "./Unify.ts";
 declare const TypeId = "~effect/Stream";
 /**
@@ -401,7 +401,7 @@ export declare const fromEffectSchedule: <A, E, R, X, AS extends A, ES, RS>(effe
  * @since 2.0.0
  * @category Constructors
  */
-export declare const tick: (interval: Duration.DurationInput) => Stream<void>;
+export declare const tick: (interval: Duration.Input) => Stream<void>;
 /**
  * Creates a stream from a pull effect, such as one produced by `Stream.toPull`.
  *
@@ -2767,7 +2767,7 @@ export declare const timeout: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Ends the stream if it does not produce a value within the specified duration.
      *
@@ -2791,7 +2791,7 @@ export declare const timeout: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
 };
 /**
  * Repeats each element of the stream according to the provided schedule,
@@ -4775,7 +4775,7 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>): <E, R>(self: Stream<A, E, R>) => Stream<Filter.Pass<A, Result>, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Filters a stream to the elements that satisfy a predicate.
      *
@@ -4821,20 +4821,38 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>): Stream<Filter.Pass<A, Result>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMap: {
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<A, B, X>): Stream<B, E, R>;
+};
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -4842,7 +4860,7 @@ export declare const filter: {
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
@@ -4850,17 +4868,13 @@ export declare const filter: {
  */
 export declare const filterEffect: {
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4868,25 +4882,21 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    <A, EX, RX>(predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<A, E | EX, R | RX>;
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4894,28 +4904,48 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
+    <A, E, R, EX, RX>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): Stream<A, E | EX, R | RX>;
+};
+/**
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMapEffect: {
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
     <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>): Stream<B, E | EX, R | RX>;
 };
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -4935,56 +4965,17 @@ export declare const filterEffect: {
  */
 export declare const partitionQueue: {
     /**
-     * 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, 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.
-     *
-     * Each queue fails with the stream error or `Cause.Done` when the source ends.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
+     *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
      *   )
      *
      *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -5002,63 +4993,24 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
+        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)
@@ -5076,119 +5028,49 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
     ], never, R | Scope.Scope>;
 };
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
 export declare const partitionEffect: {
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, Pass, Fail, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, E, R, Pass, Fail, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
 };
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -5198,12 +5080,12 @@ export declare const partitionEffect: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -5216,8 +5098,7 @@ export declare const partitionEffect: {
  */
 export declare const partition: {
     /**
-     * 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.
@@ -5227,46 +5108,12 @@ export declare const partition: {
      *
      * @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.
-     *
-     * 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"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5277,15 +5124,14 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
+        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.
@@ -5295,46 +5141,12 @@ export declare const partition: {
      *
      * @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>
-    ], 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"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5345,11 +5157,11 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
+        excluded: Stream<Fail, E>,
+        satisfying: Stream<Pass, E>
     ], never, R | Scope.Scope>;
 };
 /**
@@ -6043,7 +5855,7 @@ export declare const tapError: {
     <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -6057,12 +5869,12 @@ export declare const tapError: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -6081,7 +5893,7 @@ export declare const tapError: {
  */
 export declare const catchIf: {
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6095,12 +5907,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6119,7 +5931,7 @@ export declare const catchIf: {
      */
     <E, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6133,12 +5945,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6155,9 +5967,9 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Stream<A2, E2, R2>, orElse?: ((e: NoInfer<E>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6171,12 +5983,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6195,7 +6007,7 @@ export declare const catchIf: {
      */
     <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(self: Stream<A, E, R>, refinement: Refinement<E, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6209,12 +6021,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6231,7 +6043,32 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(self: Stream<A, E, R>, predicate: Predicate<E>, f: (e: E) => Stream<A2, E2, R2>, orElse?: ((e: E) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+};
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchFilter: {
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
 };
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
@@ -6567,7 +6404,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
+    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>, error: OmitReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
     /**
      * Catches a specific reason within a tagged error.
      *
@@ -6611,7 +6448,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: Stream<A, E, R>, errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<E, K>, RK>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
+    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: Stream<A, E, R>, errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: NarrowReason<ExtractTag<E, K>, RK>) => Stream<A2, E2, R2>, orElse?: ((reason: ExcludeReason<ExtractTag<E, K>, RK>, error: OmitReason<ExtractTag<E, K>, RK>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
 };
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
@@ -6697,8 +6534,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <K extends Tags<E>, E, Cases extends {
-        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | {
+        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => Stream<any, any, any>;
+    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<any, infer E, any> ? E : never;
@@ -6747,8 +6584,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <A, E, R, K extends Tags<E>, Cases extends {
-        [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Stream<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | {
+        [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: NarrowReason<ExtractTag<E, K>, RK>) => Stream<any, any, any>;
+    }, A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Stream<any, infer E, any> ? E : never;
@@ -6896,7 +6733,7 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, A2, E2, R2>(filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R2 | R>;
+    <E, A2, E2, R2>(predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, E | E2, R2 | R>;
     /**
      * Recovers from stream failures by filtering the `Cause` and switching to a recovery stream.
      * Non-matching causes are re-emitted as failures.
@@ -6930,7 +6767,32 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, A2, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(self: Stream<A, E, R>, filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+};
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchCauseFilter: {
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X extends Cause.Cause<any>>(filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<X> | E2, R2 | R>;
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X extends Cause.Cause<any>>(self: Stream<A, E, R>, filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<X> | E2, R | R2>;
 };
 /**
  * Switches to a fallback stream if this stream is empty.
@@ -7134,9 +6996,9 @@ export declare const orDie: <A, E, R>(self: Stream<A, E, R>) => Stream<A, never,
  * @category Error Handling
  */
 export declare const ignore: <Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined>(selfOrOptions: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R> : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
  * Ignores the stream's failure cause, including defects, and ends the stream.
@@ -7159,9 +7021,9 @@ export declare const ignore: <Arg extends Stream<any, any, any> | {
  * @category Error Handling
  */
 export declare const ignoreCause: <Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined>(streamOrOptions: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R> : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R>;
 /**
  * When the stream fails, retry it according to the given schedule.
@@ -7811,7 +7673,7 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
     /**
      * Takes the longest initial prefix of elements that satisfy the predicate.
      *
@@ -7835,52 +7697,26 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, n: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const takeWhileFilter: {
     /**
-     * Takes the longest initial prefix of elements that satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * const stream = Stream.range(1, 5).pipe(
-     *   Stream.takeWhile((n) => n % 3 !== 0)
-     * )
-     *
-     * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(stream)
-     *   yield* Console.log(result)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(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)
-     * })
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
     <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<B, E, R>;
@@ -8236,53 +8072,29 @@ export declare const dropWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const dropWhileFilter: {
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
+     * Drops elements while the filter succeeds.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
+     * Drops elements while the filter succeeds.
      *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
 };
 /**
  * Drops elements while the specified effectful predicate evaluates to `true`.
@@ -9557,7 +9369,7 @@ export declare const debounce: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    (duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    (duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Drops earlier elements within the debounce window and emits only the latest element after the pause.
      *
@@ -9581,7 +9393,7 @@ export declare const debounce: {
      * @since 2.0.0
      * @category Rate Limiting
      */
-    <A, E, R>(self: Stream<A, E, R>, duration: Duration.DurationInput): Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>;
 };
 /**
  * Delays the arrays of this stream according to the given bandwidth
@@ -9659,7 +9471,7 @@ export declare const throttleEffect: {
     <A, E2, R2>(options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
@@ -9702,7 +9514,7 @@ export declare const throttleEffect: {
     <A, E, R, E2, R2>(self: Stream<A, E, R>, options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => Effect.Effect<number, E2, R2>;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): Stream<A, E | E2, R | R2>;
@@ -9781,7 +9593,7 @@ export declare const throttle: {
     <A>(options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
@@ -9823,7 +9635,7 @@ export declare const throttle: {
     <A, E, R>(self: Stream<A, E, R>, options: {
         readonly cost: (arr: Arr.NonEmptyReadonlyArray<A>) => number;
         readonly units: number;
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly burst?: number | undefined;
         readonly strategy?: "enforce" | "shape" | undefined;
     }): Stream<A, E, R>;
@@ -9951,7 +9763,7 @@ export declare const groupedWithin: {
      * @since 2.0.0
      * @category Grouping
      */
-    (chunkSize: number, duration: Duration.DurationInput): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>;
+    (chunkSize: number, duration: Duration.Input): <A, E, R>(self: Stream<A, E, R>) => Stream<Array<A>, E, R>;
     /**
      * Partitions the stream into arrays, emitting when the chunk size is reached
      * or the duration passes.
@@ -9975,7 +9787,7 @@ export declare const groupedWithin: {
      * @since 2.0.0
      * @category Grouping
      */
-    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.DurationInput): Stream<Array<A>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, chunkSize: number, duration: Duration.Input): Stream<Array<A>, E, R>;
 };
 /**
  * Groups elements into keyed substreams using an effectful classifier.
@@ -10042,7 +9854,7 @@ export declare const groupBy: {
      */
     <A, K, V, E2, R2>(f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<V>], E | E2, R | R2>;
     /**
      * Groups elements into keyed substreams using an effectful classifier.
@@ -10077,7 +9889,7 @@ export declare const groupBy: {
      */
     <A, E, R, K, V, E2, R2>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => Effect.Effect<readonly [K, V], E2, R2>, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Stream<readonly [K, Stream<V>], E | E2, R | R2>;
 };
 /**
@@ -10141,7 +9953,7 @@ export declare const groupByKey: {
      */
     <A, K>(f: (a: NoInfer<A>) => K, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Stream<readonly [K, Stream<A>], E, R>;
     /**
      * Groups elements by a key and emits a stream per key.
@@ -10174,7 +9986,7 @@ export declare const groupByKey: {
      */
     <A, E, R, K>(self: Stream<A, E, R>, f: (a: NoInfer<A>) => K, options?: {
         readonly bufferSize?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Stream<readonly [K, Stream<A>], E, R>;
 };
 /**
@@ -10559,12 +10371,12 @@ export declare const share: {
     (options: {
         readonly capacity: "unbounded";
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     } | {
         readonly capacity: number;
         readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
     /**
      * Returns a new Stream that multicasts the original stream, subscribing when the first consumer starts.
@@ -10600,12 +10412,12 @@ export declare const share: {
     <A, E, R>(self: Stream<A, E, R>, options: {
         readonly capacity: "unbounded";
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     } | {
         readonly capacity: number;
         readonly strategy?: "sliding" | "dropping" | "suspend" | undefined;
         readonly replay?: number | undefined;
-        readonly idleTimeToLive?: Duration.DurationInput | undefined;
+        readonly idleTimeToLive?: Duration.Input | undefined;
     }): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>;
 };
 /**
@@ -12457,7 +12269,7 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Service<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
+    <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
     /**
      * Provides the stream with a single required service, eliminating that
      * requirement from its environment.
@@ -12494,7 +12306,7 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
 };
 /**
  * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
@@ -12573,7 +12385,7 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S, ES, RS>(key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
+    <I, S, ES, RS>(key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
     /**
      * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
      *
@@ -12612,7 +12424,7 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
+    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
 };
 /**
  * Transforms the stream's required services by mapping the current service map
@@ -12786,7 +12598,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
+    <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
     /**
      * Updates a single service in the stream environment by applying a function.
      *
@@ -12812,7 +12624,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Service<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
 };
 /**
  * Wraps the stream with a new span for tracing.