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

package/src/Stream.ts

@@ -12,7 +12,7 @@ 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"
@@ -20,8 +20,9 @@ import * as internalExecutionPlan from "./internal/executionPlan.ts"
 import * as internal from "./internal/stream.ts"
 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"
@@ -47,7 +48,9 @@ import type {
   ExcludeTag,
   ExtractReason,
   ExtractTag,
+  NarrowReason,
   NoInfer,
+  OmitReason,
   ReasonTags,
   Tags,
   unassigned
@@ -471,7 +474,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))
@@ -2648,8 +2651,8 @@ export const tapSink: {
     transformPullBracket(
       self,
       Effect.fnUntraced(function*(pull, _, scope) {
-        const upstreamLatch = Effect.makeLatchUnsafe()
-        const sinkLatch = Effect.makeLatchUnsafe()
+        const upstreamLatch = Latch.makeUnsafe()
+        const sinkLatch = Latch.makeUnsafe()
         let chunk: Arr.NonEmptyReadonlyArray<A> | undefined = undefined
         let causeSink: Cause.Cause<E2> | undefined = undefined
         let sinkDone = false
@@ -3316,7 +3319,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.
    *
@@ -3340,10 +3343,10 @@ 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> =>
+  <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R> =>
     transformPull(self, (pull, _scope) =>
       Effect.succeed(Effect.timeoutOrElse(pull, {
         duration,
@@ -5341,7 +5344,7 @@ export const zipLatestAll = <T extends ReadonlyArray<Stream<any, any, any>>>(
   fromChannel(Channel.suspend(() => {
     const latest: Array<any> = []
     const emitted = new Set<number>()
-    const readyLatch = Effect.makeLatchUnsafe()
+    const readyLatch = Latch.makeUnsafe()
     return Channel.mergeAll(
       Channel.fromArray(
         streams.map((s, i) =>
@@ -5763,7 +5766,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.
    *
@@ -5809,27 +5812,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)
@@ -5837,7 +5865,7 @@ export const filter: {
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
@@ -5845,17 +5873,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)
@@ -5863,25 +5887,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)
@@ -5889,35 +5909,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)
@@ -5937,63 +5987,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)
@@ -6011,78 +6015,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)
@@ -6100,16 +6057,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
@@ -6117,16 +6074,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
@@ -6135,19 +6092,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)
@@ -6165,20 +6120,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)
@@ -6198,19 +6151,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)
@@ -6228,20 +6179,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)
@@ -6261,12 +6210,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)
@@ -6297,147 +6253,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.
@@ -6447,102 +6368,25 @@ export const partitionEffect: {
  *
  * @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 ]
- * })
- * ```
- */
-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.
-   *
-   * 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 ]
-   * })
-   * ```
-   */
-  <A, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    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
-  >
+ * 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 ? Result.succeed(n) : Result.fail(n)
+ *   )
+ *   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 ]
+ * })
+ * ```
+ */
+export 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.
@@ -6552,12 +6396,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)
@@ -6568,18 +6412,18 @@ export const partition: {
    * })
    * ```
    */
-  <C extends A, E, R, B extends A, A = C>(
-    self: Stream<C, E, R>,
-    refinement: Refinement<A, B>,
+  <A, Pass, Fail>(
+    filter: Filter.Filter<NoInfer<A>, Pass, Fail>,
     options?: { readonly bufferSize?: number | undefined }
-  ): Effect.Effect<
-    [excluded: Stream<Exclude<C, B>, E>, satisfying: Stream<B, E>],
+  ): <E, R>(
+    self: Stream<A, E, R>
+  ) => Effect.Effect<
+    [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.
@@ -6589,12 +6433,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)
@@ -6605,28 +6449,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
     )
 )
@@ -7408,7 +7252,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
@@ -7422,12 +7266,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)
  *   )
  * )
@@ -7446,7 +7290,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
@@ -7460,12 +7304,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)
    *   )
    * )
@@ -7488,7 +7332,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
@@ -7502,12 +7346,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)
    *   )
    * )
@@ -7524,13 +7368,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
@@ -7544,12 +7388,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)
    *   )
    * )
@@ -7573,7 +7417,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
@@ -7587,12 +7431,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)
    *   )
    * )
@@ -7609,37 +7453,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
@@ -7978,7 +7881,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)
@@ -8091,8 +7994,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>
@@ -8155,8 +8066,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]),
@@ -8176,16 +8089,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
 )
@@ -8278,7 +8193,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,
@@ -8288,7 +8204,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
@@ -8355,7 +8274,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,
@@ -8366,7 +8286,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
@@ -8386,12 +8309,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>,
@@ -8549,12 +8472,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.
@@ -8588,19 +8511,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
+    )
   ))
 
 /**
@@ -8819,12 +8791,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(
@@ -8832,7 +8804,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))
   )
@@ -8859,19 +8831,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))
   )
 
@@ -9741,7 +9713,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.
    *
@@ -9765,71 +9737,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
@@ -10224,29 +10196,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`.
    *
@@ -10273,39 +10222,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>)
@@ -12174,7 +12137,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.
    *
@@ -12198,21 +12161,21 @@ 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
-        const pullLatch = Effect.makeLatchUnsafe()
-        const emitLatch = Effect.makeLatchUnsafe()
-        const endLatch = Effect.makeLatchUnsafe()
+        const pullLatch = Latch.makeUnsafe()
+        const emitLatch = Latch.makeUnsafe()
+        const endLatch = Latch.makeUnsafe()
 
         yield* pull.pipe(
           pullLatch.whenOpen,
@@ -12346,7 +12309,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
     }
@@ -12392,7 +12355,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
     }
@@ -12404,7 +12367,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
     }
@@ -12421,12 +12384,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()
@@ -12457,12 +12420,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()
@@ -12575,7 +12538,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
     }
@@ -12620,7 +12583,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
     }
@@ -12632,7 +12595,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
     }
@@ -12770,7 +12733,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.
@@ -12794,11 +12757,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,
@@ -12873,7 +12836,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>
   /**
@@ -12912,7 +12875,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>(
@@ -12920,7 +12883,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(
@@ -13002,7 +12965,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>
   /**
@@ -13039,7 +13002,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>(
@@ -13047,7 +13010,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(() => {
@@ -13145,7 +13108,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(
@@ -13537,7 +13500,7 @@ export const aggregateWithin: {
   fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function*(_upstream, _, scope) {
     const pull = yield* Channel.toPullScoped(self.channel, _)
 
-    const pullLatch = Effect.makeLatchUnsafe(false)
+    const pullLatch = Latch.makeUnsafe(false)
     const scheduleStep = Symbol()
     const buffer = yield* Queue.make</**
      * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
@@ -13637,12 +13600,15 @@ export const aggregateWithin: {
      * @category Aggregation
      */
     B>()
+    let leftover: Arr.NonEmptyReadonlyArray<A2> | undefined
     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(() => !hadChunk && leftover === undefined ? loop() : Queue.offer(buffer, scheduleStep)),
+        Effect.flatMap(() => Effect.never),
+        Pull.catchDone(() => Cause.done())
+      )
+    })
 
     // buffer -> sink
     const pullFromBuffer: Pull.Pull<
@@ -13652,7 +13618,6 @@ export const aggregateWithin: {
       Effect.flatMap((arr) => arr === scheduleStep ? Cause.done() : 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
@@ -13664,7 +13629,7 @@ export const aggregateWithin: {
       return pullFromBuffer
     })
     const catchSinkHalt = Effect.flatMap(([value, leftover_]: Sink.End<B, A2>) => {
-      // ignore the last output if the upsteam only pulled a halt
+      // ignore the last output if the upstream only pulled a halt
       if (!hadChunk && buffer.state._tag === "Done") return Cause.done()
       lastOutput = Option.some(value)
       leftover = leftover_
@@ -13879,12 +13844,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>
   /**
@@ -13923,12 +13888,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>(
@@ -13936,12 +13901,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(
@@ -16121,7 +16086,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: ServiceMap.Key<I, S>, service: NoInfer<S>): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, Exclude<R, I>>
   /**
@@ -16160,10 +16125,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: ServiceMap.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: ServiceMap.Key<I, S>,
   service: NoInfer<S>
 ): Stream<A, E, Exclude<R, I>> => fromChannel(Channel.provideService(self.channel, key, service)))
 
@@ -16244,7 +16209,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: 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>
   /**
@@ -16287,12 +16252,12 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, ES, RS>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.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: ServiceMap.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)))
 
@@ -16477,7 +16442,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: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, R | I>
   /**
@@ -16507,12 +16472,12 @@ export const updateService: {
    */
   <A, E, R, I, S>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.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: ServiceMap.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Stream<A, E, R | I> =>
   updateServices(self, (services) =>
@@ -16591,7 +16556,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))
@@ -17747,7 +17712,7 @@ export const toReadableStreamWith = dual<
   ): ReadableStream<A> => {
     let currentResolve: (() => void) | undefined = undefined
     let fiber: Fiber.Fiber<void, E> | undefined = undefined
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
 
     return new ReadableStream<A>({
       start(controller) {