effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/Effect.ts

@@ -40,12 +40,14 @@
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Effect that may fail
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Division by zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(a / b)
  *
  * // Error handling
@@ -84,7 +86,7 @@ import * as internalRequest from "./internal/request.ts"
 import * as internalSchedule from "./internal/schedule.ts"
 import type * as Layer from "./Layer.ts"
 import type { Logger } from "./Logger.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as Metric from "./Metric.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -116,9 +118,12 @@ import type {
   ExcludeTag,
   ExtractReason,
   ExtractTag,
+  NarrowReason,
   NoInfer,
+  OmitReason,
   ReasonOf,
   ReasonTags,
+  Simplify,
   Tags,
   unassigned
 } from "./Types.ts"
@@ -143,13 +148,15 @@ const TypeId = core.EffectTypeId
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * // A simple effect that succeeds with a value
  * const success = Effect.succeed(42)
  *
- * // An effect that may fail
- * const risky = Effect.fail(new Error("Something went wrong"))
+ * // An effect that will always fail
+ * const risky = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * // Effects can be composed using generator functions
  * const program = Effect.gen(function*() {
@@ -430,13 +437,15 @@ export declare namespace All {
    * @category Models
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class OopsError extends Data.TaggedError("OopsError")<{}> {}
    *
    * // EffectAny represents an Effect with any type parameters
    * const effects: Array<Effect.All.EffectAny> = [
    *   Effect.succeed(42),
    *   Effect.succeed("hello"),
-   *   Effect.fail(new Error("oops"))
+   *   Effect.fail(new OopsError())
    * ]
    * ```
    */
@@ -740,7 +749,6 @@ export declare namespace All {
  * ```
  *
  * @see {@link forEach} for iterating over elements and applying an effect.
- * @see {@link allWith} for a data-last version of this function.
  *
  * @since 2.0.0
  * @category Collecting
@@ -852,6 +860,316 @@ export const partition: {
   ): Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
 } = internal.partition
 
+/**
+ * Applies an effectful function to each element and accumulates all failures.
+ *
+ * This function always evaluates every element. If at least one effect fails,
+ * all failures are returned as a non-empty array and successes are discarded.
+ * If all effects succeed, it returns all collected successes.
+ *
+ * Use `discard: true` to ignore successful values while still validating all
+ * elements.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.validate([0, 1, 2, 3], (n) =>
+ *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+ * )
+ *
+ * Effect.runPromiseExit(program).then(console.log)
+ * // {
+ * //   _id: 'Exit',
+ * //   _tag: 'Failure',
+ * //   cause: {
+ * //     _id: 'Cause',
+ * //     reasons: [
+ * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+ * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+ * //     ]
+ * //   }
+ * // }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Error Accumulation
+ */
+export const validate: {
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): (elements: Iterable<A>) => Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): (elements: Iterable<A>) => Effect<void, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  /**
+   * Applies an effectful function to each element and accumulates all failures.
+   *
+   * This function always evaluates every element. If at least one effect fails,
+   * all failures are returned as a non-empty array and successes are discarded.
+   * If all effects succeed, it returns all collected successes.
+   *
+   * Use `discard: true` to ignore successful values while still validating all
+   * elements.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.validate([0, 1, 2, 3], (n) =>
+   *   n % 2 === 0 ? Effect.fail(`${n} is even`) : Effect.succeed(n)
+   * )
+   *
+   * Effect.runPromiseExit(program).then(console.log)
+   * // {
+   * //   _id: 'Exit',
+   * //   _tag: 'Failure',
+   * //   cause: {
+   * //     _id: 'Cause',
+   * //     reasons: [
+   * //       { _id: 'Reason', _tag: 'Fail', error: '0 is even' },
+   * //       { _id: 'Reason', _tag: 'Fail', error: '2 is even' }
+   * //     ]
+   * //   }
+   * // }
+   * ```
+   *
+   * @since 4.0.0
+   * @category Error Accumulation
+   */
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Effect<void, Arr.NonEmptyArray<E>, R>
+} = internal.validate
+
+/**
+ * Returns the first element that satisfies an effectful predicate.
+ *
+ * The predicate receives the element and its index. Evaluation short-circuits
+ * as soon as an element matches.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.findFirst([1, 2, 3, 4], (n) => Effect.succeed(n > 2))
+ *
+ * Effect.runPromise(program).then(console.log)
+ * // { _id: 'Option', _tag: 'Some', value: 3 }
+ * ```
+ *
+ * @since 2.0.0
+ * @category Collecting
+ */
+export const findFirst: {
+  /**
+   * Returns the first element that satisfies an effectful predicate.
+   *
+   * The predicate receives the element and its index. Evaluation short-circuits
+   * as soon as an element matches.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.findFirst([1, 2, 3, 4], (n) => Effect.succeed(n > 2))
+   *
+   * Effect.runPromise(program).then(console.log)
+   * // { _id: 'Option', _tag: 'Some', value: 3 }
+   * ```
+   *
+   * @since 2.0.0
+   * @category Collecting
+   */
+  <A, E, R>(predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>): (elements: Iterable<A>) => Effect<Option<A>, E, R>
+  /**
+   * Returns the first element that satisfies an effectful predicate.
+   *
+   * The predicate receives the element and its index. Evaluation short-circuits
+   * as soon as an element matches.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.findFirst([1, 2, 3, 4], (n) => Effect.succeed(n > 2))
+   *
+   * Effect.runPromise(program).then(console.log)
+   * // { _id: 'Option', _tag: 'Some', value: 3 }
+   * ```
+   *
+   * @since 2.0.0
+   * @category Collecting
+   */
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>
+  ): Effect<Option<A>, E, R>
+} = internal.findFirst
+
+/**
+ * Returns the first value that passes an effectful `FilterEffect`.
+ *
+ * The filter receives the element and index. Evaluation short-circuits on the
+ * first `Result.succeed` and returns the transformed value in `Option.some`.
+ *
+ * @since 4.0.0
+ * @category Collecting
+ */
+export const findFirstFilter: {
+  /**
+   * Returns the first value that passes an effectful `FilterEffect`.
+   *
+   * The filter receives the element and index. Evaluation short-circuits on the
+   * first `Result.succeed` and returns the transformed value in `Option.some`.
+   *
+   * @since 4.0.0
+   * @category Collecting
+   */
+  <A, B, X, E, R>(
+    filter: (input: NoInfer<A>, i: number) => Effect<Result.Result<B, X>, E, R>
+  ): (elements: Iterable<A>) => Effect<Option<B>, E, R>
+  /**
+   * Returns the first value that passes an effectful `FilterEffect`.
+   *
+   * The filter receives the element and index. Evaluation short-circuits on the
+   * first `Result.succeed` and returns the transformed value in `Option.some`.
+   *
+   * @since 4.0.0
+   * @category Collecting
+   */
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: (input: NoInfer<A>, i: number) => Effect<Result.Result<B, X>, E, R>
+  ): Effect<Option<B>, E, R>
+} = internal.findFirstFilter
+
 /**
  * Executes an effectful operation for each element in an `Iterable`.
  *
@@ -1206,16 +1524,18 @@ export const promise: <A>(
  *
  * @example Custom Error Handling
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TodoFetchError extends Data.TaggedError("TodoFetchError")<{ readonly cause: unknown }> {}
  *
  * const getTodo = (id: number) =>
  *   Effect.tryPromise({
  *     try: () => fetch(`https://jsonplaceholder.typicode.com/todos/${id}`),
  *     // remap the error
- *     catch: (unknown) => new Error(`something went wrong ${unknown}`)
+ *     catch: (cause) => new TodoFetchError({ cause })
  *   })
  *
- * //      ┌─── Effect<Response, Error, never>
+ * //      ┌─── Effect<Response, TodoFetchError, never>
  * //      ▼
  * const program = getTodo(1)
  * ```
@@ -1458,8 +1778,13 @@ export {
  *
  * **When to Use**
  *
- * Use `Effect.async` when dealing with APIs that use callback-style instead of
+ * Use `Effect.callback` when dealing with APIs that use callback-style instead of
  * `async/await` or `Promise`.
+ * * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.async`
  *
  * @example
  * ```ts
@@ -1512,48 +1837,147 @@ export const callback: <A, E = never, R = never>(
 export const never: Effect<never> = internal.never
 
 /**
- * Provides a way to write effectful code using generator functions, simplifying
- * control flow and error handling.
- *
- * **When to Use**
- *
- * `gen` allows you to write code that looks and behaves like synchronous
- * code, but it can handle asynchronous tasks, errors, and complex control flow
- * (like loops and conditions). It helps make asynchronous code more readable
- * and easier to manage.
- *
- * The generator functions work similarly to `async/await` but with more
- * explicit control over the execution of effects. You can `yield*` values from
- * effects and return the final result at the end.
+ * An `Effect` containing an empty record `{}`, used as the starting point for
+ * do notation chains.
  *
  * @example
  * ```ts
  * import { Effect } from "effect"
+ * import { pipe } from "effect/Function"
  *
- * const addServiceCharge = (amount: number) => amount + 1
- *
- * const applyDiscount = (
- *   total: number,
- *   discountRate: number
- * ): Effect.Effect<number, Error> =>
- *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
- *     : Effect.succeed(total - (total * discountRate) / 100)
- *
- * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
- *
- * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))
- *
- * export const program = Effect.gen(function*() {
- *   const transactionAmount = yield* fetchTransactionAmount
- *   const discountRate = yield* fetchDiscountRate
- *   const discountedAmount = yield* applyDiscount(
- *     transactionAmount,
- *     discountRate
- *   )
- *   const finalAmount = addServiceCharge(discountedAmount)
- *   return `Final amount to charge: ${finalAmount}`
- * })
+ * const program = pipe(
+ *   Effect.Do,
+ *   Effect.bind("x", () => Effect.succeed(2)),
+ *   Effect.bind("y", ({ x }) => Effect.succeed(x + 1)),
+ *   Effect.let("sum", ({ x, y }) => x + y)
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category Do notation
+ */
+export const Do: Effect<{}> = internal.Do
+
+/**
+ * Gives a name to the success value of an `Effect`, creating a single-key
+ * record used in do notation pipelines.
+ *
+ * @since 4.0.0
+ * @category Do notation
+ */
+export const bindTo: {
+  /**
+   * Gives a name to the success value of an `Effect`, creating a single-key
+   * record used in do notation pipelines.
+   *
+   * @since 4.0.0
+   * @category Do notation
+   */
+  <N extends string>(name: N): <A, E, R>(self: Effect<A, E, R>) => Effect<{ [K in N]: A }, E, R>
+  /**
+   * Gives a name to the success value of an `Effect`, creating a single-key
+   * record used in do notation pipelines.
+   *
+   * @since 4.0.0
+   * @category Do notation
+   */
+  <A, E, R, N extends string>(self: Effect<A, E, R>, name: N): Effect<{ [K in N]: A }, E, R>
+} = internal.bindTo
+
+const let_: {
+  <N extends string, A extends Record<string, any>, B>(
+    name: N,
+    f: (a: NoInfer<A>) => B
+  ): <E, R>(
+    self: Effect<A, E, R>
+  ) => Effect<Simplify<Omit<A, N> & Record<N, B>>, E, R>
+  <A extends Record<string, any>, E, R, B, N extends string>(
+    self: Effect<A, E, R>,
+    name: N,
+    f: (a: NoInfer<A>) => B
+  ): Effect<Simplify<Omit<A, N> & Record<N, B>>, E, R>
+} = internal.let
+
+export {
+  /**
+   * Adds a computed plain value to the do notation record.
+   *
+   * @since 4.0.0
+   * @category Do notation
+   */
+  let_ as let
+}
+
+/**
+ * Adds an `Effect` value to the do notation record under a given name.
+ *
+ * @since 4.0.0
+ * @category Do notation
+ */
+export const bind: {
+  /**
+   * Adds an `Effect` value to the do notation record under a given name.
+   *
+   * @since 4.0.0
+   * @category Do notation
+   */
+  <N extends string, A extends Record<string, any>, B, E2, R2>(name: N, f: (a: NoInfer<A>) => Effect<B, E2, R2>): <E, R>(
+    self: Effect<A, E, R>
+  ) => Effect<Simplify<Omit<A, N> & Record<N, B>>, E | E2, R | R2>
+  /**
+   * Adds an `Effect` value to the do notation record under a given name.
+   *
+   * @since 4.0.0
+   * @category Do notation
+   */
+  <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(self: Effect<A, E, R>, name: N, f: (a: NoInfer<A>) => Effect<B, E2, R2>): Effect<Simplify<Omit<A, N> & Record<N, B>>, E | E2, R | R2>
+} = internal.bind
+
+/**
+ * Provides a way to write effectful code using generator functions, simplifying
+ * control flow and error handling.
+ *
+ * **When to Use**
+ *
+ * `gen` allows you to write code that looks and behaves like synchronous
+ * code, but it can handle asynchronous tasks, errors, and complex control flow
+ * (like loops and conditions). It helps make asynchronous code more readable
+ * and easier to manage.
+ *
+ * The generator functions work similarly to `async/await` but with more
+ * explicit control over the execution of effects. You can `yield*` values from
+ * effects and return the final result at the end.
+ *
+ * @example
+ * ```ts
+ * import { Data, Effect } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+ *
+ * const addServiceCharge = (amount: number) => amount + 1
+ *
+ * const applyDiscount = (
+ *   total: number,
+ *   discountRate: number
+ * ): Effect.Effect<number, DiscountRateError> =>
+ *   discountRate === 0
+ *     ? Effect.fail(new DiscountRateError())
+ *     : Effect.succeed(total - (total * discountRate) / 100)
+ *
+ * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
+ *
+ * const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))
+ *
+ * export const program = Effect.gen(function*() {
+ *   const transactionAmount = yield* fetchTransactionAmount
+ *   const discountRate = yield* fetchDiscountRate
+ *   const discountedAmount = yield* applyDiscount(
+ *     transactionAmount,
+ *     discountRate
+ *   )
+ *   const finalAmount = addServiceCharge(discountedAmount)
+ *   return `Final amount to charge: ${finalAmount}`
+ * })
  * ```
  *
  * @since 2.0.0
@@ -1577,16 +2001,18 @@ export const gen: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * const addServiceCharge = (amount: number) => amount + 1
    *
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1634,16 +2060,18 @@ export const gen: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * const addServiceCharge = (amount: number) => amount + 1
    *
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
@@ -1707,12 +2135,14 @@ export namespace gen {
  * @example
  * ```ts
  * // Title: Creating a Failed Effect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
  *
- * //      ┌─── Effect<never, Error, never>
+ * class OperationFailedError extends Data.TaggedError("OperationFailedError")<{}> {}
+ *
+ * //      ┌─── Effect<never, OperationFailedError, never>
  * //      ▼
  * const failure = Effect.fail(
- *   new Error("Operation failed due to network error")
+ *   new OperationFailedError()
  * )
  * ```
  *
@@ -1729,9 +2159,11 @@ export const fail: <E>(error: E) => Effect<never, E> = internal.fail
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ProgramError extends Data.TaggedError("ProgramError")<{ readonly failedAt: Date }> {}
  *
- * const program = Effect.failSync(() => new Error("Something went wrong"))
+ * const program = Effect.failSync(() => new ProgramError({ failedAt: new Date() }))
  *
  * Effect.runPromiseExit(program).then(console.log)
  * // Output: { _id: 'Exit', _tag: 'Failure', cause: ... }
@@ -1885,12 +2317,14 @@ export {
    *
    * @example Custom Error Handling
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class JsonParsingError extends Data.TaggedError("JsonParsingError")<{ readonly cause: unknown }> {}
    *
    * const parseJSON = (input: string) =>
    *   Effect.try({
    *     try: () => JSON.parse(input),
-   *     catch: (error) => new Error(`JSON parsing failed: ${error}`)
+   *     catch: (cause) => new JsonParsingError({ cause })
    *   })
    *
    * Effect.runPromiseExit(parseJSON("invalid json")).then(console.log)
@@ -2027,17 +2461,17 @@ export const fromOption: <A>(
  * ```ts
  * import { Console, Effect } from "effect"
  *
- * const input: string | null = null
- *
- * const program = Effect.gen(function*() {
+ * const program = Effect.fn(function*(input: string | null) {
  *   const value = yield* Effect.fromNullishOr(input)
  *   yield* Console.log(value)
- * }).pipe(
+ * },
  *   Effect.catch(() => Console.log("missing"))
  * )
  *
- * Effect.runPromise(program)
+ * Effect.runPromise(program(null))
  * // Output: missing
+ * Effect.runPromise(program("hello"))
+ * // Output: hello
  * ```
  *
  * @since 4.0.0
@@ -2106,15 +2540,17 @@ export const fromYieldable: <Self extends Yieldable.Any, A, E, R>(
  *
  * @example
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2172,15 +2608,17 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2238,15 +2676,17 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2334,15 +2774,17 @@ export const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2, R2>) =
  *
  * @example Applying a Discount Based on Fetched Amount
  * ```ts
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
+ *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
  *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2415,15 +2857,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2496,15 +2940,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2577,15 +3023,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2658,15 +3106,17 @@ export const andThen: {
    *
    * @example Applying a Discount Based on Fetched Amount
    * ```ts
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
+   *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
    *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2725,16 +3175,18 @@ export const andThen: {
  * @example
  * ```ts
  * // Title: Logging a step in a pipeline
- * import { Effect, pipe } from "effect"
+ * import { Data, Effect, pipe } from "effect"
  * import { Console } from "effect"
  *
+ * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+ *
  * // Function to apply a discount safely to a transaction amount
  * const applyDiscount = (
  *   total: number,
  *   discountRate: number
- * ): Effect.Effect<number, Error> =>
+ * ): Effect.Effect<number, DiscountRateError> =>
  *   discountRate === 0
- *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+ *     ? Effect.fail(new DiscountRateError())
  *     : Effect.succeed(total - (total * discountRate) / 100)
  *
  * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2784,16 +3236,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2843,16 +3297,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2902,16 +3358,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -2961,16 +3419,18 @@ export const tap: {
    * @example
    * ```ts
    * // Title: Logging a step in a pipeline
-   * import { Effect, pipe } from "effect"
+   * import { Data, Effect, pipe } from "effect"
    * import { Console } from "effect"
    *
+   * class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
+   *
    * // Function to apply a discount safely to a transaction amount
    * const applyDiscount = (
    *   total: number,
    *   discountRate: number
-   * ): Effect.Effect<number, Error> =>
+   * ): Effect.Effect<number, DiscountRateError> =>
    *   discountRate === 0
-   *     ? Effect.fail(new Error("Discount rate cannot be zero"))
+   *     ? Effect.fail(new DiscountRateError())
    *     : Effect.succeed(total - (total * discountRate) / 100)
    *
    * // Simulated asynchronous task to fetch a transaction amount from database
@@ -3985,7 +4445,8 @@ export const catchTag: {
  * once. Instead of using {@link catchTag} multiple times, you can pass an
  * object where each key is an error type's `_tag`, and the value is the handler
  * for that specific error. This allows you to catch and recover from multiple
- * error types in a single call.
+ * error types in a single call. You can also provide a fallback handler for
+ * unhandled errors.
  *
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
@@ -4027,7 +4488,8 @@ export const catchTags: {
    * once. Instead of using {@link catchTag} multiple times, you can pass an
    * object where each key is an error type's `_tag`, and the value is the handler
    * for that specific error. This allows you to catch and recover from multiple
-   * error types in a single call.
+   * error types in a single call. You can also provide a fallback handler for
+   * unhandled errors.
    *
    * The error type must have a readonly `_tag` field to use `catchTag`. This
    * field is used to identify and match errors.
@@ -4063,19 +4525,27 @@ export const catchTags: {
     E,
     Cases extends
       & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
-  >(cases: Cases): <A, R>(
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never }),
+    A2 = never,
+    E2 = Exclude<E, { _tag: keyof Cases }>,
+    R2 = never
+  >(
+    cases: Cases,
+    orElse?: ((e: Exclude<E, { _tag: keyof Cases }>) => Effect<A2, E2, R2>) | undefined
+  ): <A, R>(
     self: Effect<A, E, R>
   ) => Effect<
     | A
+    | A2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never
     }[keyof Cases],
-    | Exclude<E, { _tag: keyof Cases }>
+    | E2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never
     }[keyof Cases],
     | R
+    | R2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never
     }[keyof Cases]
@@ -4089,7 +4559,8 @@ export const catchTags: {
    * once. Instead of using {@link catchTag} multiple times, you can pass an
    * object where each key is an error type's `_tag`, and the value is the handler
    * for that specific error. This allows you to catch and recover from multiple
-   * error types in a single call.
+   * error types in a single call. You can also provide a fallback handler for
+   * unhandled errors.
    *
    * The error type must have a readonly `_tag` field to use `catchTag`. This
    * field is used to identify and match errors.
@@ -4127,17 +4598,26 @@ export const catchTags: {
     A,
     Cases extends
       & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
-  >(self: Effect<A, E, R>, cases: Cases): Effect<
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never }),
+    A2 = never,
+    E2 = Exclude<E, { _tag: keyof Cases }>,
+    R2 = never
+  >(
+    self: Effect<A, E, R>,
+    cases: Cases,
+    orElse?: ((e: Exclude<E, { _tag: keyof Cases }>) => Effect<A2, E2, R2>) | undefined
+  ): Effect<
     | A
+    | A2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never
     }[keyof Cases],
-    | Exclude<E, { _tag: keyof Cases }>
+    | E2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never
     }[keyof Cases],
     | R
+    | R2
     | {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never
     }[keyof Cases]
@@ -4228,8 +4708,16 @@ export const catchReason: {
   >(
     errorTag: K,
     reasonTag: RK,
-    f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect<A2, E2, R2>,
-    orElse?: ((reasons: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect<A3, E3, R3>) | undefined
+    f: (
+      reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>,
+      error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>
+    ) => Effect<A2, E2, R2>,
+    orElse?:
+      | ((
+        reasons: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, RK>
+      ) => Effect<A3, E3, R3>)
+      | undefined
   ): <A, R>(
     self: Effect<A, E, R>
   ) => Effect<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>
@@ -4284,8 +4772,10 @@ export const catchReason: {
     self: Effect<A, E, R>,
     errorTag: K,
     reasonTag: RK,
-    f: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Effect<A2, E2, R2>,
-    orElse?: ((reasons: ExcludeReason<ExtractTag<E, K>, RK>) => Effect<A3, E3, R3>) | undefined
+    f: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: NarrowReason<ExtractTag<E, K>, RK>) => Effect<A2, E2, R2>,
+    orElse?:
+      | ((reasons: ExcludeReason<ExtractTag<E, K>, RK>, error: OmitReason<ExtractTag<E, K>, RK>) => Effect<A3, E3, R3>)
+      | undefined
   ): Effect<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>
 } = internal.catchReason
 
@@ -4363,7 +4853,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>
       ) => Effect<any, any, any>
     },
     A2 = unassigned,
@@ -4373,7 +4864,10 @@ export const catchReasons: {
     errorTag: K,
     cases: Cases,
     orElse?:
-      | ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>)
+      | ((
+        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
+      ) => Effect<A2, E2, R2>)
       | undefined
   ): <A, R>(
     self: Effect<A, E, R>
@@ -4434,7 +4928,10 @@ export const catchReasons: {
     R,
     K extends Tags<E>,
     Cases extends {
-      [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Effect<any, any, any>
+      [RK in ReasonTags<ExtractTag<E, K>>]+?: (
+        reason: ExtractReason<ExtractTag<E, K>, RK>,
+        error: NarrowReason<ExtractTag<E, K>, RK>
+      ) => Effect<any, any, any>
     },
     A2 = unassigned,
     E2 = never,
@@ -4444,7 +4941,10 @@ export const catchReasons: {
     errorTag: K,
     cases: Cases,
     orElse?:
-      | ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>)
+      | ((
+        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
+      ) => Effect<A2, E2, R2>)
       | undefined
   ): Effect<
     | A
@@ -4870,15 +5370,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**
  *
@@ -4905,7 +5404,7 @@ export const catchDefect: {
  *
  * // With a Filter
  * const recovered2 = program.pipe(
- *   Effect.catchIf(
+ *   Effect.catchFilter(
  *     Filter.tagged("NotFound"),
  *     (error) => Effect.succeed(`missing:${error.id}`)
  *   )
@@ -4917,15 +5416,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**
    *
@@ -4952,7 +5450,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -4968,15 +5466,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**
    *
@@ -5003,7 +5500,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5013,21 +5510,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**
    *
@@ -5054,7 +5550,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5071,15 +5567,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**
    *
@@ -5106,7 +5601,7 @@ export const catchIf: {
    *
    * // With a Filter
    * const recovered2 = program.pipe(
-   *   Effect.catchIf(
+   *   Effect.catchFilter(
    *     Filter.tagged("NotFound"),
    *     (error) => Effect.succeed(`missing:${error.id}`)
    *   )
@@ -5116,14 +5611,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`.
  *
@@ -5231,10 +5758,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.
    *
@@ -5273,13 +5800,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.
@@ -5295,17 +5852,19 @@ export const catchCauseIf: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<number, Error, never>
+ * //      ┌─── Effect<number, TaskError, never>
  * //      ▼
  * const mapped = Effect.mapError(
  *   simulatedTask,
- *   (message) => new Error(message)
+ *   (message) => new TaskError({ message })
  * )
  * ```
  *
@@ -5328,17 +5887,19 @@ export const mapError: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<number, Error, never>
+   * //      ┌─── Effect<number, TaskError, never>
    * //      ▼
    * const mapped = Effect.mapError(
    *   simulatedTask,
-   *   (message) => new Error(message)
+   *   (message) => new TaskError({ message })
    * )
    * ```
    *
@@ -5361,17 +5922,19 @@ export const mapError: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<number, Error, never>
+   * //      ┌─── Effect<number, TaskError, never>
    * //      ▼
    * const mapped = Effect.mapError(
    *   simulatedTask,
-   *   (message) => new Error(message)
+   *   (message) => new TaskError({ message })
    * )
    * ```
    *
@@ -5393,16 +5956,18 @@ export const mapError: {
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
  *
  * //      ┌─── Effect<number, string, never>
  * //      ▼
  * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
  *
- * //      ┌─── Effect<boolean, Error, never>
+ * //      ┌─── Effect<boolean, TaskError, never>
  * //      ▼
  * const modified = Effect.mapBoth(simulatedTask, {
- *   onFailure: (message) => new Error(message),
+ *   onFailure: (message) => new TaskError({ message }),
  *   onSuccess: (n) => n > 0
  * })
  * ```
@@ -5426,16 +5991,18 @@ export const mapBoth: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<boolean, Error, never>
+   * //      ┌─── Effect<boolean, TaskError, never>
    * //      ▼
    * const modified = Effect.mapBoth(simulatedTask, {
-   *   onFailure: (message) => new Error(message),
+   *   onFailure: (message) => new TaskError({ message }),
    *   onSuccess: (n) => n > 0
    * })
    * ```
@@ -5461,16 +6028,18 @@ export const mapBoth: {
    *
    * @example
    * ```ts
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
    * //      ┌─── Effect<number, string, never>
    * //      ▼
    * const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))
    *
-   * //      ┌─── Effect<boolean, Error, never>
+   * //      ┌─── Effect<boolean, TaskError, never>
    * //      ▼
    * const modified = Effect.mapBoth(simulatedTask, {
-   *   onFailure: (message) => new Error(message),
+   *   onFailure: (message) => new TaskError({ message }),
    *   onSuccess: (n) => n > 0
    * })
    * ```
@@ -5505,11 +6074,13 @@ export const mapBoth: {
  * @example
  * ```ts
  * // Title: Propagating an Error as a Defect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class DivideByZeroError extends Data.TaggedError("DivideByZeroError")<{}> {}
  *
  * const divide = (a: number, b: number) =>
  *   b === 0
- *     ? Effect.fail(new Error("Cannot divide by zero"))
+ *     ? Effect.fail(new DivideByZeroError())
  *     : Effect.succeed(a / b)
  *
  * //      ┌─── Effect<number, never, never>
@@ -5518,7 +6089,7 @@ export const mapBoth: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // (FiberFailure) Error: Cannot divide by zero
+ * // (FiberFailure) DivideByZeroError
  * //   ...stack trace...
  * ```
  *
@@ -5905,9 +6476,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.
@@ -5937,13 +6508,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.
  *
@@ -6120,7 +6721,7 @@ export const tapDefect: {
  *   attempts++
  *   yield* Console.log(`Attempt ${attempts}`)
  *   if (attempts < 3) {
- *     yield* Effect.fail("Not ready")
+ *     return yield* Effect.fail("Not ready")
  *   }
  *   return "Ready"
  * })
@@ -6247,13 +6848,15 @@ export declare namespace Retry {
  *
  * @example
  * ```ts
- * import { Effect, Schedule } from "effect"
+ * import { Data, Effect, Schedule } from "effect"
+ *
+ * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
  *
  * let attempt = 0
- * const task = Effect.callback<string, Error>((resume) => {
+ * const task = Effect.callback<string, AttemptError>((resume) => {
  *   attempt++
  *   if (attempt <= 2) {
- *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+ *     resume(Effect.fail(new AttemptError({ attempt })))
  *   } else {
  *     resume(Effect.succeed("Success!"))
  *   }
@@ -6296,13 +6899,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6345,13 +6950,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6394,13 +7001,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6447,13 +7056,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6496,13 +7107,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6545,13 +7158,15 @@ export const retry: {
    *
    * @example
    * ```ts
-   * import { Effect, Schedule } from "effect"
+   * import { Data, Effect, Schedule } from "effect"
+   *
+   * class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
    *
    * let attempt = 0
-   * const task = Effect.callback<string, Error>((resume) => {
+   * const task = Effect.callback<string, AttemptError>((resume) => {
    *   attempt++
    *   if (attempt <= 2) {
-   *     resume(Effect.fail(new Error(`Attempt ${attempt} failed`)))
+   *     resume(Effect.fail(new AttemptError({ attempt })))
    *   } else {
    *     resume(Effect.succeed("Success!"))
    *   }
@@ -6598,14 +7213,16 @@ export const retry: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Schedule } from "effect"
+ * import { Console, Data, Effect, Schedule } from "effect"
+ *
+ * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
  *
  * let attempt = 0
  * const networkRequest = Effect.gen(function*() {
  *   attempt++
  *   yield* Console.log(`Network attempt ${attempt}`)
  *   if (attempt < 3) {
- *     return yield* Effect.fail(new Error("Network timeout"))
+ *     return yield* Effect.fail(new NetworkTimeoutError())
  *   }
  *   return "Network data"
  * })
@@ -6653,14 +7270,16 @@ export const retryOrElse: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
    *
    * let attempt = 0
    * const networkRequest = Effect.gen(function*() {
    *   attempt++
    *   yield* Console.log(`Network attempt ${attempt}`)
    *   if (attempt < 3) {
-   *     return yield* Effect.fail(new Error("Network timeout"))
+   *     return yield* Effect.fail(new NetworkTimeoutError())
    *   }
    *   return "Network data"
    * })
@@ -6711,14 +7330,16 @@ export const retryOrElse: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, Schedule } from "effect"
+   * import { Console, Data, Effect, Schedule } from "effect"
+   *
+   * class NetworkTimeoutError extends Data.TaggedError("NetworkTimeoutError")<{}> {}
    *
    * let attempt = 0
    * const networkRequest = Effect.gen(function*() {
    *   attempt++
    *   yield* Console.log(`Network attempt ${attempt}`)
    *   if (attempt < 3) {
-   *     return yield* Effect.fail(new Error("Network timeout"))
+   *     return yield* Effect.fail(new NetworkTimeoutError())
    *   }
    *   return "Network data"
    * })
@@ -6799,7 +7420,8 @@ export const sandbox: <A, E, R>(
  * it succeeds or fails. This is useful when you only care about the side
  * effects of the effect and do not need to handle or process its outcome.
  *
- * Use the `log` option to emit the full {@link Cause} when the effect fails.
+ * Use the `log` option to emit the full {@link Cause} when the effect fails,
+ * and `message` to prepend a custom log message.
  *
  * @example
  * ```ts
@@ -6823,7 +7445,7 @@ export const sandbox: <A, E, R>(
  * const task = Effect.fail("Uh oh!")
  *
  * const program = task.pipe(Effect.ignore({ log: true }))
- * const programWarn = task.pipe(Effect.ignore({ log: "Warn" }))
+ * const programWarn = task.pipe(Effect.ignore({ log: "Warn", message: "Ignoring task failure" }))
  * ```
  *
  * **Previously Known As**
@@ -6837,14 +7459,17 @@ export const sandbox: <A, E, R>(
  */
 export const ignore: <
   Arg extends Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignore
@@ -6852,7 +7477,8 @@ export const ignore: <
 /**
  * Ignores the effect's failure cause, including defects and interruptions.
  *
- * Use the `log` option to emit the full {@link Cause} when the effect fails.
+ * Use the `log` option to emit the full {@link Cause} when the effect fails,
+ * and `message` to prepend a custom log message.
  *
  * @example
  * ```ts
@@ -6861,7 +7487,7 @@ export const ignore: <
  * const task = Effect.fail("boom")
  *
  * const program = task.pipe(Effect.ignoreCause)
- * const programLog = task.pipe(Effect.ignoreCause({ log: true }))
+ * const programLog = task.pipe(Effect.ignoreCause({ log: true, message: "Ignoring failure cause" }))
  * ```
  *
  * @since 4.0.0
@@ -6869,14 +7495,17 @@ export const ignore: <
  */
 export const ignoreCause: <
   Arg extends Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions?: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R> = internal.ignoreCause
@@ -6897,7 +7526,10 @@ export const ignoreCause: <
  *
  * const fetchUrl = Effect.gen(function*() {
  *   const endpoint = yield* Effect.service(Endpoint)
- *   return endpoint.url === "bad" ? yield* Effect.fail("Unavailable") : endpoint.url
+ *   if (endpoint.url === "bad") {
+ *     return yield* Effect.fail("Unavailable")
+ *   }
+ *   return endpoint.url
  * })
  *
  * const plan = ExecutionPlan.make(
@@ -6928,7 +7560,10 @@ export const withExecutionPlan: {
    *
    * const fetchUrl = Effect.gen(function*() {
    *   const endpoint = yield* Effect.service(Endpoint)
-   *   return endpoint.url === "bad" ? yield* Effect.fail("Unavailable") : endpoint.url
+   *   if (endpoint.url === "bad") {
+   *     return yield* Effect.fail("Unavailable")
+   *   }
+   *   return endpoint.url
    * })
    *
    * const plan = ExecutionPlan.make(
@@ -6963,7 +7598,10 @@ export const withExecutionPlan: {
    *
    * const fetchUrl = Effect.gen(function*() {
    *   const endpoint = yield* Effect.service(Endpoint)
-   *   return endpoint.url === "bad" ? yield* Effect.fail("Unavailable") : endpoint.url
+   *   if (endpoint.url === "bad") {
+   *     return yield* Effect.fail("Unavailable")
+   *   }
+   *   return endpoint.url
    * })
    *
    * const plan = ExecutionPlan.make(
@@ -6983,9 +7621,28 @@ export const withExecutionPlan: {
   ): Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>
 } = internalExecutionPlan.withExecutionPlan
 
+/**
+ * Runs an effect and reports any errors to the configured `ErrorReporter`s.
+ *
+ * If the `defectsOnly` option is set to `true`, only defects (unrecoverable
+ * errors) will be reported, while regular failures will be ignored.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const withErrorReporting: <
+  Arg extends Effect<any, any, any> | { readonly defectsOnly?: boolean | undefined } | undefined = {
+    readonly defectsOnly?: boolean | undefined
+  }
+>(
+  effectOrOptions: Arg,
+  options?: { readonly defectsOnly?: boolean | undefined } | undefined
+) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Arg : <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R> =
+  internal.withErrorReporting
+
+// -----------------------------------------------------------------------------
+// Fallback
 // -----------------------------------------------------------------------------
-// Fallback
-// -----------------------------------------------------------------------------
 
 /**
  * Replaces the original failure with a success value, ensuring the effect
@@ -7224,7 +7881,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutError, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | Cause.TimeoutError, R>
   // -----------------------------------------------------------------------------
   // Delays & timeouts
   // -----------------------------------------------------------------------------
@@ -7275,7 +7932,7 @@ export const timeout: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, E | Cause.TimeoutError, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E | Cause.TimeoutError, R>
 } = internal.timeout
 
 /**
@@ -7377,7 +8034,7 @@ export const timeoutOption: {
    * @since 3.1.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
   /**
    * Handles timeouts by returning an `Option` that represents either the result
    * or a timeout.
@@ -7427,7 +8084,7 @@ export const timeoutOption: {
    * @since 3.1.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<Option<A>, E, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<Option<A>, E, R>
 } = internal.timeoutOption
 
 /**
@@ -7505,7 +8162,7 @@ export const timeoutOrElse: {
    */
   <A2, E2, R2>(
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect<A2, E2, R2>>
     }
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2, R | R2>
@@ -7548,7 +8205,7 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
+      readonly duration: Duration.Input
       readonly onTimeout: LazyArg<Effect<A2, E2, R2>>
     }
   ): Effect<A | A2, E | E2, R | R2>
@@ -7595,7 +8252,7 @@ export const delay: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  (duration: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  (duration: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
   /**
    * Returns an effect that is delayed from this effect by the specified
    * `Duration`.
@@ -7616,7 +8273,7 @@ export const delay: {
    * @since 2.0.0
    * @category Delays & Timeouts
    */
-  <A, E, R>(self: Effect<A, E, R>, duration: Duration.DurationInput): Effect<A, E, R>
+  <A, E, R>(self: Effect<A, E, R>, duration: Duration.Input): Effect<A, E, R>
 } = internal.delay
 
 /**
@@ -7641,7 +8298,7 @@ export const delay: {
  * @since 2.0.0
  * @category Delays & Timeouts
  */
-export const sleep: (duration: Duration.DurationInput) => Effect<void> = internal.sleep
+export const sleep: (duration: Duration.Input) => Effect<void> = internal.sleep
 
 /**
  * Measures the runtime of an effect and returns the duration with its result.
@@ -7961,12 +8618,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)
@@ -7974,10 +8631,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
@@ -7989,12 +8643,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)
@@ -8002,10 +8656,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
@@ -8017,12 +8668,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)
@@ -8030,10 +8681,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
@@ -8045,12 +8693,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)
@@ -8058,30 +8706,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)
@@ -8089,30 +8734,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)
@@ -8120,30 +8759,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)
@@ -8151,137 +8784,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`.
+   * 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>(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`.
-   *
-   * @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))
+   * Filters and maps elements of an iterable with a `Filter`.
    *
-   * // 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))
+   * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
    *
-   * // 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, 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`.
-   *
-   * @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, 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.
@@ -8378,10 +8945,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.
    *
@@ -8447,13 +9014,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.
  *
@@ -8550,36 +9147,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.
    *
@@ -8640,36 +9207,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.
    *
@@ -8738,40 +9275,6 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): 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, 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, failing with a custom error if the predicate fails.
    *
@@ -8832,37 +9335,48 @@ export const filterOrFail: {
    * @category Filtering
    */
   <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`.
+   * Filters an effect with a `Filter`, failing when the filter fails.
    *
-   * @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, 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 with a `Filter`, failing when the filter fails.
    *
-   * // Result: Effect.fail("Expected even number, got 5")
-   * ```
+   * @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.
    *
-   * @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, 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 4.0.0
+   * @category Filtering
+   */
+  <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
@@ -9020,9 +9534,11 @@ export const when: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
  *
  * const program1 = Effect.match(success, {
  *   onFailure: (error) => `failure: ${error.message}`,
@@ -9033,8 +9549,8 @@ export const when: {
  * Effect.runPromise(program1).then(console.log)
  * // Output: "success: 42"
  *
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program2 = Effect.match(failure, {
@@ -9076,9 +9592,11 @@ export const match: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+   *
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
    *
    * const program1 = Effect.match(success, {
    *   onFailure: (error) => `failure: ${error.message}`,
@@ -9089,8 +9607,8 @@ export const match: {
    * Effect.runPromise(program1).then(console.log)
    * // Output: "success: 42"
    *
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program2 = Effect.match(failure, {
@@ -9137,9 +9655,11 @@ export const match: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
    *
    * const program1 = Effect.match(success, {
    *   onFailure: (error) => `failure: ${error.message}`,
@@ -9150,8 +9670,8 @@ export const match: {
    * Effect.runPromise(program1).then(console.log)
    * // Output: "success: 42"
    *
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program2 = Effect.match(failure, {
@@ -9581,9 +10101,11 @@ export const matchCauseEffectEager: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect, Result } from "effect"
+ * import { Cause, Console, Data, Effect, Result } from "effect"
  *
- * const task = Effect.fail(new Error("Task failed"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Task failed" }))
  *
  * const program = Effect.matchCauseEffect(task, {
  *   onFailure: (cause) =>
@@ -9633,9 +10155,11 @@ export const matchCauseEffect: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect, Result } from "effect"
+   * import { Cause, Console, Data, Effect, Result } from "effect"
+   *
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
    *
-   * const task = Effect.fail(new Error("Task failed"))
+   * const task = Effect.fail(new TaskError({ message: "Task failed" }))
    *
    * const program = Effect.matchCauseEffect(task, {
    *   onFailure: (cause) =>
@@ -9690,9 +10214,11 @@ export const matchCauseEffect: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect, Result } from "effect"
+   * import { Cause, Console, Data, Effect, Result } from "effect"
    *
-   * const task = Effect.fail(new Error("Task failed"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Task failed" }))
    *
    * const program = Effect.matchCauseEffect(task, {
    *   onFailure: (cause) =>
@@ -9756,11 +10282,13 @@ export const matchCauseEffect: {
  * @example
  * ```ts
  * // Title: Handling Both Success and Failure Cases with Side Effects
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
  *
- * const success: Effect.Effect<number, Error> = Effect.succeed(42)
- * const failure: Effect.Effect<number, Error> = Effect.fail(
- *   new Error("Uh oh!")
+ * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+ * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+ *   new ExampleError({ message: "Uh oh!" })
  * )
  *
  * const program1 = Effect.matchEffect(success, {
@@ -9816,11 +10344,13 @@ export const matchEffect: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases with Side Effects
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
+   *
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program1 = Effect.matchEffect(success, {
@@ -9881,11 +10411,13 @@ export const matchEffect: {
    * @example
    * ```ts
    * // Title: Handling Both Success and Failure Cases with Side Effects
-   * import { Effect } from "effect"
+   * import { Data, Effect } from "effect"
+   *
+   * class ExampleError extends Data.TaggedError("ExampleError")<{ readonly message: string }> {}
    *
-   * const success: Effect.Effect<number, Error> = Effect.succeed(42)
-   * const failure: Effect.Effect<number, Error> = Effect.fail(
-   *   new Error("Uh oh!")
+   * const success: Effect.Effect<number, ExampleError> = Effect.succeed(42)
+   * const failure: Effect.Effect<number, ExampleError> = Effect.fail(
+   *   new ExampleError({ message: "Uh oh!" })
    * )
    *
    * const program1 = Effect.matchEffect(success, {
@@ -10028,7 +10560,7 @@ export const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, neve
  * @since 2.0.0
  * @category Environment
  */
-export const services: <R>() => Effect<ServiceMap.ServiceMap<R>, never, R> = internal.services
+export const services: <R = never>() => Effect<ServiceMap.ServiceMap<R>, never, R> = internal.services
 
 /**
  * Transforms the current service map using the provided function.
@@ -10094,7 +10626,7 @@ export const servicesWith: <R, A, E, R2>(
  * const Database = ServiceMap.Service<Database>("Database")
  *
  * const DatabaseLive = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
  * })
  *
  * const program = Effect.gen(function*() {
@@ -10128,7 +10660,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10173,7 +10705,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10214,7 +10746,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10248,7 +10780,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10292,7 +10824,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10332,7 +10864,7 @@ export const provide: {
    * const Database = ServiceMap.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
-   *   query: (sql: string) => Effect.succeed(`Result for: ${sql}`)
+   *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
    * })
    *
    * const program = Effect.gen(function*() {
@@ -10496,7 +11028,7 @@ export const provideServices: {
  * @since 4.0.0
  * @category ServiceMap
  */
-export const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, never, I> = internal.service
+export const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never, I> = internal.service
 
 /**
  * Optionally accesses a service from the environment.
@@ -10532,7 +11064,7 @@ export const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, nev
  * @since 2.0.0
  * @category ServiceMap
  */
-export const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Effect<Option<S>> = internal.serviceOption
+export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S>> = internal.serviceOption
 
 /**
  * Provides part of the required context while leaving the rest unchanged.
@@ -10721,7 +11253,7 @@ export const updateService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, A>(service: ServiceMap.Service<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
+  <I, A>(service: ServiceMap.Key<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
   /**
    * Updates the service with the required service entry.
    *
@@ -10750,11 +11282,7 @@ export const updateService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <XA, E, R, I, A>(
-    self: Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
-    f: (value: A) => A
-  ): Effect<XA, E, R | I>
+  <XA, E, R, I, A>(self: Effect<XA, E, R>, service: ServiceMap.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>
 } = internal.updateService
 
 /**
@@ -10848,7 +11376,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S>(service: ServiceMap.Service<I, S>): {
+  <I, S>(service: ServiceMap.Key<I, S>): {
     /**
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
@@ -10987,7 +11515,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S>(service: ServiceMap.Service<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
+  <I, S>(service: ServiceMap.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
   /**
    * The `provideService` function is used to provide an actual
    * implementation for a service in the context of an effect.
@@ -11033,11 +11561,7 @@ export const provideService: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <A, E, R, I, S>(
-    self: Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
-    implementation: S
-  ): Effect<A, E, Exclude<R, I>>
+  <A, E, R, I, S>(self: Effect<A, E, R>, service: ServiceMap.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>
 } = internal.provideService
 
 /**
@@ -11145,7 +11669,7 @@ export const provideServiceEffect: {
    * @since 2.0.0
    * @category ServiceMap
    */
-  <I, S, E2, R2>(service: ServiceMap.Service<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
+  <I, S, E2, R2>(service: ServiceMap.Key<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
   /**
    * Provides the effect with the single service it requires. If the effect
    * requires more than one service use `provide` instead.
@@ -11200,7 +11724,7 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, E2, R2>(
     self: Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: ServiceMap.Key<I, S>,
     acquire: Effect<S, E2, R2>
   ): Effect<A, E | E2, Exclude<R, I> | R2>
 } = internal.provideServiceEffect
@@ -11737,9 +12261,11 @@ export const ensuring: {
  *
  * @example
  * ```ts
- * import { Cause, Console, Effect } from "effect"
+ * import { Cause, Data, Console, Effect } from "effect"
  *
- * const task = Effect.fail(new Error("Something went wrong"))
+ * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+ *
+ * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
  *
  * const program = Effect.onError(
  *   task,
@@ -11748,8 +12274,8 @@ export const ensuring: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // Cleanup on error: Error: Something went wrong
- * // Error: Something went wrong
+ * // Cleanup on error: TaskError: Something went wrong
+ * // TaskError: Something went wrong
  * ```
  *
  * @since 2.0.0
@@ -11762,9 +12288,11 @@ export const onError: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect } from "effect"
+   * import { Cause, Data, Console, Effect } from "effect"
    *
-   * const task = Effect.fail(new Error("Something went wrong"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
    *
    * const program = Effect.onError(
    *   task,
@@ -11773,8 +12301,8 @@ export const onError: {
    *
    * Effect.runPromise(program).catch(console.error)
    * // Output:
-   * // Cleanup on error: Error: Something went wrong
-   * // Error: Something went wrong
+   * // Cleanup on error: TaskError: Something went wrong
+   * // TaskError: Something went wrong
    * ```
    *
    * @since 2.0.0
@@ -11787,9 +12315,11 @@ export const onError: {
    *
    * @example
    * ```ts
-   * import { Cause, Console, Effect } from "effect"
+   * import { Cause, Data, Console, Effect } from "effect"
    *
-   * const task = Effect.fail(new Error("Something went wrong"))
+   * class TaskError extends Data.TaggedError("TaskError")<{ readonly message: string }> {}
+   *
+   * const task = Effect.fail(new TaskError({ message: "Something went wrong" }))
    *
    * const program = Effect.onError(
    *   task,
@@ -11798,8 +12328,8 @@ export const onError: {
    *
    * Effect.runPromise(program).catch(console.error)
    * // Output:
-   * // Cleanup on error: Error: Something went wrong
-   * // Error: Something went wrong
+   * // Cleanup on error: TaskError: Something went wrong
+   * // TaskError: Something went wrong
    * ```
    *
    * @since 2.0.0
@@ -11813,7 +12343,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
@@ -11837,7 +12367,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
@@ -11858,13 +12388,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
@@ -11885,13 +12415,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
@@ -11990,20 +12550,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
  * )
  * ```
  *
@@ -12012,64 +12572,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
 // -----------------------------------------------------------------------------
@@ -12272,7 +12856,7 @@ export const cachedWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
+  (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A, E, R>>
   /**
    * Returns an effect that caches its result for a specified `Duration`,
    * known as "timeToLive" (TTL).
@@ -12339,7 +12923,7 @@ export const cachedWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<Effect<A, E, R>>
+  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<Effect<A, E, R>>
 } = internal.cachedWithTTL
 
 /**
@@ -12481,7 +13065,7 @@ export const cachedInvalidateWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  (timeToLive: Duration.DurationInput): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
+  (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>
   /**
    * Caches an effect's result for a specified duration and allows manual
    * invalidation before expiration.
@@ -12551,7 +13135,7 @@ export const cachedInvalidateWithTTL: {
    * @since 2.0.0
    * @category Caching
    */
-  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.DurationInput): Effect<[Effect<A, E, R>, Effect<void>]>
+  <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<[Effect<A, E, R>, Effect<void>]>
 } = internal.cachedInvalidateWithTTL
 
 // -----------------------------------------------------------------------------
@@ -12566,8 +13150,8 @@ export const cachedInvalidateWithTTL: {
  * import { Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   yield* Effect.interrupt
- *   yield* Effect.succeed("This won't execute")
+ *   return yield* Effect.interrupt
+ *   yield* Effect.succeed("This won't execute and is unreachable")
  * })
  *
  * Effect.runPromise(program).catch(console.error)
@@ -12667,361 +13251,115 @@ export const onInterrupt: {
    * const fiber = Effect.runFork(program)
    * // Later interrupt the task
    * Effect.runFork(Fiber.interrupt(fiber))
-   * // Output: Task was interrupted, cleaning up...
-   * ```
-   *
-   * @since 2.0.0
-   * @category Interruption
-   */
-  <A, E, R, XE, XR>(
-    self: Effect<A, E, R>,
-    finalizer: (interruptors: ReadonlySet<number>) => Effect<void, XE, XR>
-  ): Effect<A, E | XE, R | XR>
-} = internal.onInterrupt
-
-/**
- * Returns a new effect that disables interruption for the given effect.
- *
- * @example
- * ```ts
- * import { Console, Effect, Fiber } from "effect"
- *
- * const criticalTask = Effect.gen(function*() {
- *   yield* Console.log("Starting critical section...")
- *   yield* Effect.sleep("2 seconds")
- *   yield* Console.log("Critical section completed")
- * })
- *
- * const program = Effect.uninterruptible(criticalTask)
- *
- * const fiber = Effect.runFork(program)
- * // Even if interrupted, the critical task will complete
- * Effect.runPromise(Fiber.interrupt(fiber))
- * ```
- *
- * @since 2.0.0
- * @category Interruption
- */
-export const uninterruptible: <A, E, R>(
-  self: Effect<A, E, R>
-) => Effect<A, E, R> = internal.uninterruptible
-
-/**
- * Disables interruption and provides a restore function to restore the
- * interruptible state within the effect.
- *
- * @example
- * ```ts
- * import { Console, Effect } from "effect"
- *
- * const program = Effect.uninterruptibleMask((restore) =>
- *   Effect.gen(function*() {
- *     yield* Console.log("Uninterruptible phase...")
- *     yield* Effect.sleep("1 second")
- *
- *     // Restore interruptibility for this part
- *     yield* restore(
- *       Effect.gen(function*() {
- *         yield* Console.log("Interruptible phase...")
- *         yield* Effect.sleep("2 seconds")
- *       })
- *     )
- *
- *     yield* Console.log("Back to uninterruptible")
- *   })
- * )
- * ```
- *
- * @since 2.0.0
- * @category Interruption
- */
-export const uninterruptibleMask: <A, E, R>(
-  f: (
-    restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>
-  ) => Effect<A, E, R>
-) => Effect<A, E, R> = internal.uninterruptibleMask
-
-/**
- * This function behaves like {@link interruptible}, but it also provides a
- * `restore` function. This function can be used to restore the interruptibility
- * of any specific region of code.
- *
- * @example
- * ```ts
- * import { Console, Effect } from "effect"
- *
- * const program = Effect.interruptibleMask((restore) =>
- *   Effect.gen(function*() {
- *     yield* Console.log("Interruptible phase...")
- *     yield* Effect.sleep("1 second")
- *
- *     // Make this part uninterruptible
- *     yield* restore(
- *       Effect.gen(function*() {
- *         yield* Console.log("Uninterruptible phase...")
- *         yield* Effect.sleep("2 seconds")
- *       })
- *     )
- *
- *     yield* Console.log("Back to interruptible")
- *   })
- * )
- * ```
- *
- * @since 2.0.0
- * @category Interruption
- */
-export const interruptibleMask: <A, E, R>(
-  f: (
-    restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>
-  ) => Effect<A, E, R>
-) => Effect<A, E, R> = internal.interruptibleMask
-
-// -----------------------------------------------------------------------------
-// Semaphore
-// -----------------------------------------------------------------------------
-
-/**
- * @category Semaphore
- * @since 2.0.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a semaphore for controlling concurrent access
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
- *
- *   return yield* semaphore.withPermits(1)(
- *     Effect.succeed("Resource accessed")
- *   )
- * })
- * ```
- */
-export interface Semaphore {
-  /**
-   * Adjusts the number of permits available in the semaphore.
-   */
-  resize(permits: number): Effect<void>
-
-  /**
-   * Runs an effect with the given number of permits and releases the permits
-   * when the effect completes.
-   *
-   * **Details**
-   *
-   * This function acquires the specified number of permits before executing
-   * the provided effect. Once the effect finishes, the permits are released.
-   * If insufficient permits are available, the function will wait until they
-   * are released by other tasks.
-   */
-  withPermits(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
-
-  /**
-   * Runs an effect with the given number of permits and releases the permits
-   * when the effect completes.
-   *
-   * **Details**
-   *
-   * This function acquires the specified number of permits before executing
-   * the provided effect. Once the effect finishes, the permits are released.
-   * If insufficient permits are available, the function will wait until they
-   * are released by other tasks.
-   */
-  withPermit<A, E, R>(self: Effect<A, E, R>): Effect<A, E, R>
-
-  /**
-   * Runs an effect only if the specified number of permits are immediately
-   * available.
-   *
-   * **Details**
-   *
-   * This function attempts to acquire the specified number of permits. If they
-   * are available, it runs the effect and releases the permits after the effect
-   * completes. If permits are not available, the effect does not execute, and
-   * the result is `Option.none`.
-   */
-  withPermitsIfAvailable(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>
-
-  /**
-   * Acquires the specified number of permits and returns the resulting
-   * available permits, suspending the task if they are not yet available.
-   * Concurrent pending `take` calls are processed in a first-in, first-out manner.
-   */
-  take(permits: number): Effect<number>
-
-  /**
-   * Releases the specified number of permits and returns the resulting
-   * available permits.
-   */
-  release(permits: number): Effect<number>
-
-  /**
-   * Releases all permits held by this semaphore and returns the resulting available permits.
+   * // Output: Task was interrupted, cleaning up...
+   * ```
+   *
+   * @since 2.0.0
+   * @category Interruption
    */
-  releaseAll: Effect<number>
-}
+  <A, E, R, XE, XR>(
+    self: Effect<A, E, R>,
+    finalizer: (interruptors: ReadonlySet<number>) => Effect<void, XE, XR>
+  ): Effect<A, E | XE, R | XR>
+} = internal.onInterrupt
 
 /**
- * Unsafely creates a new Semaphore.
+ * Returns a new effect that disables interruption for the given effect.
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Console, Effect, Fiber } from "effect"
  *
- * const semaphore = Effect.makeSemaphoreUnsafe(3)
+ * const criticalTask = Effect.gen(function*() {
+ *   yield* Console.log("Starting critical section...")
+ *   yield* Effect.sleep("2 seconds")
+ *   yield* Console.log("Critical section completed")
+ * })
  *
- * const task = (id: number) =>
- *   semaphore.withPermits(1)(
- *     Effect.gen(function*() {
- *       yield* Effect.log(`Task ${id} started`)
- *       yield* Effect.sleep("1 second")
- *       yield* Effect.log(`Task ${id} completed`)
- *     })
- *   )
+ * const program = Effect.uninterruptible(criticalTask)
  *
- * // Only 3 tasks can run concurrently
- * const program = Effect.all([
- *   task(1),
- *   task(2),
- *   task(3),
- *   task(4),
- *   task(5)
- * ], { concurrency: "unbounded" })
+ * const fiber = Effect.runFork(program)
+ * // Even if interrupted, the critical task will complete
+ * Effect.runPromise(Fiber.interrupt(fiber))
  * ```
  *
  * @since 2.0.0
- * @category Semaphore
+ * @category Interruption
  */
-export const makeSemaphoreUnsafe: (permits: number) => Semaphore = internal.makeSemaphoreUnsafe
+export const uninterruptible: <A, E, R>(
+  self: Effect<A, E, R>
+) => Effect<A, E, R> = internal.uninterruptible
 
 /**
- * Creates a new Semaphore.
+ * Disables interruption and provides a restore function to restore the
+ * interruptible state within the effect.
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Console, Effect } from "effect"
  *
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
+ * const program = Effect.uninterruptibleMask((restore) =>
+ *   Effect.gen(function*() {
+ *     yield* Console.log("Uninterruptible phase...")
+ *     yield* Effect.sleep("1 second")
  *
- *   const task = (id: number) =>
- *     semaphore.withPermits(1)(
+ *     // Restore interruptibility for this part
+ *     yield* restore(
  *       Effect.gen(function*() {
- *         yield* Effect.log(`Task ${id} acquired permit`)
- *         yield* Effect.sleep("1 second")
- *         yield* Effect.log(`Task ${id} releasing permit`)
+ *         yield* Console.log("Interruptible phase...")
+ *         yield* Effect.sleep("2 seconds")
  *       })
  *     )
  *
- *   // Run 4 tasks, but only 2 can run concurrently
- *   yield* Effect.all([task(1), task(2), task(3), task(4)])
- * })
+ *     yield* Console.log("Back to uninterruptible")
+ *   })
+ * )
  * ```
  *
  * @since 2.0.0
- * @category Semaphore
- */
-export const makeSemaphore: (permits: number) => Effect<Semaphore> = internal.makeSemaphore
-
-// -----------------------------------------------------------------------------
-// Latch
-// -----------------------------------------------------------------------------
-
-/**
- * @category Latch
- * @since 3.8.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a latch for coordination between fibers
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch()
- *
- *   // Wait for the latch to be opened
- *   yield* latch.await
- *
- *   return "Latch was opened!"
- * })
- * ```
- */
-export interface Latch {
-  /** open the latch, releasing all fibers waiting on it */
-  readonly open: Effect<boolean>
-  /** open the latch, releasing all fibers waiting on it */
-  readonly openUnsafe: () => boolean
-  /** release all fibers waiting on the latch, without opening it */
-  readonly release: Effect<boolean>
-  /** wait for the latch to be opened */
-  readonly await: Effect<void>
-  /** close the latch */
-  readonly close: Effect<boolean>
-  /** close the latch */
-  readonly closeUnsafe: () => boolean
-  /** only run the given effect when the latch is open */
-  readonly whenOpen: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
-}
-
-/**
- * Creates a new Latch.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const latch = Effect.makeLatchUnsafe(false)
- *
- * const waiter = Effect.gen(function*() {
- *   yield* Effect.log("Waiting for latch to open...")
- *   yield* latch.await
- *   yield* Effect.log("Latch opened! Continuing...")
- * })
- *
- * const opener = Effect.gen(function*() {
- *   yield* Effect.sleep("2 seconds")
- *   yield* Effect.log("Opening latch...")
- *   yield* latch.open
- * })
- *
- * const program = Effect.all([waiter, opener])
- * ```
- *
- * @category Latch
- * @since 3.8.0
+ * @category Interruption
  */
-export const makeLatchUnsafe: (open?: boolean | undefined) => Latch = internal.makeLatchUnsafe
+export const uninterruptibleMask: <A, E, R>(
+  f: (
+    restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>
+  ) => Effect<A, E, R>
+) => Effect<A, E, R> = internal.uninterruptibleMask
 
 /**
- * Creates a new Latch.
+ * This function behaves like {@link interruptible}, but it also provides a
+ * `restore` function. This function can be used to restore the interruptibility
+ * of any specific region of code.
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Console, Effect } from "effect"
  *
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch(false)
+ * const program = Effect.interruptibleMask((restore) =>
+ *   Effect.gen(function*() {
+ *     yield* Console.log("Interruptible phase...")
+ *     yield* Effect.sleep("1 second")
  *
- *   const waiter = Effect.gen(function*() {
- *     yield* Effect.log("Waiting for latch to open...")
- *     yield* latch.await
- *     yield* Effect.log("Latch opened! Continuing...")
- *   })
+ *     // Make this part uninterruptible
+ *     yield* restore(
+ *       Effect.gen(function*() {
+ *         yield* Console.log("Uninterruptible phase...")
+ *         yield* Effect.sleep("2 seconds")
+ *       })
+ *     )
  *
- *   const opener = Effect.gen(function*() {
- *     yield* Effect.sleep("2 seconds")
- *     yield* Effect.log("Opening latch...")
- *     yield* latch.open
+ *     yield* Console.log("Back to interruptible")
  *   })
- *
- *   yield* Effect.all([waiter, opener])
- * })
+ * )
  * ```
  *
- * @category Latch
- * @since 3.8.0
+ * @since 2.0.0
+ * @category Interruption
  */
-export const makeLatch: (open?: boolean | undefined) => Effect<Latch> = internal.makeLatch
+export const interruptibleMask: <A, E, R>(
+  f: (
+    restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>
+  ) => Effect<A, E, R>
+) => Effect<A, E, R> = internal.interruptibleMask
 
 // -----------------------------------------------------------------------------
 // Repetition & Recursion
@@ -13640,7 +13978,7 @@ export const repeat: {
  *   attempt++
  *   if (attempt <= 2) {
  *     yield* Console.log(`Attempt ${attempt} failed`)
- *     yield* Effect.fail(`Error ${attempt}`)
+ *     return yield* Effect.fail(`Error ${attempt}`)
  *   }
  *   yield* Console.log(`Attempt ${attempt} succeeded`)
  *   return "success"
@@ -13690,7 +14028,7 @@ export const repeatOrElse: {
    *   attempt++
    *   if (attempt <= 2) {
    *     yield* Console.log(`Attempt ${attempt} failed`)
-   *     yield* Effect.fail(`Error ${attempt}`)
+   *     return yield* Effect.fail(`Error ${attempt}`)
    *   }
    *   yield* Console.log(`Attempt ${attempt} succeeded`)
    *   return "success"
@@ -13743,7 +14081,7 @@ export const repeatOrElse: {
    *   attempt++
    *   if (attempt <= 2) {
    *     yield* Console.log(`Attempt ${attempt} failed`)
-   *     yield* Effect.fail(`Error ${attempt}`)
+   *     return yield* Effect.fail(`Error ${attempt}`)
    *   }
    *   yield* Console.log(`Attempt ${attempt} succeeded`)
    *   return "success"
@@ -15208,7 +15546,7 @@ export const withParentSpan: {
  * )
  *
  * const program = Effect.gen(function*() {
- *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+ *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
  *   yield* Console.log(name)
  * })
  * ```
@@ -15243,7 +15581,7 @@ export const request: {
    * )
    *
    * const program = Effect.gen(function*() {
-   *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+   *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
    *   yield* Console.log(name)
    * })
    * ```
@@ -15278,7 +15616,7 @@ export const request: {
    * )
    *
    * const program = Effect.gen(function*() {
-   *   const name = yield* Effect.request(GetUser({ id: 1 }), Effect.succeed(resolver))
+   *   const name = yield* Effect.request(GetUser({ id: 1 }), resolver)
    *   yield* Console.log(name)
    * })
    * ```
@@ -15516,7 +15854,7 @@ export const forkScoped: <
     readonly startImmediately?: boolean | undefined
     readonly uninterruptible?: boolean | "inherit" | undefined
   } | undefined
-) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<Fiber<_A, _E>, never, _R>
+) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<Fiber<_A, _E>, never, _R | Scope>
   : <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber<A, E>, never, R | Scope> = internal.forkScoped
 
 /**
@@ -20339,7 +20677,7 @@ export const clockWith: <A, E, R>(
  * @since 2.0.0
  * @category Logging
  */
-export const logWithLevel: (level?: LogLevel) => (...message: ReadonlyArray<any>) => Effect<void> =
+export const logWithLevel: (level?: Severity) => (...message: ReadonlyArray<any>) => Effect<void> =
   internal.logWithLevel
 
 /**
@@ -20767,6 +21105,86 @@ export const annotateLogs = dual<
     })
 )
 
+/**
+ * Adds log annotations to the current scope.
+ *
+ * This differs from `annotateLogs`, which only annotates a specific effect.
+ * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+ * restores the previous annotations when the scope closes.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function*() {
+ *     yield* Effect.log("before")
+ *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+ *     yield* Effect.log("inside scope")
+ *   })
+ * )
+ *
+ * Effect.runPromise(program)
+ * ```
+ *
+ * @since 4.0.0
+ * @category Logging
+ */
+export const annotateLogsScoped: {
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (key: string, value: unknown): Effect<void, never, Scope>
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (values: Record<string, unknown>): Effect<void, never, Scope>
+} = internal.annotateLogsScoped
+
 /**
  * Adds a span to each log line in this effect.
  *
@@ -21429,18 +21847,20 @@ export const trackSuccesses: {
  *
  * @example
  * ```ts
- * import { Effect, Metric } from "effect"
+ * import { Data, Effect, Metric } from "effect"
+ *
+ * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
  *
  * // Track error types using frequency metric
  * const errorTypeFrequency = Metric.frequency("error_types")
  *
- * const program = Effect.fail(new Error("Connection failed")).pipe(
- *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+ * const program = Effect.fail(new ConnectionFailedError()).pipe(
+ *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
  * )
  *
  * Effect.runPromiseExit(program).then(() =>
  *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
- *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+ *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
  * )
  * ```
  *
@@ -21475,18 +21895,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21521,18 +21943,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21567,18 +21991,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -21617,18 +22043,20 @@ export const trackErrors: {
    *
    * @example
    * ```ts
-   * import { Effect, Metric } from "effect"
+   * import { Data, Effect, Metric } from "effect"
+   *
+   * class ConnectionFailedError extends Data.TaggedError("ConnectionFailedError")<{}> {}
    *
    * // Track error types using frequency metric
    * const errorTypeFrequency = Metric.frequency("error_types")
    *
-   * const program = Effect.fail(new Error("Connection failed")).pipe(
-   *   Effect.trackErrors(errorTypeFrequency, (error: Error) => error.name)
+   * const program = Effect.fail(new ConnectionFailedError()).pipe(
+   *   Effect.trackErrors(errorTypeFrequency, (error: ConnectionFailedError) => error._tag)
    * )
    *
    * Effect.runPromiseExit(program).then(() =>
    *   Effect.runPromise(Metric.value(errorTypeFrequency)).then(console.log)
-   *   // Output: { occurrences: Map(1) { "Error" => 1 } }
+   *   // Output: { occurrences: Map(1) { "ConnectionFailedError" => 1 } }
    * )
    * ```
    *
@@ -22151,8 +22579,8 @@ export const trackDuration: {
       return onExit(self, () => {
         const endTime = clock.currentTimeNanosUnsafe()
         const duration = Duration.subtract(
-          Duration.fromDurationInputUnsafe(endTime),
-          Duration.fromDurationInputUnsafe(startTime)
+          Duration.fromInputUnsafe(endTime),
+          Duration.fromInputUnsafe(startTime)
         )
         const input = f === undefined ? duration : internalCall(() => f(duration))
         return Metric.update(metric, input as any)
@@ -22200,136 +22628,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.
- *
- * In Effect transactions are optimistic with retry, that means transactions are retried when:
+ * Accesses the current transaction state within an active transaction.
  *
- * - 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)
- *
- *   // Nested atomic transaction - ref1 will be part of outer transaction
- *   yield* Effect.atomic(Effect.gen(function*() {
- *     yield* TxRef.set(ref1, 10)
+ *   const ref1 = yield* Effect.transaction(TxRef.make(0))
+ *   const ref2 = yield* Effect.transaction(TxRef.make(0))
  *
- *     // 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
  * })
  * ```
  *
@@ -22341,34 +22703,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
@@ -22476,16 +22825,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}`)
@@ -22997,18 +23346,20 @@ export const satisfiesSuccessType = <A>() => <A2 extends A, E, R>(effect: Effect
  *
  * @example
  * ```ts
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class ValidationError extends Data.TaggedError("ValidationError")<{}> {}
  *
- * // Define a constraint that the error type must be an Error
- * const satisfiesError = Effect.satisfiesErrorType<Error>()
+ * // Define a constraint that the error type must be a ValidationError
+ * const satisfiesError = Effect.satisfiesErrorType<ValidationError>()
  *
- * // This works - Effect<number, TypeError, never> extends Effect<number, Error, never>
- * const validEffect = satisfiesError(Effect.fail(new TypeError("Invalid type")))
+ * // This works - Effect<number, ValidationError, never> extends the constrained type
+ * const validEffect = satisfiesError(Effect.fail(new ValidationError()))
  *
  * // This would cause a TypeScript compilation error:
  * // const invalidEffect = satisfiesError(Effect.fail("string error"))
  * //                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- * // Type 'string' is not assignable to type 'Error'
+ * // Type 'string' is not assignable to type 'ValidationError'
  * ```
  *
  * @since 4.0.0