effect 4.0.0-beta.6 → 4.0.0-beta.60

package/dist/Effect.d.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
@@ -69,6 +71,7 @@
 import type * as Arr from "./Array.ts";
 import type * as Cause from "./Cause.ts";
 import type { Clock } from "./Clock.ts";
+import * as Context from "./Context.ts";
 import * as Duration from "./Duration.ts";
 import type { ExecutionPlan } from "./ExecutionPlan.ts";
 import * as Exit from "./Exit.ts";
@@ -76,9 +79,10 @@ import type { Fiber } from "./Fiber.ts";
 import type * as Filter from "./Filter.ts";
 import { type LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.ts";
+import type { Inspectable } from "./Inspectable.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";
@@ -89,10 +93,9 @@ import type * as Result from "./Result.ts";
 import type { Schedule } from "./Schedule.ts";
 import type { Scheduler } from "./Scheduler.ts";
 import type { Scope } from "./Scope.ts";
-import * as ServiceMap from "./ServiceMap.ts";
 import type { AnySpan, ParentSpan, Span, SpanLink, SpanOptions, SpanOptionsNoTrace, TraceOptions, Tracer } from "./Tracer.ts";
 import type { TxRef } from "./TxRef.ts";
-import type { Concurrency, Covariant, EqualsWith, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NoInfer, ReasonOf, ReasonTags, Tags, unassigned } from "./Types.ts";
+import type { Concurrency, Covariant, EqualsWith, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NarrowReason, NoInfer, OmitReason, ReasonOf, ReasonTags, Simplify, Tags, unassigned } from "./Types.ts";
 import type * as Unify from "./Unify.ts";
 declare const TypeId: "~effect/Effect";
 /**
@@ -111,13 +114,15 @@ declare const TypeId: "~effect/Effect";
  *
  * @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*() {
@@ -130,11 +135,11 @@ declare const TypeId: "~effect/Effect";
  * @since 2.0.0
  * @category Models
  */
-export interface Effect<out A, out E = never, out R = never> extends Pipeable, Yieldable<Effect<A, E, R>, A, E, R> {
+export interface Effect<out A, out E = never, out R = never> extends Pipeable, Inspectable, Yieldable<Effect<A, E, R>, A, E, R> {
     readonly [TypeId]: Variance<A, E, R>;
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: EffectUnify<this>;
-    [Unify.ignoreSymbol]?: EffectUnifyIgnore;
+    [Unify.ignoreSymbol]?: {};
 }
 /**
  * A type that can be yielded in an Effect generator function.
@@ -191,21 +196,6 @@ export interface EffectUnify<A extends {
 }> {
     Effect?: () => A[Unify.typeSymbol] extends Effect<infer A0, infer E0, infer R0> | infer _ ? Effect<A0, E0, R0> : never;
 }
-/**
- * @category Models
- * @since 2.0.0
- * @example
- * ```ts
- * import type { Effect } from "effect"
- *
- * // EffectUnifyIgnore is used internally to control type unification
- * // It prevents certain types from being unified with Effect types
- * declare const ignored: Effect.EffectUnifyIgnore
- * ```
- */
-export interface EffectUnifyIgnore {
-    Effect?: true;
-}
 /**
  * @category Type Lambdas
  * @since 2.0.0
@@ -367,13 +357,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())
      * ]
      * ```
      */
@@ -625,7 +617,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
@@ -724,6 +715,291 @@ export declare const partition: {
         readonly concurrency?: Concurrency | undefined;
     }): Effect<[excluded: Array<E>, satisfying: Array<B>], never, 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
+ */
+export declare 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>;
+};
+/**
+ * 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 declare 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>;
+};
+/**
+ * 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 declare 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>;
+};
 /**
  * Executes an effectful operation for each element in an `Iterable`.
  *
@@ -1068,16 +1344,18 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  *
  * @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)
  * ```
@@ -1307,8 +1585,13 @@ undefined_ as undefined };
  *
  * **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
@@ -1352,6 +1635,90 @@ export declare const callback: <A, E = never, R = never>(register: (this: Schedu
  * @category Creating Effects
  */
 export declare const never: Effect<never>;
+/**
+ * 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 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 declare const Do: Effect<{}>;
+/**
+ * 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 declare 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>;
+};
+declare 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>;
+};
+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 declare 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>;
+};
 /**
  * Provides a way to write effectful code using generator functions, simplifying
  * control flow and error handling.
@@ -1369,16 +1736,18 @@ export declare const never: Effect<never>;
  *
  * @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))
@@ -1418,16 +1787,18 @@ export declare 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))
@@ -1471,16 +1842,18 @@ export declare 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))
@@ -1535,12 +1908,14 @@ export declare namespace gen {
  * @example
  * ```ts
  * // Title: Creating a Failed Effect
- * import { Effect } from "effect"
+ * import { Data, Effect } from "effect"
+ *
+ * class OperationFailedError extends Data.TaggedError("OperationFailedError")<{}> {}
  *
- * //      ┌─── Effect<never, Error, never>
+ * //      ┌─── Effect<never, OperationFailedError, never>
  * //      ▼
  * const failure = Effect.fail(
- *   new Error("Operation failed due to network error")
+ *   new OperationFailedError()
  * )
  * ```
  *
@@ -1556,9 +1931,11 @@ export declare const fail: <E>(error: E) => Effect<never, E>;
  *
  * @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: ... }
@@ -1705,12 +2082,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)
@@ -1832,17 +2211,17 @@ export declare const fromOption: <A>(option: Option<A>) => Effect<A, Cause.NoSuc
  * ```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
@@ -1903,15 +2282,17 @@ export declare const fromYieldable: <Self extends Yieldable.Any, A, E, R>(yielda
  *
  * @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
@@ -1965,15 +2346,17 @@ export declare 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
@@ -2027,15 +2410,17 @@ export declare 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
@@ -2120,15 +2505,17 @@ export declare const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2
  *
  * @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
@@ -2201,15 +2588,17 @@ export declare 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
@@ -2282,15 +2671,17 @@ export declare 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
@@ -2363,15 +2754,17 @@ export declare 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
@@ -2444,15 +2837,17 @@ export declare 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
@@ -2510,16 +2905,18 @@ export declare 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
@@ -2569,16 +2966,18 @@ export declare 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
@@ -2628,16 +3027,18 @@ export declare 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
@@ -2687,16 +3088,18 @@ export declare 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
@@ -2746,16 +3149,18 @@ export declare 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
@@ -3538,12 +3943,12 @@ export {
  *
  * **Details**
  *
- * The `catchAll` function catches any errors that may occur during the
+ * The `catch` function catches any errors that may occur during the
  * execution of an effect and allows you to handle them by specifying a fallback
  * effect. This ensures that the program continues without failing by recovering
  * from errors using the provided fallback logic.
  *
- * **Note**: `catchAll` only handles recoverable errors. It will not recover
+ * **Note**: `catch` only handles recoverable errors. It will not recover
  * from unrecoverable defects.
  *
  * @see {@link catchCause} for a version that can recover from both recoverable and unrecoverable errors.
@@ -3691,7 +4096,8 @@ export declare 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.
@@ -3733,7 +4139,8 @@ export declare 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.
@@ -3775,13 +4182,15 @@ export declare const catchTags: {
         [K in Exclude<keyof Cases, Extract<E, {
             _tag: string;
         }>["_tag"]>]: never;
-    })>(cases: Cases): <A, R>(self: Effect<A, E, R>) => Effect<A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
-    }[keyof Cases], Exclude<E, {
+    }), 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], E2 | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
-    }[keyof Cases], R | {
+    }[keyof Cases], R | R2 | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never;
     }[keyof Cases]>;
     /**
@@ -3793,7 +4202,8 @@ export declare 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.
@@ -3835,13 +4245,15 @@ export declare const catchTags: {
         [K in Exclude<keyof Cases, Extract<E, {
             _tag: string;
         }>["_tag"]>]: never;
-    })>(self: Effect<A, E, R>, cases: Cases): Effect<A | {
-        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
-    }[keyof Cases], Exclude<E, {
+    }), 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], E2 | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
-    }[keyof Cases], R | {
+    }[keyof Cases], R | R2 | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer R> ? R : never;
     }[keyof Cases]>;
 };
@@ -3916,7 +4328,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect<A2, E2, R2>, orElse?: ((reasons: ExcludeReason<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>;
+    <K extends Tags<E>, E, RK extends ReasonTags<ExtractTag<NoInfer<E>, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(errorTag: K, reasonTag: RK, f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => 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>;
     /**
      * Catches a specific reason within a tagged error.
      *
@@ -3952,7 +4364,7 @@ export declare const catchReason: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: 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): Effect<A | A2 | Exclude<A3, unassigned>, (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3, R | R2 | R3>;
+    <A, E, R, K extends Tags<E>, RK extends ReasonTags<ExtractTag<E, K>>, A2, E2, R2, A3 = unassigned, E3 = never, R3 = never>(self: Effect<A, E, R>, errorTag: K, reasonTag: RK, 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>;
 };
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
@@ -4024,8 +4436,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <K extends Tags<E>, E, Cases extends {
-        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | {
+        [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>, error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect<any, any, any>;
+    }, A2 = unassigned, E2 = never, R2 = never>(errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>) | undefined): <A, R>(self: Effect<A, E, R>) => Effect<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
@@ -4067,8 +4479,8 @@ export declare const catchReasons: {
      * @category Error Handling
      */
     <A, E, R, K extends Tags<E>, Cases extends {
-        [RK in ReasonTags<ExtractTag<E, K>>]+?: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Effect<any, any, any>;
-    }, A2 = unassigned, E2 = never, R2 = never>(self: Effect<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | {
+        [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, R2 = never>(self: Effect<A, E, R>, errorTag: K, cases: Cases, orElse?: ((reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>, error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>) => Effect<A2, E2, R2>) | undefined): Effect<A | Exclude<A2, unassigned> | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Effect<infer A, any, any> ? A : never;
     }[keyof Cases], (A2 extends unassigned ? E : ExcludeTag<E, K>) | E2 | {
         [RK in keyof Cases]: Cases[RK] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
@@ -4469,15 +4881,14 @@ export declare const catchDefect: {
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (defect: unknown) => Effect<A2, E2, R2>): Effect<A | A2, E | E2, R | R2>;
 };
 /**
- * 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**
  *
@@ -4504,7 +4915,7 @@ export declare const catchDefect: {
  *
  * // With a Filter
  * const recovered2 = program.pipe(
- *   Effect.catchIf(
+ *   Effect.catchFilter(
  *     Filter.tagged("NotFound"),
  *     (error) => Effect.succeed(`missing:${error.id}`)
  *   )
@@ -4516,15 +4927,14 @@ export declare const catchDefect: {
  */
 export declare 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**
      *
@@ -4551,7 +4961,7 @@ export declare const catchIf: {
      *
      * // With a Filter
      * const recovered2 = program.pipe(
-     *   Effect.catchIf(
+     *   Effect.catchFilter(
      *     Filter.tagged("NotFound"),
      *     (error) => Effect.succeed(`missing:${error.id}`)
      *   )
@@ -4563,15 +4973,14 @@ export declare const catchIf: {
      */
     <E, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(refinement: Predicate.Refinement<NoInfer<E>, EB>, f: (e: EB) => Effect<A2, E2, R2>, 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**
      *
@@ -4598,7 +5007,7 @@ export declare const catchIf: {
      *
      * // With a Filter
      * const recovered2 = program.pipe(
-     *   Effect.catchIf(
+     *   Effect.catchFilter(
      *     Filter.tagged("NotFound"),
      *     (error) => Effect.succeed(`missing:${error.id}`)
      *   )
@@ -4608,17 +5017,16 @@ export declare 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): <A, R>(self: Effect<A, E, R>) => Effect<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <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**
      *
@@ -4645,7 +5053,7 @@ export declare const catchIf: {
      *
      * // With a Filter
      * const recovered2 = program.pipe(
-     *   Effect.catchIf(
+     *   Effect.catchFilter(
      *     Filter.tagged("NotFound"),
      *     (error) => Effect.succeed(`missing:${error.id}`)
      *   )
@@ -4657,15 +5065,14 @@ export declare const catchIf: {
      */
     <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(self: Effect<A, E, R>, refinement: Predicate.Refinement<E, EB>, f: (e: EB) => Effect<A2, E2, R2>, 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**
      *
@@ -4692,7 +5099,7 @@ export declare const catchIf: {
      *
      * // With a Filter
      * const recovered2 = program.pipe(
-     *   Effect.catchIf(
+     *   Effect.catchFilter(
      *     Filter.tagged("NotFound"),
      *     (error) => Effect.succeed(`missing:${error.id}`)
      *   )
@@ -4702,7 +5109,29 @@ export declare 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>(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): Effect<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(self: Effect<A, E, R>, 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>;
+};
+/**
+ * Recovers from specific errors using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare 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>;
 };
 /**
  * Catches `NoSuchElementError` failures and converts them to `Option.none`.
@@ -4808,7 +5237,7 @@ export declare 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.
      *
@@ -4847,7 +5276,29 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(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>;
+    <A, E, R, B, E2, R2>(self: Effect<A, E, R>, predicate: Predicate.Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>): Effect<A | B, E | E2, R | R2>;
+};
+/**
+ * Recovers from specific failures based on a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare 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>;
 };
 /**
  * The `mapError` function is used to transform or modify the error
@@ -4864,17 +5315,19 @@ export declare 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 })
  * )
  * ```
  *
@@ -4897,17 +5350,19 @@ export declare 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 })
      * )
      * ```
      *
@@ -4930,17 +5385,19 @@ export declare 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 })
      * )
      * ```
      *
@@ -4961,16 +5418,18 @@ export declare 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
  * })
  * ```
@@ -4994,16 +5453,18 @@ export declare 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
      * })
      * ```
@@ -5030,16 +5491,18 @@ export declare 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
      * })
      * ```
@@ -5073,11 +5536,13 @@ export declare 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>
@@ -5086,7 +5551,7 @@ export declare const mapBoth: {
  *
  * Effect.runPromise(program).catch(console.error)
  * // Output:
- * // (FiberFailure) Error: Cannot divide by zero
+ * // (FiberFailure) DivideByZeroError
  * //   ...stack trace...
  * ```
  *
@@ -5454,7 +5919,7 @@ export declare 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>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | 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, E | E2, R | R2>;
     /**
      * Conditionally executes a side effect based on the cause of a failed effect.
      *
@@ -5483,7 +5948,29 @@ export declare const tapCauseIf: {
      * @since 4.0.0
      * @category Sequencing
      */
-    <A, E, R, Result extends Filter.ResultOrBool, 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>): Effect<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Effect<A, E, R>, predicate: Predicate.Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>): 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
+ */
+export declare 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>;
 };
 /**
  * Inspect severe errors or defects (non-recoverable failures) in an effect.
@@ -5660,7 +6147,7 @@ export declare const tapDefect: {
  *   attempts++
  *   yield* Console.log(`Attempt ${attempts}`)
  *   if (attempts < 3) {
- *     yield* Effect.fail("Not ready")
+ *     return yield* Effect.fail("Not ready")
  *   }
  *   return "Ready"
  * })
@@ -5708,9 +6195,13 @@ export declare namespace Retry {
      */
     type Return<R, E, A, O extends Options<E>> = Effect<A, (O extends {
         schedule: Schedule<infer _O, infer _I, infer _E1, infer _R>;
-    } ? E | _E1 : O extends {
+    } ? E : O extends {
+        times: number;
+    } ? E : O extends {
         until: Predicate.Refinement<E, infer E2>;
-    } ? E2 : E) | (O extends {
+    } ? E2 : O extends {
+        while: Predicate.Refinement<E, infer E2>;
+    } ? Exclude<E, E2> : E) | (O extends {
         schedule: Schedule<infer _O, infer _I, infer E, infer _R>;
     } ? E : never) | (O extends {
         while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
@@ -5769,13 +6260,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!"))
  *   }
@@ -5818,13 +6311,15 @@ export declare 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!"))
      *   }
@@ -5867,13 +6362,15 @@ export declare 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!"))
      *   }
@@ -5916,13 +6413,15 @@ export declare 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!"))
      *   }
@@ -5965,13 +6464,15 @@ export declare 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!"))
      *   }
@@ -6014,13 +6515,15 @@ export declare 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!"))
      *   }
@@ -6063,13 +6566,15 @@ export declare 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!"))
      *   }
@@ -6110,14 +6615,16 @@ export declare 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"
  * })
@@ -6165,14 +6672,16 @@ export declare 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"
      * })
@@ -6220,14 +6729,16 @@ export declare 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"
      * })
@@ -6300,7 +6811,8 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
  * 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
@@ -6324,7 +6836,7 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
  * 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**
@@ -6337,16 +6849,20 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
  * @category Error Handling
  */
 export declare 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>;
 /**
  * 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
@@ -6355,18 +6871,21 @@ export declare const ignore: <Arg extends Effect<any, any, any> | {
  * 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
  * @category Error Handling
  */
 export declare 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>;
 /**
  * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
@@ -6378,13 +6897,16 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
  *
  * @example
  * ```ts
- * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+ * import { Effect, ExecutionPlan, Layer, Context } from "effect"
  *
- * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+ * const Endpoint = Context.Service<{ url: string }>("Endpoint")
  *
  * 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(
@@ -6409,13 +6931,16 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+     * import { Effect, ExecutionPlan, Layer, Context } from "effect"
      *
-     * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+     * const Endpoint = Context.Service<{ url: string }>("Endpoint")
      *
      * 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(
@@ -6445,13 +6970,16 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+     * import { Effect, ExecutionPlan, Layer, Context } from "effect"
      *
-     * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+     * const Endpoint = Context.Service<{ url: string }>("Endpoint")
      *
      * 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(
@@ -6472,6 +7000,22 @@ export declare const withExecutionPlan: {
         requirements: PlanR;
     }>): Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>;
 };
+/**
+ * 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 declare 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>;
 /**
  * Replaces the original failure with a success value, ensuring the effect
  * cannot fail.
@@ -6692,7 +7236,7 @@ export declare 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>;
     /**
      * Adds a time limit to an effect, triggering a timeout if the effect exceeds
      * the duration.
@@ -6739,7 +7283,7 @@ export declare 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>;
 };
 /**
  * Handles timeouts by returning an `Option` that represents either the result
@@ -6840,7 +7384,7 @@ export declare 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.
@@ -6890,7 +7434,7 @@ export declare 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>;
 };
 /**
  * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
@@ -6911,7 +7455,7 @@ export declare const timeoutOption: {
  * // Use cached data as fallback when timeout is reached
  * const program = Effect.timeoutOrElse(slowQuery, {
  *   duration: "2 seconds",
- *   onTimeout: () =>
+ *   orElse: () =>
  *     Effect.gen(function*() {
  *       yield* Console.log("Query timed out, using cached data")
  *       return "Cached result"
@@ -6948,7 +7492,7 @@ export declare const timeoutOrElse: {
      * // Use cached data as fallback when timeout is reached
      * const program = Effect.timeoutOrElse(slowQuery, {
      *   duration: "2 seconds",
-     *   onTimeout: () =>
+     *   orElse: () =>
      *     Effect.gen(function*() {
      *       yield* Console.log("Query timed out, using cached data")
      *       return "Cached result"
@@ -6966,8 +7510,8 @@ export declare const timeoutOrElse: {
      * @category Delays & Timeouts
      */
     <A2, E2, R2>(options: {
-        readonly duration: Duration.DurationInput;
-        readonly onTimeout: LazyArg<Effect<A2, E2, R2>>;
+        readonly duration: Duration.Input;
+        readonly orElse: LazyArg<Effect<A2, E2, R2>>;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2, R | R2>;
     /**
      * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
@@ -6988,7 +7532,7 @@ export declare const timeoutOrElse: {
      * // Use cached data as fallback when timeout is reached
      * const program = Effect.timeoutOrElse(slowQuery, {
      *   duration: "2 seconds",
-     *   onTimeout: () =>
+     *   orElse: () =>
      *     Effect.gen(function*() {
      *       yield* Console.log("Query timed out, using cached data")
      *       return "Cached result"
@@ -7006,8 +7550,8 @@ export declare const timeoutOrElse: {
      * @category Delays & Timeouts
      */
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, options: {
-        readonly duration: Duration.DurationInput;
-        readonly onTimeout: LazyArg<Effect<A2, E2, R2>>;
+        readonly duration: Duration.Input;
+        readonly orElse: LazyArg<Effect<A2, E2, R2>>;
     }): Effect<A | A2, E | E2, R | R2>;
 };
 /**
@@ -7051,7 +7595,7 @@ export declare 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`.
@@ -7072,7 +7616,7 @@ export declare 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>;
 };
 /**
  * Returns an effect that suspends for the specified duration. This method is
@@ -7096,7 +7640,7 @@ export declare const delay: {
  * @since 2.0.0
  * @category Delays & Timeouts
  */
-export declare const sleep: (duration: Duration.DurationInput) => Effect<void>;
+export declare const sleep: (duration: Duration.Input) => Effect<void>;
 /**
  * Measures the runtime of an effect and returns the duration with its result.
  *
@@ -7389,12 +7933,12 @@ export declare const raceFirst: {
     }): Effect<A | A2, E | E2, R | R2>;
 };
 /**
- * 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)
@@ -7402,10 +7946,7 @@ export declare 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
@@ -7413,12 +7954,12 @@ export declare const raceFirst: {
  */
 export declare 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)
@@ -7426,10 +7967,7 @@ export declare 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
@@ -7437,12 +7975,12 @@ export declare const filter: {
      */
     <A, B extends A>(refinement: Predicate.Refinement<NoInfer<A>, B>): (elements: Iterable<A>) => Effect<Array<B>>;
     /**
-     * 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)
@@ -7450,10 +7988,7 @@ export declare 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
@@ -7461,12 +7996,12 @@ export declare const filter: {
      */
     <A>(predicate: Predicate.Predicate<NoInfer<A>>): (elements: Iterable<A>) => Effect<Array<A>>;
     /**
-     * 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)
@@ -7474,25 +8009,22 @@ export declare 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>, options?: {
+    <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>;
     /**
-     * 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)
@@ -7500,25 +8032,20 @@ export declare 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>>;
     /**
-     * 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)
@@ -7526,25 +8053,20 @@ export declare 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>>;
     /**
-     * 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)
@@ -7552,116 +8074,63 @@ export declare 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>>;
+    <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>;
+};
+/**
+ * Filters and maps elements of an iterable with a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMap: {
     /**
-     * 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))
-     * )
-     * ```
+     * Filters and maps elements of an iterable with a `Filter`.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A>(elements: Iterable<A>, predicate: Predicate.Predicate<A>): Effect<Array<A>>;
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): (elements: Iterable<A>) => Effect<Array<B>>;
     /**
-     * Filters elements of an iterable using a predicate, refinement, effectful
-     * predicate, or `Filter.FilterEffect`.
+     * Filters and maps elements of an iterable with a `Filter`.
      *
-     * @example
-     * ```ts
-     * import { Effect, Filter, Result } from "effect"
-     *
-     * // Sync predicate
-     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-     *
-     * // Effectful predicate
-     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-     *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
     <A, B, X>(elements: Iterable<A>, filter: Filter.Filter<NoInfer<A>, B, X>): Effect<Array<B>>;
+};
+/**
+ * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMapEffect: {
     /**
-     * Filters elements of an iterable using a predicate, refinement, effectful
-     * predicate, or `Filter.FilterEffect`.
-     *
-     * @example
-     * ```ts
-     * import { Effect, Filter, Result } from "effect"
-     *
-     * // Sync predicate
-     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-     *
-     * // Effectful predicate
-     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-     *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
+     * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, B, X, E, R>(elements: Iterable<A>, filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>, options?: {
+    <A, B, X, E, R>(filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>, options?: {
         readonly concurrency?: Concurrency | undefined;
-    }): Effect<Array<B>, E, R>;
+    }): (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>, options?: {
+    <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>;
+    }): Effect<Array<B>, E, R>;
 };
 /**
  * Filters an effect, providing an alternative effect if the predicate fails.
@@ -7755,7 +8224,7 @@ export declare 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.
      *
@@ -7817,7 +8286,29 @@ export declare const filterOrElse: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool, 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>;
+    <A, E, R, C, E2, R2>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => Effect<C, E2, R2>): Effect<A | C, E | E2, R | R2>;
+};
+/**
+ * Filters an effect with a `Filter`, providing an alternative effect on failure.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare 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>;
 };
 /**
  * Filters an effect, failing with a custom error if the predicate fails.
@@ -7878,127 +8369,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E2, B extends A>(refinement: Predicate.Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => 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.
-     *
-     * **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, E2>(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.
-     *
-     * **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 extends A>(refinement: Predicate.Refinement<NoInfer<A>, B>): <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.
-     *
-     * **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>(predicate: Predicate.Predicate<NoInfer<A>>): <E, R>(self: Effect<A, E, R>) => Effect<A, Cause.NoSuchElementError | E, R>;
+    <A, E2, B extends A>(refinement: Predicate.Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => 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.
      *
@@ -8028,7 +8399,7 @@ export declare const filterOrFail: {
      * @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>;
+    <A, E2>(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.
      *
@@ -8058,7 +8429,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, E2, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): Effect<B, E2 | E, R>;
+    <A, B extends A>(refinement: Predicate.Refinement<NoInfer<A>, B>): <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.
      *
@@ -8088,7 +8459,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, E2>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): Effect<A, E2 | E, R>;
+    <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.
      *
@@ -8118,7 +8489,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B, X, E2>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>, orFailWith: (x: X) => E2): Effect<B, E2 | E, R>;
+    <A, E, R, E2, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): Effect<B, E2 | E, R>;
     /**
      * Filters an effect, failing with a custom error if the predicate fails.
      *
@@ -8148,7 +8519,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>): Effect<B, E | Cause.NoSuchElementError, R>;
+    <A, E, R, E2>(self: Effect<A, E, R>, 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.
      *
@@ -8178,7 +8549,7 @@ export declare const filterOrFail: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>): Effect<A, E | Cause.NoSuchElementError, R>;
+    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>): Effect<B, E | Cause.NoSuchElementError, R>;
     /**
      * Filters an effect, failing with a custom error if the predicate fails.
      *
@@ -8208,7 +8579,43 @@ export declare const filterOrFail: {
      * @since 2.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>;
+    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>): Effect<A, E | Cause.NoSuchElementError, R>;
+};
+/**
+ * Filters an effect with a `Filter`, failing when the filter fails.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMapOrFail: {
+    /**
+     * Filters an effect with a `Filter`, failing when the filter fails.
+     *
+     * @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.
+     *
+     * @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 4.0.0
+     * @category Filtering
+     */
+    <A, E, R, B, X, E2>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>, orFailWith: (x: X) => E2): Effect<B, E2 | E, R>;
+    /**
+     * Filters an effect with a `Filter`, failing when the filter fails.
+     *
+     * @since 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>;
 };
 /**
  * Conditionally executes an effect based on a boolean condition.
@@ -8349,9 +8756,11 @@ export declare const when: {
  * @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}`,
@@ -8362,8 +8771,8 @@ export declare 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, {
@@ -8401,9 +8810,11 @@ export declare 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}`,
@@ -8414,8 +8825,8 @@ export declare 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, {
@@ -8456,9 +8867,11 @@ export declare 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}`,
@@ -8469,8 +8882,8 @@ export declare 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, {
@@ -8872,9 +9285,11 @@ export declare const matchCauseEffectEager: {
  *
  * @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) =>
@@ -8924,9 +9339,11 @@ export declare 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) =>
@@ -8979,9 +9396,11 @@ export declare 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) =>
@@ -9041,11 +9460,13 @@ export declare const matchCauseEffect: {
  * @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, {
@@ -9101,11 +9522,13 @@ export declare 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, {
@@ -9164,11 +9587,13 @@ export declare 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, {
@@ -9260,7 +9685,7 @@ export declare const isFailure: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
  */
 export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
 /**
- * Returns the complete service map from the current context.
+ * Returns the complete context.
  *
  * This function allows you to access all services that are currently available
  * in the effect's environment. This can be useful for debugging, introspection,
@@ -9268,56 +9693,56 @@ export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
  *
  * @example
  * ```ts
- * import { Console, Effect, Option, ServiceMap } from "effect"
+ * import { Console, Effect, Option, Context } from "effect"
  *
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Database = ServiceMap.Service<{
+ * const Database = Context.Service<{
  *   query: (sql: string) => string
  * }>("Database")
  *
  * const program = Effect.gen(function*() {
- *   const allServices = yield* Effect.services()
+ *   const allServices = yield* Effect.context()
  *
  *   // Check if specific services are available
- *   const loggerOption = ServiceMap.getOption(allServices, Logger)
- *   const databaseOption = ServiceMap.getOption(allServices, Database)
+ *   const loggerOption = Context.getOption(allServices, Logger)
+ *   const databaseOption = Context.getOption(allServices, Database)
  *
  *   yield* Console.log(`Logger available: ${Option.isSome(loggerOption)}`)
  *   yield* Console.log(`Database available: ${Option.isSome(databaseOption)}`)
  * })
  *
- * const serviceMap = ServiceMap.make(Logger, { log: console.log })
- *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+ * const context = Context.make(Logger, { log: console.log })
+ *   .pipe(Context.add(Database, { query: () => "result" }))
  *
- * const provided = Effect.provideServices(program, serviceMap)
+ * const provided = Effect.provideContext(program, context)
  * ```
  *
  * @since 2.0.0
  * @category Environment
  */
-export declare const services: <R>() => Effect<ServiceMap.ServiceMap<R>, never, R>;
+export declare const context: <R = never>() => Effect<Context.Context<R>, never, R>;
 /**
- * Transforms the current service map using the provided function.
+ * Transforms the current context using the provided function.
  *
- * This function allows you to access the complete service map and perform
+ * This function allows you to access the complete context and perform
  * computations based on all available services. This is useful when you need
  * to conditionally execute logic based on what services are available.
  *
  * @example
  * ```ts
- * import { Console, Effect, Option, ServiceMap } from "effect"
+ * import { Console, Effect, Option, Context } from "effect"
  *
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Cache = ServiceMap.Service<{
+ * const Cache = Context.Service<{
  *   get: (key: string) => string | null
  * }>("Cache")
  *
- * const program = Effect.servicesWith((services) => {
- *   const cacheOption = ServiceMap.getOption(services, Cache)
+ * const program = Effect.contextWith((services) => {
+ *   const cacheOption = Context.getOption(services, Cache)
  *   const hasCache = Option.isSome(cacheOption)
  *
  *   if (hasCache) {
@@ -9342,7 +9767,7 @@ export declare const services: <R>() => Effect<ServiceMap.ServiceMap<R>, never,
  * @since 2.0.0
  * @category Environment
  */
-export declare const servicesWith: <R, A, E, R2>(f: (services: ServiceMap.ServiceMap<R>) => Effect<A, E, R2>) => Effect<A, E, R | R2>;
+export declare const contextWith: <R, A, E, R2>(f: (context: Context.Context<R>) => Effect<A, E, R2>) => Effect<A, E, R | R2>;
 /**
  * Provides dependencies to an effect using layers or a context. Use `options.local`
  * to build the layer every time; by default, layers are shared between provide
@@ -9350,16 +9775,16 @@ export declare const servicesWith: <R, A, E, R2>(f: (services: ServiceMap.Servic
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
  * interface Database {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.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*() {
@@ -9384,16 +9809,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9420,16 +9845,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9456,16 +9881,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9482,7 +9907,7 @@ export declare const provide: {
      * @since 2.0.0
      * @category Environment
      */
-    <R2>(context: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>;
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>;
     /**
      * Provides dependencies to an effect using layers or a context. Use `options.local`
      * to build the layer every time; by default, layers are shared between provide
@@ -9490,16 +9915,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9526,16 +9951,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9562,16 +9987,16 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Effect, Layer, ServiceMap } from "effect"
+     * import { Effect, Layer, Context } from "effect"
      *
      * interface Database {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
      *
-     * const Database = ServiceMap.Service<Database>("Database")
+     * const Database = Context.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*() {
@@ -9588,32 +10013,32 @@ export declare const provide: {
      * @since 2.0.0
      * @category Environment
      */
-    <A, E, R, R2>(self: Effect<A, E, R>, context: ServiceMap.ServiceMap<R2>): Effect<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(self: Effect<A, E, R>, context: Context.Context<R2>): Effect<A, E, Exclude<R, R2>>;
 };
 /**
- * Provides a service map to an effect, fulfilling its service requirements.
+ * Provides a context to an effect, fulfilling its service requirements.
  *
  * **Details**
  *
- * This function provides multiple services at once by supplying a service map
+ * This function provides multiple services at once by supplying a context
  * that contains all the required services. It removes the provided services
  * from the effect's requirements, making them available to the effect.
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * // Define service keys
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Database = ServiceMap.Service<{
+ * const Database = Context.Service<{
  *   query: (sql: string) => string
  * }>("Database")
  *
- * // Create service map with multiple services
- * const serviceMap = ServiceMap.make(Logger, { log: console.log })
- *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+ * // Create a context with multiple services
+ * const context = Context.make(Logger, { log: console.log })
+ *   .pipe(Context.add(Database, { query: () => "result" }))
  *
  * // An effect that requires both services
  * const program = Effect.gen(function*() {
@@ -9623,37 +10048,37 @@ export declare const provide: {
  *   return db.query("SELECT * FROM users")
  * })
  *
- * const provided = Effect.provideServices(program, serviceMap)
+ * const provided = Effect.provideContext(program, context)
  * ```
  *
  * @since 2.0.0
  * @category Environment
  */
-export declare const provideServices: {
+export declare const provideContext: {
     /**
-     * Provides a service map to an effect, fulfilling its service requirements.
+     * Provides a context to an effect, fulfilling its service requirements.
      *
      * **Details**
      *
-     * This function provides multiple services at once by supplying a service map
+     * This function provides multiple services at once by supplying a context
      * that contains all the required services. It removes the provided services
      * from the effect's requirements, making them available to the effect.
      *
      * @example
      * ```ts
-     * import { Effect, ServiceMap } from "effect"
+     * import { Effect, Context } from "effect"
      *
      * // Define service keys
-     * const Logger = ServiceMap.Service<{
+     * const Logger = Context.Service<{
      *   log: (msg: string) => void
      * }>("Logger")
-     * const Database = ServiceMap.Service<{
+     * const Database = Context.Service<{
      *   query: (sql: string) => string
      * }>("Database")
      *
-     * // Create service map with multiple services
-     * const serviceMap = ServiceMap.make(Logger, { log: console.log })
-     *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+     * // Create a context with multiple services
+     * const context = Context.make(Logger, { log: console.log })
+     *   .pipe(Context.add(Database, { query: () => "result" }))
      *
      * // An effect that requires both services
      * const program = Effect.gen(function*() {
@@ -9663,37 +10088,37 @@ export declare const provideServices: {
      *   return db.query("SELECT * FROM users")
      * })
      *
-     * const provided = Effect.provideServices(program, serviceMap)
+     * const provided = Effect.provideContext(program, context)
      * ```
      *
      * @since 2.0.0
      * @category Environment
      */
-    <XR>(context: ServiceMap.ServiceMap<XR>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, XR>>;
+    <XR>(context: Context.Context<XR>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, XR>>;
     /**
-     * Provides a service map to an effect, fulfilling its service requirements.
+     * Provides a context to an effect, fulfilling its service requirements.
      *
      * **Details**
      *
-     * This function provides multiple services at once by supplying a service map
+     * This function provides multiple services at once by supplying a context
      * that contains all the required services. It removes the provided services
      * from the effect's requirements, making them available to the effect.
      *
      * @example
      * ```ts
-     * import { Effect, ServiceMap } from "effect"
+     * import { Effect, Context } from "effect"
      *
      * // Define service keys
-     * const Logger = ServiceMap.Service<{
+     * const Logger = Context.Service<{
      *   log: (msg: string) => void
      * }>("Logger")
-     * const Database = ServiceMap.Service<{
+     * const Database = Context.Service<{
      *   query: (sql: string) => string
      * }>("Database")
      *
-     * // Create service map with multiple services
-     * const serviceMap = ServiceMap.make(Logger, { log: console.log })
-     *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+     * // Create a context with multiple services
+     * const context = Context.make(Logger, { log: console.log })
+     *   .pipe(Context.add(Database, { query: () => "result" }))
      *
      * // An effect that requires both services
      * const program = Effect.gen(function*() {
@@ -9703,26 +10128,26 @@ export declare const provideServices: {
      *   return db.query("SELECT * FROM users")
      * })
      *
-     * const provided = Effect.provideServices(program, serviceMap)
+     * const provided = Effect.provideContext(program, context)
      * ```
      *
      * @since 2.0.0
      * @category Environment
      */
-    <A, E, R, XR>(self: Effect<A, E, R>, context: ServiceMap.ServiceMap<XR>): Effect<A, E, Exclude<R, XR>>;
+    <A, E, R, XR>(self: Effect<A, E, R>, context: Context.Context<XR>): Effect<A, E, Exclude<R, XR>>;
 };
 /**
  * Accesses a service from the context.
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Database {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.Service<Database>("Database")
  *
  * const program = Effect.gen(function*() {
  *   const db = yield* Effect.service(Database)
@@ -9731,9 +10156,9 @@ export declare const provideServices: {
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, never, I>;
+export declare const service: <I, S>(service: Context.Key<I, S>) => Effect<S, never, I>;
 /**
  * Optionally accesses a service from the environment.
  *
@@ -9746,10 +10171,10 @@ export declare const service: <I, S>(service: ServiceMap.Service<I, S>) => Effec
  *
  * @example
  * ```ts
- * import { Effect, Option, ServiceMap } from "effect"
+ * import { Effect, Option, Context } from "effect"
  *
  * // Define a service key
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
  *
@@ -9766,9 +10191,9 @@ export declare const service: <I, S>(service: ServiceMap.Service<I, S>) => Effec
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Effect<Option<S>>;
+export declare const serviceOption: <I, S>(key: Context.Key<I, S>) => Effect<Option<S>>;
 /**
  * Provides part of the required context while leaving the rest unchanged.
  *
@@ -9779,13 +10204,13 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Eff
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * // Define services
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Config = ServiceMap.Service<{
+ * const Config = Context.Service<{
  *   name: string
  * }>("Config")
  *
@@ -9795,8 +10220,8 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Eff
  *
  * // Transform services by providing Config while keeping Logger requirement
  * const configured = program.pipe(
- *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
- *     ServiceMap.add(services, Config, { name: "World" })
+ *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+ *     Context.add(context, Config, { name: "World" })
  *   )
  * )
  *
@@ -9807,9 +10232,9 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Eff
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const updateServices: {
+export declare const updateContext: {
     /**
      * Provides part of the required context while leaving the rest unchanged.
      *
@@ -9820,13 +10245,13 @@ export declare const updateServices: {
      *
      * @example
      * ```ts
-     * import { Effect, ServiceMap } from "effect"
+     * import { Effect, Context } from "effect"
      *
      * // Define services
-     * const Logger = ServiceMap.Service<{
+     * const Logger = Context.Service<{
      *   log: (msg: string) => void
      * }>("Logger")
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   name: string
      * }>("Config")
      *
@@ -9836,8 +10261,8 @@ export declare const updateServices: {
      *
      * // Transform services by providing Config while keeping Logger requirement
      * const configured = program.pipe(
-     *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -9848,9 +10273,9 @@ export declare const updateServices: {
      * ```
      *
      * @since 4.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <R2, R>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>): <A, E>(self: Effect<A, E, R>) => Effect<A, E, R2>;
+    <R2, R>(f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): <A, E>(self: Effect<A, E, R>) => Effect<A, E, R2>;
     /**
      * Provides part of the required context while leaving the rest unchanged.
      *
@@ -9861,13 +10286,13 @@ export declare const updateServices: {
      *
      * @example
      * ```ts
-     * import { Effect, ServiceMap } from "effect"
+     * import { Effect, Context } from "effect"
      *
      * // Define services
-     * const Logger = ServiceMap.Service<{
+     * const Logger = Context.Service<{
      *   log: (msg: string) => void
      * }>("Logger")
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   name: string
      * }>("Config")
      *
@@ -9877,8 +10302,8 @@ export declare const updateServices: {
      *
      * // Transform services by providing Config while keeping Logger requirement
      * const configured = program.pipe(
-     *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -9889,19 +10314,19 @@ export declare const updateServices: {
      * ```
      *
      * @since 4.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <A, E, R, R2>(self: Effect<A, E, R>, f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>): Effect<A, E, R2>;
+    <A, E, R, R2>(self: Effect<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): Effect<A, E, R2>;
 };
 /**
  * Updates the service with the required service entry.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a counter service
- * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+ * const Counter = Context.Service<{ count: number }>("Counter")
  *
  * const program = Effect.gen(function*() {
  *   const updatedCounter = yield* Effect.service(Counter)
@@ -9919,7 +10344,7 @@ export declare const updateServices: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const updateService: {
     /**
@@ -9927,10 +10352,10 @@ export declare const updateService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a counter service
-     * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+     * const Counter = Context.Service<{ count: number }>("Counter")
      *
      * const program = Effect.gen(function*() {
      *   const updatedCounter = yield* Effect.service(Counter)
@@ -9948,18 +10373,18 @@ export declare const updateService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <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: Context.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.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a counter service
-     * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+     * const Counter = Context.Service<{ count: number }>("Counter")
      *
      * const program = Effect.gen(function*() {
      *   const updatedCounter = yield* Effect.service(Counter)
@@ -9977,9 +10402,9 @@ export declare const updateService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <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: Context.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>;
 };
 /**
  * The `provideService` function is used to provide an actual
@@ -9995,10 +10420,10 @@ export declare const updateService: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a service for configuration
- * const Config = ServiceMap.Service<{
+ * const Config = Context.Service<{
  *   apiUrl: string
  *   timeout: number
  * }>("Config")
@@ -10024,7 +10449,7 @@ export declare const updateService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const provideService: {
     /**
@@ -10041,10 +10466,10 @@ export declare const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a service for configuration
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   apiUrl: string
      *   timeout: number
      * }>("Config")
@@ -10070,9 +10495,9 @@ export declare const provideService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <I, S>(service: ServiceMap.Service<I, S>): {
+    <I, S>(service: Context.Key<I, S>): {
         /**
          * The `provideService` function is used to provide an actual
          * implementation for a service in the context of an effect.
@@ -10087,10 +10512,10 @@ export declare const provideService: {
          *
          * @example
          * ```ts
-         * import { Console, Effect, ServiceMap } from "effect"
+         * import { Console, Effect, Context } from "effect"
          *
          * // Define a service for configuration
-         * const Config = ServiceMap.Service<{
+         * const Config = Context.Service<{
          *   apiUrl: string
          *   timeout: number
          * }>("Config")
@@ -10116,7 +10541,7 @@ export declare const provideService: {
          * ```
          *
          * @since 2.0.0
-         * @category ServiceMap
+         * @category Context
          */
         (implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
         /**
@@ -10133,10 +10558,10 @@ export declare const provideService: {
          *
          * @example
          * ```ts
-         * import { Console, Effect, ServiceMap } from "effect"
+         * import { Console, Effect, Context } from "effect"
          *
          * // Define a service for configuration
-         * const Config = ServiceMap.Service<{
+         * const Config = Context.Service<{
          *   apiUrl: string
          *   timeout: number
          * }>("Config")
@@ -10162,7 +10587,7 @@ export declare const provideService: {
          * ```
          *
          * @since 2.0.0
-         * @category ServiceMap
+         * @category Context
          */
         <A, E, R>(self: Effect<A, E, R>, implementation: S): Effect<A, E, Exclude<R, I>>;
     };
@@ -10180,10 +10605,10 @@ export declare const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a service for configuration
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   apiUrl: string
      *   timeout: number
      * }>("Config")
@@ -10209,9 +10634,9 @@ export declare const provideService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <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: Context.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.
@@ -10226,10 +10651,10 @@ export declare const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a service for configuration
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   apiUrl: string
      *   timeout: number
      * }>("Config")
@@ -10255,9 +10680,9 @@ export declare const provideService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <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: Context.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -10271,13 +10696,13 @@ export declare const provideService: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a database connection service
  * interface DatabaseConnection {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
- * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+ * const Database = Context.Service<DatabaseConnection>("Database")
  *
  * // Effect that creates a database connection
  * const createConnection = Effect.gen(function*() {
@@ -10309,7 +10734,7 @@ export declare const provideService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const provideServiceEffect: {
     /**
@@ -10324,13 +10749,13 @@ export declare const provideServiceEffect: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a database connection service
      * interface DatabaseConnection {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
-     * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+     * const Database = Context.Service<DatabaseConnection>("Database")
      *
      * // Effect that creates a database connection
      * const createConnection = Effect.gen(function*() {
@@ -10362,9 +10787,9 @@ export declare const provideServiceEffect: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <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: Context.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.
@@ -10377,13 +10802,13 @@ export declare const provideServiceEffect: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a database connection service
      * interface DatabaseConnection {
      *   readonly query: (sql: string) => Effect.Effect<string>
      * }
-     * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+     * const Database = Context.Service<DatabaseConnection>("Database")
      *
      * // Effect that creates a database connection
      * const createConnection = Effect.gen(function*() {
@@ -10415,9 +10840,9 @@ export declare const provideServiceEffect: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
-    <A, E, R, I, S, E2, R2>(self: Effect<A, E, R>, service: ServiceMap.Service<I, S>, acquire: Effect<S, E2, R2>): Effect<A, E | E2, Exclude<R, I> | R2>;
+    <A, E, R, I, S, E2, R2>(self: Effect<A, E, R>, service: Context.Key<I, S>, acquire: Effect<S, E2, R2>): Effect<A, E | E2, Exclude<R, I> | R2>;
 };
 /**
  * Sets the concurrency level for parallel operations within an effect.
@@ -10672,7 +11097,9 @@ export declare const scopedWith: <A, E, R>(f: (scope: Scope) => Effect<A, E, R>)
  * @since 2.0.0
  * @category Resource Management & Finalization
  */
-export declare const acquireRelease: <A, E, R>(acquire: Effect<A, E, R>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<unknown>) => Effect<A, E, R | Scope>;
+export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<unknown, never, R2>, options?: {
+    readonly interruptible?: boolean;
+}) => Effect<A, E, R | R2 | Scope>;
 /**
  * This function is used to ensure that an `Effect` value that represents the
  * acquisition of a resource (for example, opening a file, launching a thread,
@@ -10914,9 +11341,11 @@ export declare 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,
@@ -10925,8 +11354,8 @@ export declare 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
@@ -10939,9 +11368,11 @@ export declare 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,
@@ -10950,8 +11381,8 @@ export declare 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
@@ -10964,9 +11395,11 @@ export declare 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,
@@ -10975,8 +11408,8 @@ export declare 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
@@ -10986,7 +11419,7 @@ export declare 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
@@ -11010,7 +11443,7 @@ export declare const onError: {
 export declare 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
@@ -11031,10 +11464,10 @@ export declare 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>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | 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
@@ -11055,7 +11488,29 @@ export declare const onErrorIf: {
      * @since 4.0.0
      * @category Resource Management & Finalization
      */
-    <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(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>): Effect<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Effect<A, E, R>, predicate: Predicate.Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Effect<void, XE, XR>): 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
+ */
+export declare 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>;
 };
 /**
  * The low level primitive that powers `onExit`.
@@ -11149,20 +11604,20 @@ export declare const onExit: {
     <A, E, R, XE = never, XR = never>(self: Effect<A, E, R>, f: (exit: Exit.Exit<A, E>) => Effect<void, XE, XR>): 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
  * )
  * ```
  *
@@ -11171,49 +11626,71 @@ export declare const onExit: {
  */
 export declare 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>): <R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | 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>(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>): Effect<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Effect<A, E, R>, 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>;
+};
+/**
+ * Runs the cleanup effect only when the `Exit` matches the provided `Filter`.
+ *
+ * @since 4.0.0
+ * @category Resource Management & Finalization
+ */
+export declare 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>;
 };
 /**
  * Returns an effect that lazily computes a result and caches it for subsequent
@@ -11412,7 +11889,7 @@ export declare 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).
@@ -11479,7 +11956,7 @@ export declare 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>>;
 };
 /**
  * Caches an effect's result for a specified duration and allows manual
@@ -11620,7 +12097,7 @@ export declare 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.
@@ -11690,7 +12167,7 @@ export declare 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>]>;
 };
 /**
  * Returns an effect that is immediately interrupted.
@@ -11700,8 +12177,8 @@ export declare 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)
@@ -11890,6 +12367,13 @@ export declare const uninterruptibleMask: <A, E, R>(f: (restore: <AX, EX, RX>(ef
  * @category Interruption
  */
 export declare 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>;
+/**
+ * Creates an AbortSignal that is managed by the provided scope.
+ *
+ * @since 4.0.0
+ * @category Interruption
+ */
+export declare const abortSignal: Effect<AbortSignal, never, Scope>;
 /**
  * @since 2.0.0
  * @category Repetition / Recursion
@@ -11918,10 +12402,10 @@ export declare namespace Repeat {
      * ```
      */
     type Return<R, E, A, O extends Options<A>> = Effect<O extends {
-        schedule: Schedule<infer Out, infer _I, infer _E, infer _R>;
-    } ? Out : O extends {
         until: Predicate.Refinement<A, infer B>;
-    } ? B : A, E | (O extends {
+    } ? B : O extends {
+        while: Predicate.Refinement<A, infer B>;
+    } ? Exclude<A, B> : A, E | (O extends {
         schedule: Schedule<infer _Out, infer _I, infer E, infer _R>;
     } ? E : never) | (O extends {
         while: (...args: Array<any>) => Effect<infer _A, infer E, infer _R>;
@@ -12470,7 +12954,7 @@ export declare 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"
@@ -12520,7 +13004,7 @@ export declare 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"
@@ -12570,7 +13054,7 @@ export declare 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"
@@ -13969,7 +14453,7 @@ export declare 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)
  * })
  * ```
@@ -14000,7 +14484,7 @@ export declare 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)
      * })
      * ```
@@ -14031,7 +14515,7 @@ export declare 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)
      * })
      * ```
@@ -14040,7 +14524,7 @@ export declare const request: {
 };
 /**
  * Low-level entry point that registers a request with a resolver and delivers the exit value via `onExit`.
- * Use this when you already have a `ServiceMap` and need to enqueue a request outside an `Effect`.
+ * Use this when you already have a `Context` and need to enqueue a request outside an `Effect`.
  *
  * It returns a canceler that removes the pending request entry.
  *
@@ -14050,7 +14534,7 @@ export declare const request: {
 export declare const requestUnsafe: <A extends Request.Any>(self: A, options: {
     readonly resolver: RequestResolver<A>;
     readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void;
-    readonly services: ServiceMap.ServiceMap<never>;
+    readonly context: Context.Context<never>;
 }) => () => void;
 /**
  * Returns an effect that forks this effect into its own separate fiber,
@@ -14240,7 +14724,7 @@ export declare const forkScoped: <Arg extends Effect<any, any, any> | {
 }>(effectOrOptions?: Arg, options?: {
     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> : <A, E, R>(self: Effect<A, E, R>) => Effect<Fiber<A, E>, never, R | Scope>;
+} | undefined) => [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>;
 /**
  * Forks the effect into a new fiber attached to the global scope. Because the
  * new fiber is attached to the global scope, when the fiber executing the
@@ -14360,6 +14844,7 @@ export interface RunOptions {
     readonly signal?: AbortSignal | undefined;
     readonly scheduler?: Scheduler | undefined;
     readonly uninterruptible?: boolean | undefined;
+    readonly onFiberStart?: ((fiber: Fiber<unknown, unknown>) => void) | undefined;
 }
 /**
  * The foundational function for running effects, returning a "fiber" that can
@@ -14407,15 +14892,15 @@ export declare const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunO
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Logger {
  *   log: (message: string) => void
  * }
  *
- * const Logger = ServiceMap.Service<Logger>("Logger")
+ * const Logger = Context.Service<Logger>("Logger")
  *
- * const services = ServiceMap.make(Logger, {
+ * const services = Context.make(Logger, {
  *   log: (message) => console.log(message)
  * })
  *
@@ -14431,7 +14916,7 @@ export declare const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunO
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Fiber<A, E>;
+export declare const runForkWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Fiber<A, E>;
 /**
  * Forks an effect with the provided services, registers `onExit` as a fiber observer, and returns an interruptor.
  *
@@ -14439,15 +14924,15 @@ export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A,
  *
  * @example
  * ```ts
- * import { Console, Effect, Exit, ServiceMap } from "effect"
+ * import { Console, Effect, Exit, Context } from "effect"
  *
  * interface Logger {
  *   log: (message: string) => Effect.Effect<void>
  * }
  *
- * const Logger = ServiceMap.Service<Logger>("Logger")
+ * const Logger = Context.Service<Logger>("Logger")
  *
- * const services = ServiceMap.make(Logger, {
+ * const services = Context.make(Logger, {
  *   log: (message) => Console.log(message)
  * })
  *
@@ -14472,7 +14957,7 @@ export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A,
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runCallbackWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: (RunOptions & {
+export declare const runCallbackWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: (RunOptions & {
     readonly onExit: (exit: Exit.Exit<A, E>) => void;
 }) | undefined) => (interruptor?: number | undefined) => void;
 /**
@@ -14555,15 +15040,15 @@ export declare const runPromise: <A, E>(effect: Effect<A, E>, options?: RunOptio
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Config {
  *   apiUrl: string
  * }
  *
- * const Config = ServiceMap.Service<Config>("Config")
+ * const Config = Context.Service<Config>("Config")
  *
- * const services = ServiceMap.make(Config, {
+ * const context = Context.make(Config, {
  *   apiUrl: "https://api.example.com"
  * })
  *
@@ -14572,13 +15057,13 @@ export declare const runPromise: <A, E>(effect: Effect<A, E>, options?: RunOptio
  *   return `Connecting to ${config.apiUrl}`
  * })
  *
- * Effect.runPromiseWith(services)(program).then(console.log)
+ * Effect.runPromiseWith(context)(program).then(console.log)
  * ```
  *
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runPromiseWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<A>;
+export declare const runPromiseWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<A>;
 /**
  * Runs an effect and returns a `Promise` that resolves to an `Exit`, which
  * represents the outcome (success or failure) of the effect.
@@ -14632,15 +15117,15 @@ export declare const runPromiseExit: <A, E>(effect: Effect<A, E>, options?: RunO
  *
  * @example
  * ```ts
- * import { Effect, Exit, ServiceMap } from "effect"
+ * import { Effect, Exit, Context } from "effect"
  *
  * interface Database {
  *   query: (sql: string) => string
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.Service<Database>("Database")
  *
- * const services = ServiceMap.make(Database, {
+ * const services = Context.make(Database, {
  *   query: (sql) => `Result for: ${sql}`
  * })
  *
@@ -14659,7 +15144,7 @@ export declare const runPromiseExit: <A, E>(effect: Effect<A, E>, options?: RunO
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runPromiseExitWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<Exit.Exit<A, E>>;
+export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<Exit.Exit<A, E>>;
 /**
  * Executes an effect synchronously, running it immediately and returning the
  * result.
@@ -14723,15 +15208,15 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface MathService {
  *   add: (a: number, b: number) => number
  * }
  *
- * const MathService = ServiceMap.Service<MathService>("MathService")
+ * const MathService = Context.Service<MathService>("MathService")
  *
- * const services = ServiceMap.make(MathService, {
+ * const context = Context.make(MathService, {
  *   add: (a, b) => a + b
  * })
  *
@@ -14740,14 +15225,14 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
  *   return math.add(2, 3)
  * })
  *
- * const result = Effect.runSyncWith(services)(program)
+ * const result = Effect.runSyncWith(context)(program)
  * console.log(result) // 5
  * ```
  *
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runSyncWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>) => A;
+export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>) => A;
 /**
  * Runs an effect synchronously and returns the result as an `Exit` type, which
  * represents the outcome (success or failure) of the effect.
@@ -14823,10 +15308,10 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  *
  * @example
  * ```ts
- * import { Effect, Exit, ServiceMap } from "effect"
+ * import { Effect, Exit, Context } from "effect"
  *
  * // Define a logger service
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
  *
@@ -14836,12 +15321,12 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  *   return 42
  * })
  *
- * // Prepare services
- * const services = ServiceMap.make(Logger, {
+ * // Prepare context
+ * const context = Context.make(Logger, {
  *   log: (msg) => console.log(`[LOG] ${msg}`)
  * })
  *
- * const exit = Effect.runSyncExitWith(services)(program)
+ * const exit = Effect.runSyncExitWith(context)(program)
  *
  * if (Exit.isSuccess(exit)) {
  *   console.log(`Success: ${exit.value}`)
@@ -14856,7 +15341,7 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runSyncExitWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>) => Exit.Exit<A, E>;
+export declare const runSyncExitWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>) => Exit.Exit<A, E>;
 /**
  * Type helpers for functions built with `Effect.fn` and `Effect.fnUntraced`.
  *
@@ -15546,7 +16031,7 @@ export declare const clockWith: <A, E, R>(f: (clock: Clock) => Effect<A, E, R>)
  * @since 2.0.0
  * @category Logging
  */
-export declare const logWithLevel: (level?: LogLevel) => (...message: ReadonlyArray<any>) => Effect<void>;
+export declare const logWithLevel: (level?: Severity) => (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages using the default log level.
  *
@@ -15813,6 +16298,85 @@ export declare const annotateLogs: {
     <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
     <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
 };
+/**
+ * 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 declare 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>;
+};
 /**
  * Adds a span to each log line in this effect.
  *
@@ -16348,18 +16912,20 @@ export declare 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 } }
  * )
  * ```
  *
@@ -16394,18 +16960,20 @@ export declare 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 } }
      * )
      * ```
      *
@@ -16440,18 +17008,20 @@ export declare 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 } }
      * )
      * ```
      *
@@ -16486,18 +17056,20 @@ export declare 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 } }
      * )
      * ```
      *
@@ -16532,18 +17104,20 @@ export declare 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 } }
      * )
      * ```
      *
@@ -17024,7 +17598,7 @@ export declare const trackDuration: {
      */
     <A, E, R, State>(self: Effect<A, E, R>, metric: Metric.Metric<Duration.Duration, State>): Effect<A, E, R>;
 };
-declare const Transaction_base: ServiceMap.ServiceClass<Transaction, "effect/Effect/Transaction", {
+declare const Transaction_base: Context.ServiceClass<Transaction, "effect/Effect/Transaction", {
     retry: boolean;
     readonly journal: Map<TxRef<any>, {
         readonly version: number;
@@ -17055,19 +17629,22 @@ declare const Transaction_base: ServiceMap.ServiceClass<Transaction, "effect/Eff
 export declare class Transaction extends Transaction_base {
 }
 /**
- * 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.
+ * 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.
+ *
+ * If called inside an active transaction, `tx` composes with the current transaction and reuses
+ * its journal and retry state instead of creating a nested boundary.
  *
  * In Effect transactions are optimistic with retry, that means transactions are retried when:
  *
- * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
+ * - the body of the transaction explicitely calls to `Effect.txRetry` 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.
+ * The outermost `tx` call creates the transaction boundary and commits or rolls back the full
+ * composed transaction.
  *
  * @example
  * ```ts
@@ -17077,10 +17654,10 @@ export declare class Transaction extends Transaction_base {
  *   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*() {
+ *   // Nested tx calls compose into the same transaction
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     yield* TxRef.set(ref1, 10)
- *     yield* TxRef.set(ref2, 20)
+ *     yield* Effect.tx(TxRef.set(ref2, 20))
  *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
  *     console.log(`Transaction sum: ${sum}`)
  *   }))
@@ -17093,122 +17670,7 @@ export declare class Transaction extends Transaction_base {
  * @since 4.0.0
  * @category Transactions
  */
-export declare const atomic: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
-/**
- * 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}`)
- *
- *     yield* TxRef.set(ref, 42)
- *     return yield* TxRef.get(ref)
- *   })
- * )
- *
- * Effect.runPromise(program).then(console.log) // 42
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export declare const atomicWith: <A, E, R>(f: (state: Transaction["Service"]) => Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
-/**
- * Creates an isolated transaction that never composes with parent transactions.
- *
- * **Details**
- *
- * 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.
- *
- * **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
- *
- * **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
- *
- * @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)
- *
- *     // 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
- *   yield* Effect.transaction(Effect.gen(function*() {
- *     yield* TxRef.set(ref2, 200)
- *   }))
- *
- *   const val1 = yield* TxRef.get(ref1) // 20
- *   const val2 = yield* TxRef.get(ref2) // 200
- *   return { ref1: val1, ref2: val2 }
- * })
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export declare const transaction: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
-/**
- * Executes a function within an isolated transaction context, providing 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.
- *
- * @example
- * ```ts
- * import { Effect, TxRef } from "effect"
- *
- * 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
- * @category Transactions
- */
-export declare const transactionWith: <A, E, R>(f: (state: Transaction["Service"]) => Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
+export declare const tx: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
 /**
  * Signals that the current transaction needs to be retried.
  *
@@ -17229,15 +17691,15 @@ export declare const transactionWith: <A, E, R>(f: (state: Transaction["Service"
  *   // 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.tx(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.tx(Effect.gen(function*() {
  *     const value = yield* TxRef.get(ref)
  *     if (value < 10) {
  *       yield* Effect.log(`retry due to value: ${value}`)
- *       return yield* Effect.retryTransaction
+ *       return yield* Effect.txRetry
  *     }
  *     yield* Effect.log(`transaction done with value: ${value}`)
  *   }))
@@ -17246,7 +17708,7 @@ export declare const transactionWith: <A, E, R>(f: (state: Transaction["Service"
  * Effect.runPromise(program).catch(console.error)
  * ```
  */
-export declare const retryTransaction: Effect<never, never, Transaction>;
+export declare const txRetry: Effect<never, never, Transaction>;
 /**
  * @since 4.0.0
  * @category Effectify
@@ -17686,18 +18148,20 @@ export declare const satisfiesSuccessType: <A>() => <A2 extends A, E, R>(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