effect 3.14.21 → 3.15.0

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.14.21";
+let moduleVersion = "3.15.0";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/dist/esm/internal/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":["moduleVersion","getCurrentVersion","setCurrentVersion","version"],"sources":["../../../src/internal/version.ts"],"sourcesContent":[null],"mappings":"AAAA,IAAIA,aAAa,GAAG,SAAS;AAE7B,OAAO,MAAMC,iBAAiB,GAAGA,CAAA,KAAMD,aAAa;AAEpD,OAAO,MAAME,iBAAiB,GAAIC,OAAe,IAAI;EACnDH,aAAa,GAAGG,OAAO;AACzB,CAAC","ignoreList":[]}
+{"version":3,"file":"version.js","names":["moduleVersion","getCurrentVersion","setCurrentVersion","version"],"sources":["../../../src/internal/version.ts"],"sourcesContent":[null],"mappings":"AAAA,IAAIA,aAAa,GAAG,QAAQ;AAE5B,OAAO,MAAMC,iBAAiB,GAAGA,CAAA,KAAMD,aAAa;AAEpD,OAAO,MAAME,iBAAiB,GAAIC,OAAe,IAAI;EACnDH,aAAa,GAAGG,OAAO;AACzB,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.14.21",
+  "version": "3.15.0",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Brand.ts

@@ -18,7 +18,7 @@
  */
 import * as Arr from "./Array.js"
 import * as Either from "./Either.js"
-import { identity } from "./Function.js"
+import { identity, unsafeCoerce } from "./Function.js"
 import * as Option from "./Option.js"
 import type { Predicate } from "./Predicate.js"
 import type * as Types from "./Types.js"
@@ -350,3 +350,11 @@ export const all: <Brands extends readonly [Brand.Constructor<any>, ...Array<Bra
     is: (args: any): args is any => Either.isRight(either(args))
   })
 }
+
+/**
+ * Retrieves the unbranded value from a `Brand` instance.
+ *
+ * @since 3.15.0
+ * @category getters
+ */
+export const unbranded: <A extends Brand<any>>(branded: A) => Brand.Unbranded<A> = unsafeCoerce

package/src/Cause.ts

@@ -1911,6 +1911,14 @@ export const isRuntimeException: (u: unknown) => u is RuntimeException = core.is
  */
 export const TimeoutException: new(message?: string | undefined) => TimeoutException = core.TimeoutException
 
+/**
+ * Checks if a given unknown value is a `TimeoutException`.
+ *
+ * @since 3.15.0
+ * @category Guards
+ */
+export const isTimeoutException: (u: unknown) => u is TimeoutException = core.isTimeoutException
+
 /**
  * Creates an instance of `UnknownException`, an error object used to handle
  * unknown errors such as those from rejected promises.

package/src/ConfigError.ts

@@ -76,6 +76,7 @@ export interface And extends ConfigError.Proto {
   readonly _op: "And"
   readonly left: ConfigError
   readonly right: ConfigError
+  readonly message: string
 }
 
 /**
@@ -86,6 +87,7 @@ export interface Or extends ConfigError.Proto {
   readonly _op: "Or"
   readonly left: ConfigError
   readonly right: ConfigError
+  readonly message: string
 }
 
 /**

package/src/Effect.ts

@@ -60,7 +60,15 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
-import type { Concurrency, Contravariant, Covariant, NoExcessProperties, NoInfer, NotFunction } from "./Types.js"
+import type {
+  Concurrency,
+  Contravariant,
+  Covariant,
+  EqualsWith,
+  NoExcessProperties,
+  NoInfer,
+  NotFunction
+} from "./Types.js"
 import type * as Unify from "./Unify.js"
 import { isGeneratorFunction, type YieldWrap } from "./Utils.js"
 
@@ -7303,7 +7311,9 @@ export const catchTag: {
    * @since 2.0.0
    * @category Error handling
    */
-  <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: NoInfer<Extract<E, { _tag: K }>>) => Effect<A1, E1, R1>): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
+  <E, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect<A1, E1, R1>]
+  ): <A, R>(self: Effect<A, E, R>) => Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
   /**
    * Catches and handles specific errors by their `_tag` field, which is used as a
    * discriminator.
@@ -7361,11 +7371,10 @@ export const catchTag: {
    * @since 2.0.0
    * @category Error handling
    */
-  <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1, A1>(
+  <A, E, R, const K extends RA.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
     self: Effect<A, E, R>,
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect<A1, E1, R1>
-  ): Effect<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1>
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect<A1, E1, R1>]
+  ): Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
 } = effect.catchTag
 
 /**
@@ -9433,51 +9442,10 @@ export const liftPredicate: {
    * @category Condition Checking
    * @since 3.4.0
    */
-  <A, B extends A, E>(refinement: Refinement<A, B>, orFailWith: (a: A) => E): (a: A) => Effect<B, E>
-  /**
-   * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
-   * or failing with specified error if the predicate fails
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * const isPositive = (n: number): boolean => n > 0
-   *
-   * // succeeds with `1`
-   * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`)
-   *
-   * // fails with `"0 is not positive"`
-   * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`)
-   * ```
-   *
-   * @category Condition Checking
-   * @since 3.4.0
-   */
-  <B extends A, E, A = B>(predicate: Predicate<A>, orFailWith: (a: A) => E): (a: B) => Effect<B, E>
-  /**
-   * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
-   * or failing with specified error if the predicate fails
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect } from "effect"
-   *
-   * const isPositive = (n: number): boolean => n > 0
-   *
-   * // succeeds with `1`
-   * Effect.liftPredicate(1, isPositive, n => `${n} is not positive`)
-   *
-   * // fails with `"0 is not positive"`
-   * Effect.liftPredicate(0, isPositive, n => `${n} is not positive`)
-   * ```
-   *
-   * @category Condition Checking
-   * @since 3.4.0
-   */
-  <A, E, B extends A>(self: A, refinement: Refinement<A, B>, orFailWith: (a: A) => E): Effect<B, E>
+  <T extends A, E, B extends T = T, A = T>(
+    predicate: Refinement<T, B> | Predicate<T>,
+    orFailWith: (a: EqualsWith<T, B, A, Exclude<A, B>>) => E
+  ): (a: A) => Effect<EqualsWith<T, B, A, B>, E>
   /**
    * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
    * or failing with specified error if the predicate fails
@@ -9499,7 +9467,11 @@ export const liftPredicate: {
    * @category Condition Checking
    * @since 3.4.0
    */
-  <B extends A, E, A = B>(self: B, predicate: Predicate<A>, orFailWith: (a: A) => E): Effect<B, E>
+  <A, E, B extends A = A>(
+    self: A,
+    predicate: Refinement<A, B> | Predicate<A>,
+    orFailWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ): Effect<B, E>
 } = effect.liftPredicate
 
 /**
@@ -16367,28 +16339,10 @@ export const filterOrDie: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B extends A>(
-    refinement: Refinement<NoInfer<A>, B>,
-    orDieWith: (a: NoInfer<A>) => unknown
+  <A, B extends A = A>(
+    predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>,
+    orDieWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>
-  /**
-   * Filters an effect, dying with a custom defect if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect dies with a custom defect
-   * generated by the `orDieWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints on values and treating violations as
-   * fatal program errors.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A>(predicate: Predicate<NoInfer<A>>, orDieWith: (a: NoInfer<A>) => unknown): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
   /**
    * Filters an effect, dying with a custom defect if the predicate fails.
    *
@@ -16408,31 +16362,9 @@ export const filterOrDie: {
    */
   <A, E, R, B extends A>(
     self: Effect<A, E, R>,
-    refinement: Refinement<A, B>,
-    orDieWith: (a: A) => unknown
+    predicate: Predicate<A> | Refinement<A, B>,
+    orDieWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): Effect<B, E, R>
-  /**
-   * Filters an effect, dying with a custom defect if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, the effect dies with a custom defect
-   * generated by the `orDieWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints on values and treating violations as
-   * fatal program errors.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R>(
-    self: Effect<A, E, R>,
-    predicate: Predicate<A>,
-    orDieWith: (a: A) => unknown
-  ): Effect<A, E, R>
 } = effect.filterOrDie
 
 /**
@@ -16460,33 +16392,10 @@ export const filterOrDieMessage: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>
-  /**
-   * Filters an effect, dying with a custom message if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function works like {@link filterOrDie} but allows you to specify a
-   * custom error message to describe the reason for the failure. The message is
-   * included in the defect when the predicate evaluates to `false`.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
-  /**
-   * Filters an effect, dying with a custom message if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function works like {@link filterOrDie} but allows you to specify a
-   * custom error message to describe the reason for the failure. The message is
-   * included in the defect when the predicate evaluates to `false`.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>, message: string): Effect<B, E, R>
+  <A, B extends A = A>(
+    predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>,
+    message: string
+  ): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>
   /**
    * Filters an effect, dying with a custom message if the predicate fails.
    *
@@ -16499,7 +16408,11 @@ export const filterOrDieMessage: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>, message: string): Effect<A, E, R>
+  <A, E, R, B extends A = A>(
+    self: Effect<A, E, R>,
+    predicate: Predicate<A> | Refinement<A, B>,
+    message: string
+  ): Effect<B, E, R>
 } = effect.filterOrDieMessage
 
 /**
@@ -16529,9 +16442,9 @@ export const filterOrElse: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B extends A, C, E2, R2>(
-    refinement: Refinement<NoInfer<A>, B>,
-    orElse: (a: NoInfer<A>) => Effect<C, E2, R2>
+  <A, C, E2, R2, B extends A = A>(
+    predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>,
+    orElse: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => Effect<C, E2, R2>
   ): <E, R>(self: Effect<A, E, R>) => Effect<B | C, E2 | E, R2 | R>
   /**
    * Filters an effect, providing an alternative effect if the predicate fails.
@@ -16546,46 +16459,11 @@ export const filterOrElse: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B, E2, R2>(
-    predicate: Predicate<NoInfer<A>>,
-    orElse: (a: NoInfer<A>) => Effect<B, E2, R2>
-  ): <E, R>(self: Effect<A, E, R>) => Effect<A | B, E2 | E, R2 | R>
-  /**
-   * Filters an effect, providing an alternative effect if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, it executes the `orElse` effect instead. The
-   * `orElse` effect can produce an alternative value or perform additional
-   * computations.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R, B extends A, C, E2, R2>(
+  <A, E, R, C, E2, R2, B extends A = A>(
     self: Effect<A, E, R>,
-    refinement: Refinement<A, B>,
-    orElse: (a: A) => Effect<C, E2, R2>
+    predicate: Predicate<A> | Refinement<A, B>,
+    orElse: (a: EqualsWith<A, B, A, Exclude<A, B>>) => Effect<C, E2, R2>
   ): Effect<B | C, E | E2, R | R2>
-  /**
-   * Filters an effect, providing an alternative effect if the predicate fails.
-   *
-   * **Details**
-   *
-   * This function applies a predicate to the result of an effect. If the
-   * predicate evaluates to `false`, it executes the `orElse` effect instead. The
-   * `orElse` effect can produce an alternative value or perform additional
-   * computations.
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R, B, E2, R2>(
-    self: Effect<A, E, R>,
-    predicate: Predicate<A>,
-    orElse: (a: A) => Effect<B, E2, R2>
-  ): Effect<A | B, E | E2, R | R2>
 } = effect.filterOrElse
 
 /**
@@ -16689,7 +16567,10 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Effect<A, E, R>) => Effect<B, E2 | E, R>
+  <A, E2, B extends A = A>(
+    predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>,
+    orFailWith: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => 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.
    *
@@ -16740,215 +16621,11 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E2>(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 a custom error
-   * generated by the `orFailWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints and treating violations as
-   * recoverable errors.
-   *
-   * **Providing a Guard**
-   *
-   * In addition to the filtering capabilities discussed earlier, you have the
-   * option to further refine and narrow down the type of the success channel by
-   * providing a [user-defined type
-   * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-   * Let's explore this concept through an example:
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect, pipe } from "effect"
-   *
-   * // Define a user interface
-   * interface User {
-   *   readonly name: string
-   * }
-   *
-   * // Simulate an asynchronous authentication function
-   * declare const auth: () => Promise<User | null>
-   *
-   * const program = pipe(
-   *   Effect.promise(() => auth()),
-   *   // Use filterOrFail with a custom type guard to ensure user is not null
-   *   Effect.filterOrFail(
-   *     (user): user is User => user !== null, // Type guard
-   *     () => new Error("Unauthorized")
-   *   ),
-   *   // 'user' now has the type `User` (not `User | null`)
-   *   Effect.andThen((user) => user.name)
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementException | 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 a custom error
-   * generated by the `orFailWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints and treating violations as
-   * recoverable errors.
-   *
-   * **Providing a Guard**
-   *
-   * In addition to the filtering capabilities discussed earlier, you have the
-   * option to further refine and narrow down the type of the success channel by
-   * providing a [user-defined type
-   * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-   * Let's explore this concept through an example:
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect, pipe } from "effect"
-   *
-   * // Define a user interface
-   * interface User {
-   *   readonly name: string
-   * }
-   *
-   * // Simulate an asynchronous authentication function
-   * declare const auth: () => Promise<User | null>
-   *
-   * const program = pipe(
-   *   Effect.promise(() => auth()),
-   *   // Use filterOrFail with a custom type guard to ensure user is not null
-   *   Effect.filterOrFail(
-   *     (user): user is User => user !== null, // Type guard
-   *     () => new Error("Unauthorized")
-   *   ),
-   *   // 'user' now has the type `User` (not `User | null`)
-   *   Effect.andThen((user) => user.name)
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Effect<A, E, R>) => Effect<A, Cause.NoSuchElementException | 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 a custom error
-   * generated by the `orFailWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints and treating violations as
-   * recoverable errors.
-   *
-   * **Providing a Guard**
-   *
-   * In addition to the filtering capabilities discussed earlier, you have the
-   * option to further refine and narrow down the type of the success channel by
-   * providing a [user-defined type
-   * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-   * Let's explore this concept through an example:
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect, pipe } from "effect"
-   *
-   * // Define a user interface
-   * interface User {
-   *   readonly name: string
-   * }
-   *
-   * // Simulate an asynchronous authentication function
-   * declare const auth: () => Promise<User | null>
-   *
-   * const program = pipe(
-   *   Effect.promise(() => auth()),
-   *   // Use filterOrFail with a custom type guard to ensure user is not null
-   *   Effect.filterOrFail(
-   *     (user): user is User => user !== null, // Type guard
-   *     () => new Error("Unauthorized")
-   *   ),
-   *   // 'user' now has the type `User` (not `User | null`)
-   *   Effect.andThen((user) => user.name)
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R, B extends A, E2>(
+  <A, E, R, E2, B extends A = A>(
     self: Effect<A, E, R>,
-    refinement: Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): Effect<B, E | E2, 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 a custom error
-   * generated by the `orFailWith` function.
-   *
-   * **When to Use**
-   *
-   * This is useful for enforcing constraints and treating violations as
-   * recoverable errors.
-   *
-   * **Providing a Guard**
-   *
-   * In addition to the filtering capabilities discussed earlier, you have the
-   * option to further refine and narrow down the type of the success channel by
-   * providing a [user-defined type
-   * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
-   * Let's explore this concept through an example:
-   *
-   * **Example**
-   *
-   * ```ts
-   * import { Effect, pipe } from "effect"
-   *
-   * // Define a user interface
-   * interface User {
-   *   readonly name: string
-   * }
-   *
-   * // Simulate an asynchronous authentication function
-   * declare const auth: () => Promise<User | null>
-   *
-   * const program = pipe(
-   *   Effect.promise(() => auth()),
-   *   // Use filterOrFail with a custom type guard to ensure user is not null
-   *   Effect.filterOrFail(
-   *     (user): user is User => user !== null, // Type guard
-   *     () => new Error("Unauthorized")
-   *   ),
-   *   // 'user' now has the type `User` (not `User | null`)
-   *   Effect.andThen((user) => user.name)
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category Filtering
-   */
-  <A, E, R, E2>(self: Effect<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Effect<A, E | E2, R>
+    predicate: Predicate<A> | Refinement<A, B>,
+    orFailWith: (a: EqualsWith<A, B, A, Exclude<A, B>>) => E2
+  ): Effect<B, E2 | E, R>
   /**
    * Filters an effect, failing with a custom error if the predicate fails.
    *
@@ -16999,7 +16676,7 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Refinement<A, B>): Effect<B, E | Cause.NoSuchElementException, R>
+  <A, B extends A = A>(predicate: Predicate<NoInfer<A>> | Refinement<NoInfer<A>, B>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementException | E, R>
   /**
    * Filters an effect, failing with a custom error if the predicate fails.
    *
@@ -17050,7 +16727,7 @@ export const filterOrFail: {
    * @since 2.0.0
    * @category Filtering
    */
-  <A, E, R>(self: Effect<A, E, R>, predicate: Predicate<A>): Effect<A, E | Cause.NoSuchElementException, R>
+  <A, E, R, B extends A = A>(self: Effect<A, E, R>, predicate: Predicate<A> | Refinement<A, B>): Effect<B, E | Cause.NoSuchElementException, R>
 } = effect.filterOrFail
 
 /**