effect 4.0.0-beta.17 → 4.0.0-beta.19

package/src/Effect.ts

@@ -763,7 +763,7 @@ export const all: <
 ) => All.Return<Arg, O> = internal.all
 
 /**
- * Applies an effectful function to each element and partitions failures and
+ * Applies an effectful `Filter` to each element and partitions failures and
  * successes.
  *
  * The returned tuple is `[excluded, satisfying]`, where:
@@ -776,10 +776,10 @@ export const all: <
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Effect, Result } from "effect"
  *
  * const program = Effect.partition([0, 1, 2, 3], (n) =>
- *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+ *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
  * )
  *
  * Effect.runPromise(program).then(console.log)
@@ -791,7 +791,7 @@ export const all: <
  */
 export const partition: {
   /**
-   * Applies an effectful function to each element and partitions failures and
+   * Applies an effectful `Filter` to each element and partitions failures and
    * successes.
    *
    * The returned tuple is `[excluded, satisfying]`, where:
@@ -804,10 +804,10 @@ export const partition: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Effect, Result } from "effect"
    *
    * const program = Effect.partition([0, 1, 2, 3], (n) =>
-   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
    * )
    *
    * Effect.runPromise(program).then(console.log)
@@ -817,12 +817,12 @@ export const partition: {
    * @since 3.0.0
    * @category Collecting
    */
-  <A, B, E, R>(
-    f: (a: A, i: number) => Effect<B, E, R>,
+  <A, Pass, Fail, E, R>(
+    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): (elements: Iterable<A>) => Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
   /**
-   * Applies an effectful function to each element and partitions failures and
+   * Applies an effectful `Filter` to each element and partitions failures and
    * successes.
    *
    * The returned tuple is `[excluded, satisfying]`, where:
@@ -835,10 +835,10 @@ export const partition: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Effect, Result } from "effect"
    *
    * const program = Effect.partition([0, 1, 2, 3], (n) =>
-   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   *   Effect.succeed(n % 2 === 0 ? Result.fail(`${n} is even`) : Result.succeed(n))
    * )
    *
    * Effect.runPromise(program).then(console.log)
@@ -848,11 +848,11 @@ export const partition: {
    * @since 3.0.0
    * @category Collecting
    */
-  <A, B, E, R>(
+  <A, Pass, Fail, E, R>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect<B, E, R>,
+    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
 } = internal.partition
 
 /**
@@ -5198,15 +5198,14 @@ export const catchDefect: {
 } = internal.catchDefect
 
 /**
- * Recovers from specific errors using a `Filter`, `Predicate`, or
- * `Refinement`.
+ * Recovers from specific errors using a `Predicate` or `Refinement`.
  *
  * **When to Use**
  *
- * `catchIf` lets you recover from errors that match a condition. Pass a
- * `Filter` for transformation, a `Refinement` for type narrowing, or a
- * `Predicate` for simple boolean matching. Non-matching errors re-fail with
- * the original cause. Defects and interrupts are not caught.
+ * `catchIf` lets you recover from errors that match a condition. Use a
+ * `Refinement` for type narrowing or a `Predicate` for simple boolean
+ * matching. Non-matching errors re-fail with the original cause. Defects and
+ * interrupts are not caught.
  *
  * **Previously Known As**
  *
@@ -5233,7 +5232,7 @@ export const catchDefect: {
  *
  * // With a Filter
  * const recovered2 = program.pipe(
- *   Effect.catchIf(
+ *   Effect.catchFilter(
  *     Filter.tagged("NotFound"),
  *     (error) => Effect.succeed(`missing:${error.id}`)
  *   )
@@ -5245,15 +5244,14 @@ export const catchDefect: {
  */
 export const catchIf: {
   /**
-   * Recovers from specific errors using a `Filter`, `Predicate`, or
-   * `Refinement`.
+   * Recovers from specific errors using a `Predicate` or `Refinement`.
    *
    * **When to Use**
    *
-   * `catchIf` lets you recover from errors that match a condition. Pass a
-   * `Filter` for transformation, a `Refinement` for type narrowing, or a
-   * `Predicate` for simple boolean matching. Non-matching errors re-fail with
-   * the original cause. Defects and interrupts are not caught.
+   * `catchIf` lets you recover from errors that match a condition. Use a
+   * `Refinement` for type narrowing or a `Predicate` for simple boolean
+   * matching. Non-matching errors re-fail with the original cause. Defects and
+   * interrupts are not caught.
    *
    * **Previously Known As**
    *
@@ -5280,7 +5278,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5296,15 +5294,14 @@ export const catchIf: {
     orElse?: ((e: Exclude<E, EB>) => Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect<A, E, R>) => Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
   /**
-   * Recovers from specific errors using a `Filter`, `Predicate`, or
-   * `Refinement`.
+   * Recovers from specific errors using a `Predicate` or `Refinement`.
    *
    * **When to Use**
    *
-   * `catchIf` lets you recover from errors that match a condition. Pass a
-   * `Filter` for transformation, a `Refinement` for type narrowing, or a
-   * `Predicate` for simple boolean matching. Non-matching errors re-fail with
-   * the original cause. Defects and interrupts are not caught.
+   * `catchIf` lets you recover from errors that match a condition. Use a
+   * `Refinement` for type narrowing or a `Predicate` for simple boolean
+   * matching. Non-matching errors re-fail with the original cause. Defects and
+   * interrupts are not caught.
    *
    * **Previously Known As**
    *
@@ -5331,7 +5328,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5341,21 +5338,20 @@ export const catchIf: {
    * @since 2.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: (e: Filter.Pass<E, Result>) => Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect<A3, E3, R3>) | undefined
+  <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    predicate: Predicate.Predicate<NoInfer<E>>,
+    f: (e: NoInfer<E>) => Effect<A2, E2, R2>,
+    orElse?: ((e: NoInfer<E>) => Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect<A, E, R>) => Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
   /**
-   * Recovers from specific errors using a `Filter`, `Predicate`, or
-   * `Refinement`.
+   * Recovers from specific errors using a `Predicate` or `Refinement`.
    *
    * **When to Use**
    *
-   * `catchIf` lets you recover from errors that match a condition. Pass a
-   * `Filter` for transformation, a `Refinement` for type narrowing, or a
-   * `Predicate` for simple boolean matching. Non-matching errors re-fail with
-   * the original cause. Defects and interrupts are not caught.
+   * `catchIf` lets you recover from errors that match a condition. Use a
+   * `Refinement` for type narrowing or a `Predicate` for simple boolean
+   * matching. Non-matching errors re-fail with the original cause. Defects and
+   * interrupts are not caught.
    *
    * **Previously Known As**
    *
@@ -5382,7 +5378,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5399,15 +5395,14 @@ export const catchIf: {
     orElse?: ((e: Exclude<E, EB>) => Effect<A3, E3, R3>) | undefined
   ): Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
   /**
-   * Recovers from specific errors using a `Filter`, `Predicate`, or
-   * `Refinement`.
+   * Recovers from specific errors using a `Predicate` or `Refinement`.
    *
    * **When to Use**
    *
-   * `catchIf` lets you recover from errors that match a condition. Pass a
-   * `Filter` for transformation, a `Refinement` for type narrowing, or a
-   * `Predicate` for simple boolean matching. Non-matching errors re-fail with
-   * the original cause. Defects and interrupts are not caught.
+   * `catchIf` lets you recover from errors that match a condition. Use a
+   * `Refinement` for type narrowing or a `Predicate` for simple boolean
+   * matching. Non-matching errors re-fail with the original cause. Defects and
+   * interrupts are not caught.
    *
    * **Previously Known As**
    *
@@ -5434,7 +5429,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5444,14 +5439,46 @@ export const catchIf: {
    * @since 2.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: Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<E>, Result>,
-    f: (e: Filter.Pass<E, Result>) => Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect<A3, E3, R3>) | undefined
+    predicate: Predicate.Predicate<E>,
+    f: (e: E) => Effect<A2, E2, R2>,
+    orElse?: ((e: E) => Effect<A3, E3, R3>) | undefined
   ): Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
 } = internal.catchIf
 
+/**
+ * Recovers from specific errors using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchFilter: {
+  /**
+   * Recovers from specific errors using a `Filter`.
+   *
+   * @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: (e: EB) => Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect<A3, E3, R3>) | undefined
+  ): <A, R>(self: Effect<A, E, R>) => Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+  /**
+   * Recovers from specific errors using a `Filter`.
+   *
+   * @since 4.0.0
+   * @category Error Handling
+   */
+  <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
+    f: (e: EB) => Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect<A3, E3, R3>) | undefined
+  ): Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+} = internal.catchFilter
+
 /**
  * Catches `NoSuchElementError` failures and converts them to `Option.none`.
  *
@@ -5559,10 +5586,10 @@ export const catchCauseIf: {
    * @since 4.0.0
    * @category Error Handling
    */
-  <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<B, E2, R2>
-  ): <A, R>(self: Effect<A, E, R>) => Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): <A, R>(self: Effect<A, E, R>) => Effect<A | B, E | E2, R | R2>
   /**
    * Recovers from specific failures based on a predicate.
    *
@@ -5601,13 +5628,43 @@ export const catchCauseIf: {
    * @since 4.0.0
    * @category Error Handling
    */
-  <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
+  <A, E, R, B, E2, R2>(
     self: Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<B, E2, R2>
-  ): Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): Effect<A | B, E | E2, R | R2>
 } = internal.catchCauseIf
 
+/**
+ * Recovers from specific failures based on a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchCauseFilter: {
+  /**
+   * Recovers from specific failures based on a `Filter`.
+   *
+   * @since 4.0.0
+   * @category Error Handling
+   */
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): <A, R>(self: Effect<A, E, R>) => Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
+  /**
+   * Recovers from specific failures based on a `Filter`.
+   *
+   * @since 4.0.0
+   * @category Error Handling
+   */
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
+} = internal.catchCauseFilter
+
 /**
  * The `mapError` function is used to transform or modify the error
  * produced by an effect, without affecting its success value.
@@ -6233,9 +6290,9 @@ export const tapCauseIf: {
    * @since 4.0.0
    * @category Sequencing
    */
-  <E, Result extends Filter.ResultOrBool, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>
   /**
    * Conditionally executes a side effect based on the cause of a failed effect.
@@ -6265,13 +6322,43 @@ export const tapCauseIf: {
    * @since 4.0.0
    * @category Sequencing
    */
-  <A, E, R, Result extends Filter.ResultOrBool, B, E2, R2>(
+  <A, E, R, B, E2, R2>(
     self: Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>
   ): Effect<A, E | E2, R | R2>
 } = internal.tapCauseIf
 
+/**
+ * Conditionally executes a side effect based on the cause of a failed effect.
+ *
+ * @since 4.0.0
+ * @category Sequencing
+ */
+export const tapCauseFilter: {
+  /**
+   * Conditionally executes a side effect based on the cause of a failed effect.
+   *
+   * @since 4.0.0
+   * @category Sequencing
+   */
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>
+  /**
+   * Conditionally executes a side effect based on the cause of a failed effect.
+   *
+   * @since 4.0.0
+   * @category Sequencing
+   */
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>
+  ): Effect<A, E | E2, R | R2>
+} = internal.tapCauseFilter
+
 /**
  * Inspect severe errors or defects (non-recoverable failures) in an effect.
  *
@@ -8308,12 +8395,12 @@ export const raceFirst: {
 // -----------------------------------------------------------------------------
 
 /**
- * Filters elements of an iterable using a predicate, refinement, effectful
- * predicate, or `Filter.FilterEffect`.
+ * Filters elements of an iterable using a predicate, refinement, or effectful
+ * predicate.
  *
  * @example
  * ```ts
- * import { Effect, Filter, Result } from "effect"
+ * import { Effect } from "effect"
  *
  * // Sync predicate
  * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8321,10 +8408,7 @@ export const raceFirst: {
  * // Effectful predicate
  * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
  *
- * // FilterEffect
- * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
- *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
- * )
+ * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
  * ```
  *
  * @since 2.0.0
@@ -8336,12 +8420,12 @@ export const filter: {
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8349,10 +8433,7 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
@@ -8364,12 +8445,12 @@ export const filter: {
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8377,10 +8458,7 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
@@ -8392,12 +8470,12 @@ export const filter: {
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8405,30 +8483,27 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B, X>(
-    filter: Filter.Filter<NoInfer<A>, B, X>,
+  <A, E, R>(
+    predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect<Array<B>>
+  ): (iterable: Iterable<A>) => Effect<Array<A>, E, R>
   // -----------------------------------------------------------------------------
   // Filtering
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8436,30 +8511,24 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B, X, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect<Array<B>, E, R>
+  <A, B extends A>(elements: Iterable<A>, refinement: Predicate.Refinement<A, B>): Effect<Array<B>>
   // -----------------------------------------------------------------------------
   // Filtering
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8467,30 +8536,24 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R>(
-    predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): (iterable: Iterable<A>) => Effect<Array<A>, E, R>
+  <A>(elements: Iterable<A>, predicate: Predicate.Predicate<A>): Effect<Array<A>>
   // -----------------------------------------------------------------------------
   // Filtering
   // -----------------------------------------------------------------------------
 
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters elements of an iterable using a predicate, refinement, or effectful
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * import { Effect } from "effect"
    *
    * // Sync predicate
    * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
@@ -8498,137 +8561,71 @@ export const filter: {
    * // Effectful predicate
    * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
    *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
+   * // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
    * ```
    *
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B extends A>(elements: Iterable<A>, refinement: Predicate.Refinement<A, B>): Effect<Array<B>>
-  // -----------------------------------------------------------------------------
-  // Filtering
-  // -----------------------------------------------------------------------------
+  <A, E, R>(
+    iterable: Iterable<A>,
+    predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): Effect<Array<A>, E, R>
+} = internal.filter
 
+/**
+ * Filters and maps elements of an iterable with a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap: {
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
-   *
-   * @example
-   * ```ts
-   * import { Effect, Filter, Result } from "effect"
+   * Filters and maps elements of an iterable with a `Filter`.
    *
-   * // Sync predicate
-   * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-   *
-   * // Effectful predicate
-   * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-   *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
-   * ```
-   *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
-  <A>(elements: Iterable<A>, predicate: Predicate.Predicate<A>): Effect<Array<A>>
-  // -----------------------------------------------------------------------------
-  // Filtering
-  // -----------------------------------------------------------------------------
-
+  <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): (elements: Iterable<A>) => Effect<Array<B>>
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Filters and maps elements of an iterable with a `Filter`.
    *
-   * @example
-   * ```ts
-   * import { Effect, Filter, Result } from "effect"
-   *
-   * // Sync predicate
-   * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-   *
-   * // Effectful predicate
-   * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-   *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
-   * ```
-   *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
   <A, B, X>(elements: Iterable<A>, filter: Filter.Filter<NoInfer<A>, B, X>): Effect<Array<B>>
-  // -----------------------------------------------------------------------------
-  // Filtering
-  // -----------------------------------------------------------------------------
+} = internal.filterMap
 
+/**
+ * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect: {
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
-   *
-   * @example
-   * ```ts
-   * import { Effect, Filter, Result } from "effect"
-   *
-   * // Sync predicate
-   * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-   *
-   * // Effectful predicate
-   * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-   *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
-   * ```
+   * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
    *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
   <A, B, X, E, R>(
-    elements: Iterable<A>,
     filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect<Array<B>, E, R>
-  // -----------------------------------------------------------------------------
-  // Filtering
-  // -----------------------------------------------------------------------------
-
+  ): (elements: Iterable<A>) => Effect<Array<B>, E, R>
   /**
-   * Filters elements of an iterable using a predicate, refinement, effectful
-   * predicate, or `Filter.FilterEffect`.
+   * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
    *
-   * @example
-   * ```ts
-   * import { Effect, Filter, Result } from "effect"
-   *
-   * // Sync predicate
-   * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-   *
-   * // Effectful predicate
-   * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-   *
-   * // FilterEffect
-   * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-   *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-   * )
-   * ```
-   *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
-  <A, E, R>(
-    iterable: Iterable<A>,
-    predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>,
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect<Array<A>, E, R>
-} = internal.filter
+  ): Effect<Array<B>, E, R>
+} = internal.filterMapEffect
 
 /**
  * Filters an effect, providing an alternative effect if the predicate fails.
@@ -8725,10 +8722,10 @@ export const filterOrElse: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, Result extends Filter.ResultOrBool, C, E2, R2>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect<C, E2, R2>
-  ): <E, R>(self: Effect<A, E, R>) => Effect<Filter.Pass<A, Result> | C, E2 | E, R2 | R>
+  <A, C, E2, R2>(
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect<C, E2, R2>
+  ): <E, R>(self: Effect<A, E, R>) => Effect<A | C, E2 | E, R2 | R>
   /**
    * Filters an effect, providing an alternative effect if the predicate fails.
    *
@@ -8794,13 +8791,43 @@ export const filterOrElse: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R, Result extends Filter.ResultOrBool, C, E2, R2>(
+  <A, E, R, C, E2, R2>(
     self: Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect<C, E2, R2>
-  ): Effect<Filter.Pass<A, Result> | C, E | E2, R | R2>
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect<C, E2, R2>
+  ): Effect<A | C, E | E2, R | R2>
 } = internal.filterOrElse
 
+/**
+ * Filters an effect with a `Filter`, providing an alternative effect on failure.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapOrElse: {
+  /**
+   * Filters an effect with a `Filter`, providing an alternative effect on failure.
+   *
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <A, B, X, C, E2, R2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect<C, E2, R2>
+  ): <E, R>(self: Effect<A, E, R>) => Effect<B | C, E2 | E, R2 | R>
+  /**
+   * Filters an effect with a `Filter`, providing an alternative effect on failure.
+   *
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <A, E, R, B, X, C, E2, R2>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect<C, E2, R2>
+  ): Effect<B | C, E | E2, R | R2>
+} = internal.filterMapOrElse
+
 /**
  * Filters an effect, failing with a custom error if the predicate fails.
  *
@@ -8897,36 +8924,6 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): <E, R>(self: Effect<A, E, R>) => Effect<A, E2 | E, R>
-  /**
-   * Filters an effect, failing with a custom error if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect fails with either a custom
-   * error (if `orFailWith` is provided) or a `NoSuchElementError`.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * // An effect that produces a number
-   * const program = Effect.succeed(5)
-   *
-   * // Filter for even numbers, fail for odd numbers
-   * const filtered = Effect.filterOrFail(
-   *   program,
-   *   (n) => n % 2 === 0,
-   *   (n) => `Expected even number, got ${n}`
-   * )
-   *
-   * // Result: Effect.fail("Expected even number, got 5")
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, B, X, E2>(filter: Filter.Filter<NoInfer<A>, B, X>, orFailWith: (x: X) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>
   /**
    * Filters an effect, failing with a custom error if the predicate fails.
    *
@@ -8987,36 +8984,6 @@ export const filterOrFail: {
    * @category Filtering
    */
   <A>(predicate: Predicate.Predicate<NoInfer<A>>): <E, R>(self: Effect<A, E, R>) => Effect<A, Cause.NoSuchElementError | E, R>
-  /**
-   * Filters an effect, failing with a custom error if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect fails with either a custom
-   * error (if `orFailWith` is provided) or a `NoSuchElementError`.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * // An effect that produces a number
-   * const program = Effect.succeed(5)
-   *
-   * // Filter for even numbers, fail for odd numbers
-   * const filtered = Effect.filterOrFail(
-   *   program,
-   *   (n) => n % 2 === 0,
-   *   (n) => `Expected even number, got ${n}`
-   * )
-   *
-   * // Result: Effect.fail("Expected even number, got 5")
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementError | E, R>
   /**
    * Filters an effect, failing with a custom error if the predicate fails.
    *
@@ -9114,11 +9081,7 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R, B, X, E2>(
-    self: Effect<A, E, R>,
-    filter: Filter.Filter<A, B, X>,
-    orFailWith: (x: X) => E2
-  ): Effect<B, E2 | E, R>
+  <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>): Effect<B, E | Cause.NoSuchElementError, R>
   /**
    * Filters an effect, failing with a custom error if the predicate fails.
    *
@@ -9148,68 +9111,49 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>): Effect<B, E | Cause.NoSuchElementError, R>
+  <A, E, R>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>): Effect<A, E | Cause.NoSuchElementError, R>
+} = internal.filterOrFail
+
+/**
+ * Filters an effect with a `Filter`, failing when the filter fails.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapOrFail: {
   /**
-   * Filters an effect, failing with a custom error if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect fails with either a custom
-   * error (if `orFailWith` is provided) or a `NoSuchElementError`.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * // An effect that produces a number
-   * const program = Effect.succeed(5)
+   * Filters an effect with a `Filter`, failing when the filter fails.
    *
-   * // Filter for even numbers, fail for odd numbers
-   * const filtered = Effect.filterOrFail(
-   *   program,
-   *   (n) => n % 2 === 0,
-   *   (n) => `Expected even number, got ${n}`
-   * )
-   *
-   * // Result: Effect.fail("Expected even number, got 5")
-   * ```
-   *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
-  <A, E, R>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>): Effect<A, E | Cause.NoSuchElementError, R>
+  <A, B, X, E2>(filter: Filter.Filter<NoInfer<A>, B, X>, orFailWith: (x: X) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>
   /**
-   * Filters an effect, failing with a custom error if the predicate fails.
+   * Filters an effect with a `Filter`, failing when the filter fails.
    *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect fails with either a custom
-   * error (if `orFailWith` is provided) or a `NoSuchElementError`.
-   *
-   * @example
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * // An effect that produces a number
-   * const program = Effect.succeed(5)
-   *
-   * // Filter for even numbers, fail for odd numbers
-   * const filtered = Effect.filterOrFail(
-   *   program,
-   *   (n) => n % 2 === 0,
-   *   (n) => `Expected even number, got ${n}`
-   * )
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementError | E, R>
+  /**
+   * Filters an effect with a `Filter`, failing when the filter fails.
    *
-   * // Result: Effect.fail("Expected even number, got 5")
-   * ```
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <A, E, R, B, X, E2>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<A, B, X>,
+    orFailWith: (x: X) => E2
+  ): Effect<B, E2 | E, R>
+  /**
+   * Filters an effect with a `Filter`, failing when the filter fails.
    *
-   * @since 2.0.0
+   * @since 4.0.0
    * @category Filtering
    */
-  <A, E, R, B, X>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>): Effect<B, E | Cause.NoSuchElementError, R>
-} = internal.filterOrFail
+  <A, E, R, B, X>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>): Effect<B, Cause.NoSuchElementError | E, R>
+} = internal.filterMapOrFail
 
 // -----------------------------------------------------------------------------
 // Conditional Operators
@@ -12160,7 +12104,7 @@ export const onError: {
 
 /**
  * Runs the finalizer only when this effect fails and the `Cause` matches the
- * filter, passing the filtered failure and the original cause.
+ * provided predicate.
  *
  * @example
  * ```ts
@@ -12184,7 +12128,7 @@ export const onError: {
 export const onErrorIf: {
   /**
    * Runs the finalizer only when this effect fails and the `Cause` matches the
-   * filter, passing the filtered failure and the original cause.
+   * provided predicate.
    *
    * @example
    * ```ts
@@ -12205,13 +12149,13 @@ export const onErrorIf: {
    * @since 4.0.0
    * @category Resource Management & Finalization
    */
-  <E, Result extends Filter.ResultOrBool, XE, XR>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<void, XE, XR>
+  <E, XE, XR>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<void, XE, XR>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | XR>
   /**
    * Runs the finalizer only when this effect fails and the `Cause` matches the
-   * filter, passing the filtered failure and the original cause.
+   * provided predicate.
    *
    * @example
    * ```ts
@@ -12232,13 +12176,43 @@ export const onErrorIf: {
    * @since 4.0.0
    * @category Resource Management & Finalization
    */
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect<void, XE, XR>
   ): Effect<A, E | XE, R | XR>
 } = internal.onErrorIf
 
+/**
+ * Runs the finalizer only when this effect fails and the cause matches the provided `Filter`.
+ *
+ * @since 4.0.0
+ * @category Resource Management & Finalization
+ */
+export const onErrorFilter: {
+  /**
+   * Runs the finalizer only when this effect fails and the cause matches the provided `Filter`.
+   *
+   * @since 4.0.0
+   * @category Resource Management & Finalization
+   */
+  <A, E, EB, X, XE, XR>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect<void, XE, XR>
+  ): <R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | XR>
+  /**
+   * Runs the finalizer only when this effect fails and the cause matches the provided `Filter`.
+   *
+   * @since 4.0.0
+   * @category Resource Management & Finalization
+   */
+  <A, E, R, EB, X, XE, XR>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect<void, XE, XR>
+  ): Effect<A, E | XE, R | XR>
+} = internal.onErrorFilter
+
 /**
  * The low level primitive that powers `onExit`.
  * function is used to run a finalizer when the effect exits, regardless of the
@@ -12337,20 +12311,20 @@ export const onExit: {
 } = internal.onExit
 
 /**
- * Runs the cleanup effect only when the `Exit` passes the provided filter.
- *
- * The cleanup is skipped when the filter returns `Filter.fail`.
+ * Runs the cleanup effect only when the `Exit` satisfies the provided
+ * predicate.
  *
  * @example
  * ```ts
- * import { Console, Effect, Exit, Filter } from "effect"
- *
- * const exitFilter = Filter.fromPredicate(Exit.isSuccess<number, never>)
+ * import { Console, Effect, Exit } from "effect"
  *
  * const program = Effect.onExitIf(
  *   Effect.succeed(42),
- *   exitFilter,
- *   (success) => Console.log(`Succeeded with: ${success.value}`)
+ *   Exit.isSuccess,
+ *   (exit) =>
+ *     Exit.isSuccess(exit)
+ *       ? Console.log(`Succeeded with: ${exit.value}`)
+ *       : Effect.void
  * )
  * ```
  *
@@ -12359,64 +12333,88 @@ export const onExit: {
  */
 export const onExitIf: {
   /**
-   * Runs the cleanup effect only when the `Exit` passes the provided filter.
-   *
-   * The cleanup is skipped when the filter returns `Filter.fail`.
+   * Runs the cleanup effect only when the `Exit` satisfies the provided
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Console, Effect, Exit, Filter } from "effect"
-   *
-   * const exitFilter = Filter.fromPredicate(Exit.isSuccess<number, never>)
+   * import { Console, Effect, Exit } from "effect"
    *
    * const program = Effect.onExitIf(
    *   Effect.succeed(42),
-   *   exitFilter,
-   *   (success) => Console.log(`Succeeded with: ${success.value}`)
+   *   Exit.isSuccess,
+   *   (exit) =>
+   *     Exit.isSuccess(exit)
+   *       ? Console.log(`Succeeded with: ${exit.value}`)
+   *       : Effect.void
    * )
    * ```
    *
    * @since 4.0.0
    * @category Resource Management & Finalization
    */
-  <A, E, XE, XR, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect<void, XE, XR>
+  <A, E, XE, XR>(
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect<void, XE, XR>
   ): <R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | XR>
   /**
-   * Runs the cleanup effect only when the `Exit` passes the provided filter.
-   *
-   * The cleanup is skipped when the filter returns `Filter.fail`.
+   * Runs the cleanup effect only when the `Exit` satisfies the provided
+   * predicate.
    *
    * @example
    * ```ts
-   * import { Console, Effect, Exit, Filter } from "effect"
-   *
-   * const exitFilter = Filter.fromPredicate(Exit.isSuccess<number, never>)
+   * import { Console, Effect, Exit } from "effect"
    *
    * const program = Effect.onExitIf(
    *   Effect.succeed(42),
-   *   exitFilter,
-   *   (success) => Console.log(`Succeeded with: ${success.value}`)
+   *   Exit.isSuccess,
+   *   (exit) =>
+   *     Exit.isSuccess(exit)
+   *       ? Console.log(`Succeeded with: ${exit.value}`)
+   *       : Effect.void
    * )
    * ```
    *
    * @since 4.0.0
    * @category Resource Management & Finalization
    */
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect<A, E, R>,
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect<void, XE, XR>
   ): Effect<A, E | XE, R | XR>
 } = internal.onExitIf
 
+/**
+ * Runs the cleanup effect only when the `Exit` matches the provided `Filter`.
+ *
+ * @since 4.0.0
+ * @category Resource Management & Finalization
+ */
+export const onExitFilter: {
+  /**
+   * Runs the cleanup effect only when the `Exit` matches the provided `Filter`.
+   *
+   * @since 4.0.0
+   * @category Resource Management & Finalization
+   */
+  <A, E, XE, XR, B, X>(
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect<void, XE, XR>
+  ): <R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | XR>
+  /**
+   * Runs the cleanup effect only when the `Exit` matches the provided `Filter`.
+   *
+   * @since 4.0.0
+   * @category Resource Management & Finalization
+   */
+  <A, E, R, XE, XR, B, X>(
+    self: Effect<A, E, R>,
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect<void, XE, XR>
+  ): Effect<A, E | XE, R | XR>
+} = internal.onExitFilter
+
 // -----------------------------------------------------------------------------
 // Caching
 // -----------------------------------------------------------------------------
@@ -22381,136 +22379,70 @@ export class Transaction extends ServiceMap.Service<
 >()("effect/Effect/Transaction") {}
 
 /**
- * Defines a transaction. Transactions are "all or nothing" with respect to changes made to
- * transactional values (i.e. TxRef) that occur within the transaction body.
+ * Accesses the current transaction state within an active transaction.
  *
- * In Effect transactions are optimistic with retry, that means transactions are retried when:
- *
- * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
- *   accessed transactional values changes.
- *
- * - any of the accessed transactional values change during the execution of the transaction
- *   due to a different transaction committing before the current.
- *
- * - parent transaction retry, if you have a transaction within another transaction and
- *   the parent retries the child will also retry together with the parent.
+ * This function requires `Transaction` in the context and does NOT create or strip
+ * transaction boundaries. Use it to interact with the transaction journal (e.g. in
+ * `TxRef` internals). To define a transaction boundary, use {@link transaction}.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* TxRef.make(0)
- *   const ref2 = yield* TxRef.make(0)
- *
- *   // All operations within atomic block succeed or fail together
- *   yield* Effect.atomic(Effect.gen(function*() {
- *     yield* TxRef.set(ref1, 10)
- *     yield* TxRef.set(ref2, 20)
- *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
- *     console.log(`Transaction sum: ${sum}`)
- *   }))
- *
- *   console.log(`Final ref1: ${yield* TxRef.get(ref1)}`) // 10
- *   console.log(`Final ref2: ${yield* TxRef.get(ref2)}`) // 20
- * })
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export const atomic = <A, E, R>(
-  effect: Effect<A, E, R>
-): Effect<A, E, Exclude<R, Transaction>> => atomicWith(() => effect)
-
-/**
- * Executes a function within a transaction context, providing access to the transaction state.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * const program = Effect.atomicWith((txState) =>
- *   Effect.gen(function*() {
- *     const ref = yield* TxRef.make(0)
- *
- *     // Access transaction state for debugging
- *     console.log(`Journal size: ${txState.journal.size}`)
- *     console.log(`Retry flag: ${txState.retry}`)
+ *   const ref = yield* Effect.transaction(TxRef.make(0))
  *
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     yield* TxRef.set(ref, 42)
  *     return yield* TxRef.get(ref)
- *   })
- * )
- *
- * Effect.runPromise(program).then(console.log) // 42
+ *   }))
+ * })
  * ```
  *
  * @since 4.0.0
  * @category Transactions
  */
-export const atomicWith = <A, E, R>(
+export const withTxState = <A, E, R>(
   f: (state: Transaction["Service"]) => Effect<A, E, R>
-): Effect<A, E, Exclude<R, Transaction>> =>
-  withFiber((fiber) => {
-    // Check if transaction already exists and reuse it (composing behavior)
-    if (fiber.services.mapUnsafe.has(Transaction.key)) {
-      return internalCall(() => f(ServiceMap.getUnsafe(fiber.services, Transaction))) as Effect<
-        A,
-        E,
-        Exclude<R, Transaction>
-      >
-    }
-    // No existing transaction, create isolated one using transactionWith
-    return transactionWith(f)
-  })
+): Effect<A, E, R | Transaction> =>
+  flatMap(
+    Transaction.asEffect(),
+    (state) => internalCall(() => f(state))
+  )
 
 /**
- * Creates an isolated transaction that never composes with parent transactions.
+ * Defines a transaction boundary. Transactions are "all or nothing" with respect to changes
+ * made to transactional values (i.e. TxRef) that occur within the transaction body.
  *
- * **Details**
+ * In Effect transactions are optimistic with retry, that means transactions are retried when:
  *
- * Unlike `Effect.atomic`, which composes with parent transactions when nested,
- * `Effect.transaction` always creates a new isolated transaction boundary.
- * This ensures complete isolation between different transaction scopes.
+ * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
+ *   accessed transactional values changes.
  *
- * **Key Differences from Effect.atomic:**
- * - Always creates a new transaction, even when called within another transaction
- * - Parent transaction failures don't affect isolated transactions
- * - Isolated transaction failures don't affect parent transactions
- * - Each transaction has its own journal and retry logic
+ * - any of the accessed transactional values change during the execution of the transaction
+ *   due to a different transaction committing before the current.
  *
- * **When to Use:**
- * - When you need guaranteed isolation between transaction scopes
- * - For implementing independent operations that shouldn't be affected by outer transactions
- * - When building transaction-based systems where isolation is critical
+ * Each call to `transaction` always creates a new isolated transaction boundary with its own
+ * journal and retry logic.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* TxRef.make(0)
- *   const ref2 = yield* TxRef.make(100)
+ *   const ref1 = yield* Effect.transaction(TxRef.make(0))
+ *   const ref2 = yield* Effect.transaction(TxRef.make(0))
  *
- *   // Nested atomic transaction - ref1 will be part of outer transaction
- *   yield* Effect.atomic(Effect.gen(function*() {
- *     yield* TxRef.set(ref1, 10)
- *
- *     // This atomic operation composes with the parent
- *     yield* Effect.atomic(Effect.gen(function*() {
- *       yield* TxRef.set(ref1, 20) // Part of same transaction
- *     }))
- *   }))
- *
- *   // Isolated transaction - ref2 will be in its own transaction
+ *   // All operations within transaction block succeed or fail together
  *   yield* Effect.transaction(Effect.gen(function*() {
- *     yield* TxRef.set(ref2, 200)
+ *     yield* TxRef.set(ref1, 10)
+ *     yield* TxRef.set(ref2, 20)
+ *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
+ *     console.log(`Transaction sum: ${sum}`)
  *   }))
  *
- *   const val1 = yield* TxRef.get(ref1) // 20
- *   const val2 = yield* TxRef.get(ref2) // 200
- *   return { ref1: val1, ref2: val2 }
+ *   console.log(`Final ref1: ${yield* Effect.transaction(TxRef.get(ref1))}`) // 10
+ *   console.log(`Final ref2: ${yield* Effect.transaction(TxRef.get(ref2))}`) // 20
  * })
  * ```
  *
@@ -22522,34 +22454,21 @@ export const transaction = <A, E, R>(
 ): Effect<A, E, Exclude<R, Transaction>> => transactionWith(() => effect)
 
 /**
- * Executes a function within an isolated transaction context, providing access to the transaction state.
+ * Like {@link transaction} but provides access to the transaction state.
  *
- * This function always creates a new transaction boundary, regardless of whether it's called
- * within another transaction. This ensures complete isolation between transaction scopes.
+ * Always creates a new isolated transaction boundary with its own journal and retry logic.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
- * const program = Effect.transactionWith((txState) =>
+ * const program = Effect.transactionWith((_txState) =>
  *   Effect.gen(function*() {
  *     const ref = yield* TxRef.make(0)
- *
- *     // This transaction is isolated - it has its own journal
- *     // txState.journal is independent of any parent transaction
- *
  *     yield* TxRef.set(ref, 42)
  *     return yield* TxRef.get(ref)
  *   })
  * )
- *
- * // Even when nested in another atomic block, this transaction is isolated
- * const nestedProgram = Effect.atomic(
- *   Effect.gen(function*() {
- *     const result = yield* program // Runs in its own isolated transaction
- *     return result
- *   })
- * )
  * ```
  *
  * @since 4.0.0
@@ -22657,16 +22576,16 @@ function clearTransaction(state: Transaction["Service"]) {
  *
  * const program = Effect.gen(function*() {
  *   // create a transactional reference
- *   const ref = yield* TxRef.make(0)
+ *   const ref = yield* Effect.transaction(TxRef.make(0))
  *
  *   // forks a fiber that increases the value of `ref` every 100 millis
  *   yield* Effect.forkChild(Effect.forever(
  *     // update to transactional value
- *     TxRef.update(ref, (n) => n + 1).pipe(Effect.delay("100 millis"))
+ *     Effect.transaction(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
  *   ))
  *
  *   // the following will retry 10 times until the `ref` value is 10
- *   yield* Effect.atomic(Effect.gen(function*() {
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     const value = yield* TxRef.get(ref)
  *     if (value < 10) {
  *       yield* Effect.log(`retry due to value: ${value}`)