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

package/dist/Effect.d.ts

@@ -78,7 +78,7 @@ import { type LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.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";
@@ -92,7 +92,7 @@ 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";
 /**
@@ -625,7 +625,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 +723,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: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>): (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: Filter.FilterEffect<NoInfer<A>, B, X, E, R, [i: number]>): Effect<Option<B>, E, R>;
+};
 /**
  * Executes an effectful operation for each element in an `Iterable`.
  *
@@ -1352,6 +1636,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.
@@ -3916,7 +4284,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 +4320,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 +4392,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 +4435,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 +4837,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 +4871,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 +4883,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 +4917,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 +4929,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 +4963,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 +4973,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 +5009,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 +5021,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 +5055,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 +5065,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 +5193,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,14 +5232,36 @@ 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>;
 };
 /**
- * The `mapError` function is used to transform or modify the error
- * produced by an effect, without affecting its success value.
+ * Recovers from specific failures based on a `Filter`.
  *
- * This function is helpful when you want to enhance the error with additional
- * information, change the error type, or apply custom error handling while
+ * @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
+ * produced by an effect, without affecting its success value.
+ *
+ * This function is helpful when you want to enhance the error with additional
+ * information, change the error type, or apply custom error handling while
  * keeping the original behavior of the effect's success values intact. It only
  * operates on the error channel and leaves the success channel unchanged.
  *
@@ -5454,7 +5861,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 +5890,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.
@@ -6337,11 +6766,11 @@ 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;
 } | undefined = {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 }>(effectOrOptions?: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | 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.
@@ -6362,11 +6791,11 @@ export declare const ignore: <Arg extends Effect<any, any, any> | {
  * @category Error Handling
  */
 export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 } | undefined = {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | undefined;
 }>(effectOrOptions?: Arg, options?: {
-    readonly log?: boolean | LogLevel | undefined;
+    readonly log?: boolean | Severity | 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
@@ -6472,6 +6901,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 +7137,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 +7184,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 +7285,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 +7335,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.
@@ -6966,7 +7411,7 @@ export declare const timeoutOrElse: {
      * @category Delays & Timeouts
      */
     <A2, E2, R2>(options: {
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly onTimeout: LazyArg<Effect<A2, E2, R2>>;
     }): <A, E, R>(self: Effect<A, E, R>) => Effect<A | A2, E | E2, R | R2>;
     /**
@@ -7006,7 +7451,7 @@ export declare const timeoutOrElse: {
      * @category Delays & Timeouts
      */
     <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, options: {
-        readonly duration: Duration.DurationInput;
+        readonly duration: Duration.Input;
         readonly onTimeout: LazyArg<Effect<A2, E2, R2>>;
     }): Effect<A | A2, E | E2, R | R2>;
 };
@@ -7051,7 +7496,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 +7517,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 +7541,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 +7834,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 +7847,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 +7855,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 +7868,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 +7876,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 +7889,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 +7897,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 +7910,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 +7933,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 +7954,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 +7975,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))
+     * Filters and maps elements of an iterable with a `Filter`.
      *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A>(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`.
-     *
-     * @example
-     * ```ts
-     * import { Effect, Filter, Result } from "effect"
+     * Filters and maps elements of an iterable with a `Filter`.
      *
-     * // Sync predicate
-     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-     *
-     * // Effectful predicate
-     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-     *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
     <A, 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`.
+     * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
      *
-     * @example
-     * ```ts
-     * import { Effect, Filter, Result } from "effect"
-     *
-     * // Sync predicate
-     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-     *
-     * // Effectful predicate
-     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-     *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, 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"
+     * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
      *
-     * // Sync predicate
-     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
-     *
-     * // Effectful predicate
-     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
-     *
-     * // FilterEffect
-     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
-     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
-     * )
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(iterable: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect<boolean, E, R>, 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 +8125,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 +8187,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.
@@ -7938,7 +8330,7 @@ export declare const filterOrFail: {
      * @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>;
+    <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.
      *
@@ -7968,7 +8360,7 @@ export declare const filterOrFail: {
      * @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>;
+    <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.
      *
@@ -7998,7 +8390,7 @@ export declare const filterOrFail: {
      * @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, 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.
      *
@@ -8028,7 +8420,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, 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.
      *
@@ -8058,7 +8450,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, 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.
      *
@@ -8088,127 +8480,43 @@ 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, 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, failing with a custom error if the predicate fails.
-     *
-     * **Details**
+     * Filters an effect with a `Filter`, failing when the filter fails.
      *
-     * 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
+     * @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>;
+    <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")
-     * ```
+     * Filters an effect with a `Filter`, failing when the filter fails.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Effect<A, E, R>, refinement: Predicate.Refinement<NoInfer<A>, B>): Effect<B, E | Cause.NoSuchElementError, R>;
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Effect<A, E, R>) => Effect<B, Cause.NoSuchElementError | E, R>;
     /**
-     * Filters an effect, failing with a custom error if the predicate fails.
-     *
-     * **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"
+     * Filters an effect with a `Filter`, failing when the filter fails.
      *
-     * // 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
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Effect<A, E, R>, predicate: Predicate.Predicate<NoInfer<A>>): Effect<A, E | Cause.NoSuchElementError, R>;
+    <A, E, R, B, X, E2>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>, orFailWith: (x: X) => E2): Effect<B, E2 | E, R>;
     /**
-     * Filters an effect, failing with a custom error if the predicate fails.
+     * Filters an effect with a `Filter`, failing when the filter fails.
      *
-     * **Details**
-     *
-     * This function applies a predicate to the result of an effect. If the
-     * predicate evaluates to `false`, the effect fails with either a custom
-     * error (if `orFailWith` is provided) or a `NoSuchElementError`.
-     *
-     * @example
-     * ```ts
-     * import { Effect } from "effect"
-     *
-     * // An effect that produces a number
-     * const program = Effect.succeed(5)
-     *
-     * // Filter for even numbers, fail for odd numbers
-     * const filtered = Effect.filterOrFail(
-     *   program,
-     *   (n) => n % 2 === 0,
-     *   (n) => `Expected even number, got ${n}`
-     * )
-     *
-     * // Result: Effect.fail("Expected even number, got 5")
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, B, X>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>): Effect<B, E | Cause.NoSuchElementError, R>;
+    <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.
@@ -9733,7 +10041,7 @@ export declare const provideServices: {
  * @since 4.0.0
  * @category ServiceMap
  */
-export declare const service: <I, S>(service: ServiceMap.Service<I, S>) => Effect<S, never, I>;
+export declare const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never, I>;
 /**
  * Optionally accesses a service from the environment.
  *
@@ -9768,7 +10076,7 @@ export declare const service: <I, S>(service: ServiceMap.Service<I, S>) => Effec
  * @since 2.0.0
  * @category ServiceMap
  */
-export declare const serviceOption: <I, S>(key: ServiceMap.Service<I, S>) => Effect<Option<S>>;
+export declare const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S>>;
 /**
  * Provides part of the required context while leaving the rest unchanged.
  *
@@ -9950,7 +10258,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <I, A>(service: ServiceMap.Service<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>;
+    <I, A>(service: ServiceMap.Key<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>;
     /**
      * Updates the service with the required service entry.
      *
@@ -9979,7 +10287,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <XA, E, R, I, A>(self: Effect<XA, E, R>, service: ServiceMap.Service<I, A>, f: (value: A) => A): Effect<XA, E, R | I>;
+    <XA, E, R, I, A>(self: Effect<XA, E, R>, service: ServiceMap.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>;
 };
 /**
  * The `provideService` function is used to provide an actual
@@ -10072,7 +10380,7 @@ export declare const provideService: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <I, S>(service: ServiceMap.Service<I, S>): {
+    <I, S>(service: ServiceMap.Key<I, S>): {
         /**
          * The `provideService` function is used to provide an actual
          * implementation for a service in the context of an effect.
@@ -10211,7 +10519,7 @@ export declare const provideService: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <I, S>(service: ServiceMap.Service<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
+    <I, S>(service: ServiceMap.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
     /**
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
@@ -10257,7 +10565,7 @@ export declare const provideService: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <A, E, R, I, S>(self: Effect<A, E, R>, service: ServiceMap.Service<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(self: Effect<A, E, R>, service: ServiceMap.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -10364,7 +10672,7 @@ export declare const provideServiceEffect: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <I, S, E2, R2>(service: ServiceMap.Service<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>;
+    <I, S, E2, R2>(service: ServiceMap.Key<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>;
     /**
      * Provides the effect with the single service it requires. If the effect
      * requires more than one service use `provide` instead.
@@ -10417,7 +10725,7 @@ export declare const provideServiceEffect: {
      * @since 2.0.0
      * @category ServiceMap
      */
-    <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: ServiceMap.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.
@@ -10986,7 +11294,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 +11318,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 +11339,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 +11363,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 +11479,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 +11501,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 +11764,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 +11831,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 +11972,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 +12042,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.
@@ -11890,232 +12242,6 @@ 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>;
-/**
- * @category Semaphore
- * @since 2.0.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a semaphore for controlling concurrent access
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
- *
- *   return yield* semaphore.withPermits(1)(
- *     Effect.succeed("Resource accessed")
- *   )
- * })
- * ```
- */
-export interface Semaphore {
-    /**
-     * Adjusts the number of permits available in the semaphore.
-     */
-    resize(permits: number): Effect<void>;
-    /**
-     * Runs an effect with the given number of permits and releases the permits
-     * when the effect completes.
-     *
-     * **Details**
-     *
-     * This function acquires the specified number of permits before executing
-     * the provided effect. Once the effect finishes, the permits are released.
-     * If insufficient permits are available, the function will wait until they
-     * are released by other tasks.
-     */
-    withPermits(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
-    /**
-     * Runs an effect with the given number of permits and releases the permits
-     * when the effect completes.
-     *
-     * **Details**
-     *
-     * This function acquires the specified number of permits before executing
-     * the provided effect. Once the effect finishes, the permits are released.
-     * If insufficient permits are available, the function will wait until they
-     * are released by other tasks.
-     */
-    withPermit<A, E, R>(self: Effect<A, E, R>): Effect<A, E, R>;
-    /**
-     * Runs an effect only if the specified number of permits are immediately
-     * available.
-     *
-     * **Details**
-     *
-     * This function attempts to acquire the specified number of permits. If they
-     * are available, it runs the effect and releases the permits after the effect
-     * completes. If permits are not available, the effect does not execute, and
-     * the result is `Option.none`.
-     */
-    withPermitsIfAvailable(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>;
-    /**
-     * Acquires the specified number of permits and returns the resulting
-     * available permits, suspending the task if they are not yet available.
-     * Concurrent pending `take` calls are processed in a first-in, first-out manner.
-     */
-    take(permits: number): Effect<number>;
-    /**
-     * Releases the specified number of permits and returns the resulting
-     * available permits.
-     */
-    release(permits: number): Effect<number>;
-    /**
-     * Releases all permits held by this semaphore and returns the resulting available permits.
-     */
-    releaseAll: Effect<number>;
-}
-/**
- * Unsafely creates a new Semaphore.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const semaphore = Effect.makeSemaphoreUnsafe(3)
- *
- * const task = (id: number) =>
- *   semaphore.withPermits(1)(
- *     Effect.gen(function*() {
- *       yield* Effect.log(`Task ${id} started`)
- *       yield* Effect.sleep("1 second")
- *       yield* Effect.log(`Task ${id} completed`)
- *     })
- *   )
- *
- * // Only 3 tasks can run concurrently
- * const program = Effect.all([
- *   task(1),
- *   task(2),
- *   task(3),
- *   task(4),
- *   task(5)
- * ], { concurrency: "unbounded" })
- * ```
- *
- * @since 2.0.0
- * @category Semaphore
- */
-export declare const makeSemaphoreUnsafe: (permits: number) => Semaphore;
-/**
- * Creates a new Semaphore.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const semaphore = yield* Effect.makeSemaphore(2)
- *
- *   const task = (id: number) =>
- *     semaphore.withPermits(1)(
- *       Effect.gen(function*() {
- *         yield* Effect.log(`Task ${id} acquired permit`)
- *         yield* Effect.sleep("1 second")
- *         yield* Effect.log(`Task ${id} releasing permit`)
- *       })
- *     )
- *
- *   // Run 4 tasks, but only 2 can run concurrently
- *   yield* Effect.all([task(1), task(2), task(3), task(4)])
- * })
- * ```
- *
- * @since 2.0.0
- * @category Semaphore
- */
-export declare const makeSemaphore: (permits: number) => Effect<Semaphore>;
-/**
- * @category Latch
- * @since 3.8.0
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * // Create and use a latch for coordination between fibers
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch()
- *
- *   // Wait for the latch to be opened
- *   yield* latch.await
- *
- *   return "Latch was opened!"
- * })
- * ```
- */
-export interface Latch {
-    /** open the latch, releasing all fibers waiting on it */
-    readonly open: Effect<boolean>;
-    /** open the latch, releasing all fibers waiting on it */
-    readonly openUnsafe: () => boolean;
-    /** release all fibers waiting on the latch, without opening it */
-    readonly release: Effect<boolean>;
-    /** wait for the latch to be opened */
-    readonly await: Effect<void>;
-    /** close the latch */
-    readonly close: Effect<boolean>;
-    /** close the latch */
-    readonly closeUnsafe: () => boolean;
-    /** only run the given effect when the latch is open */
-    readonly whenOpen: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
-}
-/**
- * Creates a new Latch.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const latch = Effect.makeLatchUnsafe(false)
- *
- * const waiter = Effect.gen(function*() {
- *   yield* Effect.log("Waiting for latch to open...")
- *   yield* latch.await
- *   yield* Effect.log("Latch opened! Continuing...")
- * })
- *
- * const opener = Effect.gen(function*() {
- *   yield* Effect.sleep("2 seconds")
- *   yield* Effect.log("Opening latch...")
- *   yield* latch.open
- * })
- *
- * const program = Effect.all([waiter, opener])
- * ```
- *
- * @category Latch
- * @since 3.8.0
- */
-export declare const makeLatchUnsafe: (open?: boolean | undefined) => Latch;
-/**
- * Creates a new Latch.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- *
- * const program = Effect.gen(function*() {
- *   const latch = yield* Effect.makeLatch(false)
- *
- *   const waiter = Effect.gen(function*() {
- *     yield* Effect.log("Waiting for latch to open...")
- *     yield* latch.await
- *     yield* Effect.log("Latch opened! Continuing...")
- *   })
- *
- *   const opener = Effect.gen(function*() {
- *     yield* Effect.sleep("2 seconds")
- *     yield* Effect.log("Opening latch...")
- *     yield* latch.open
- *   })
- *
- *   yield* Effect.all([waiter, opener])
- * })
- * ```
- *
- * @category Latch
- * @since 3.8.0
- */
-export declare const makeLatch: (open?: boolean | undefined) => Effect<Latch>;
 /**
  * @since 2.0.0
  * @category Repetition / Recursion
@@ -15772,7 +15898,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.
  *
@@ -16039,6 +16165,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.
  *
@@ -17281,118 +17486,63 @@ 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.
- *
- * In Effect transactions are optimistic with retry, that means transactions are retried when:
- *
- * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
- *   accessed transactional values changes.
+ * Accesses the current transaction state within an active transaction.
  *
- * - any of the accessed transactional values change during the execution of the transaction
- *   due to a different transaction committing before the current.
- *
- * - parent transaction retry, if you have a transaction within another transaction and
- *   the parent retries the child will also retry together with the parent.
+ * This function requires `Transaction` in the context and does NOT create or strip
+ * transaction boundaries. Use it to interact with the transaction journal (e.g. in
+ * `TxRef` internals). To define a transaction boundary, use {@link transaction}.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* TxRef.make(0)
- *   const ref2 = yield* TxRef.make(0)
- *
- *   // All operations within atomic block succeed or fail together
- *   yield* Effect.atomic(Effect.gen(function*() {
- *     yield* TxRef.set(ref1, 10)
- *     yield* TxRef.set(ref2, 20)
- *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
- *     console.log(`Transaction sum: ${sum}`)
- *   }))
- *
- *   console.log(`Final ref1: ${yield* TxRef.get(ref1)}`) // 10
- *   console.log(`Final ref2: ${yield* TxRef.get(ref2)}`) // 20
- * })
- * ```
- *
- * @since 4.0.0
- * @category Transactions
- */
-export 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}`)
+ *   const ref = yield* Effect.transaction(TxRef.make(0))
  *
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     yield* TxRef.set(ref, 42)
  *     return yield* TxRef.get(ref)
- *   })
- * )
- *
- * Effect.runPromise(program).then(console.log) // 42
+ *   }))
+ * })
  * ```
  *
  * @since 4.0.0
  * @category Transactions
  */
-export declare const atomicWith: <A, E, R>(f: (state: Transaction["Service"]) => Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
+export declare const withTxState: <A, E, R>(f: (state: Transaction["Service"]) => Effect<A, E, R>) => Effect<A, E, R | Transaction>;
 /**
- * Creates an isolated transaction that never composes with parent transactions.
+ * Defines a transaction boundary. Transactions are "all or nothing" with respect to changes
+ * made to transactional values (i.e. TxRef) that occur within the transaction body.
  *
- * **Details**
+ * In Effect transactions are optimistic with retry, that means transactions are retried when:
  *
- * Unlike `Effect.atomic`, which composes with parent transactions when nested,
- * `Effect.transaction` always creates a new isolated transaction boundary.
- * This ensures complete isolation between different transaction scopes.
+ * - the body of the transaction explicitely calls to `Effect.retryTransaction` and any of the
+ *   accessed transactional values changes.
  *
- * **Key Differences from Effect.atomic:**
- * - Always creates a new transaction, even when called within another transaction
- * - Parent transaction failures don't affect isolated transactions
- * - Isolated transaction failures don't affect parent transactions
- * - Each transaction has its own journal and retry logic
+ * - any of the accessed transactional values change during the execution of the transaction
+ *   due to a different transaction committing before the current.
  *
- * **When to Use:**
- * - When you need guaranteed isolation between transaction scopes
- * - For implementing independent operations that shouldn't be affected by outer transactions
- * - When building transaction-based systems where isolation is critical
+ * Each call to `transaction` always creates a new isolated transaction boundary with its own
+ * journal and retry logic.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const ref1 = yield* TxRef.make(0)
- *   const ref2 = yield* TxRef.make(100)
- *
- *   // Nested atomic transaction - ref1 will be part of outer transaction
- *   yield* Effect.atomic(Effect.gen(function*() {
- *     yield* TxRef.set(ref1, 10)
- *
- *     // This atomic operation composes with the parent
- *     yield* Effect.atomic(Effect.gen(function*() {
- *       yield* TxRef.set(ref1, 20) // Part of same transaction
- *     }))
- *   }))
+ *   const ref1 = yield* Effect.transaction(TxRef.make(0))
+ *   const ref2 = yield* Effect.transaction(TxRef.make(0))
  *
- *   // Isolated transaction - ref2 will be in its own transaction
+ *   // All operations within transaction block succeed or fail together
  *   yield* Effect.transaction(Effect.gen(function*() {
- *     yield* TxRef.set(ref2, 200)
+ *     yield* TxRef.set(ref1, 10)
+ *     yield* TxRef.set(ref2, 20)
+ *     const sum = (yield* TxRef.get(ref1)) + (yield* TxRef.get(ref2))
+ *     console.log(`Transaction sum: ${sum}`)
  *   }))
  *
- *   const val1 = yield* TxRef.get(ref1) // 20
- *   const val2 = yield* TxRef.get(ref2) // 200
- *   return { ref1: val1, ref2: val2 }
+ *   console.log(`Final ref1: ${yield* Effect.transaction(TxRef.get(ref1))}`) // 10
+ *   console.log(`Final ref2: ${yield* Effect.transaction(TxRef.get(ref2))}`) // 20
  * })
  * ```
  *
@@ -17401,34 +17551,21 @@ export declare const atomicWith: <A, E, R>(f: (state: Transaction["Service"]) =>
  */
 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.
+ * Like {@link transaction} but provides access to the transaction state.
  *
- * This function always creates a new transaction boundary, regardless of whether it's called
- * within another transaction. This ensures complete isolation between transaction scopes.
+ * Always creates a new isolated transaction boundary with its own journal and retry logic.
  *
  * @example
  * ```ts
  * import { Effect, TxRef } from "effect"
  *
- * const program = Effect.transactionWith((txState) =>
+ * const program = Effect.transactionWith((_txState) =>
  *   Effect.gen(function*() {
  *     const ref = yield* TxRef.make(0)
- *
- *     // This transaction is isolated - it has its own journal
- *     // txState.journal is independent of any parent transaction
- *
  *     yield* TxRef.set(ref, 42)
  *     return yield* TxRef.get(ref)
  *   })
  * )
- *
- * // Even when nested in another atomic block, this transaction is isolated
- * const nestedProgram = Effect.atomic(
- *   Effect.gen(function*() {
- *     const result = yield* program // Runs in its own isolated transaction
- *     return result
- *   })
- * )
  * ```
  *
  * @since 4.0.0
@@ -17450,16 +17587,16 @@ export declare const transactionWith: <A, E, R>(f: (state: Transaction["Service"
  *
  * const program = Effect.gen(function*() {
  *   // create a transactional reference
- *   const ref = yield* TxRef.make(0)
+ *   const ref = yield* Effect.transaction(TxRef.make(0))
  *
  *   // forks a fiber that increases the value of `ref` every 100 millis
  *   yield* Effect.forkChild(Effect.forever(
  *     // update to transactional value
- *     TxRef.update(ref, (n) => n + 1).pipe(Effect.delay("100 millis"))
+ *     Effect.transaction(TxRef.update(ref, (n) => n + 1)).pipe(Effect.delay("100 millis"))
  *   ))
  *
  *   // the following will retry 10 times until the `ref` value is 10
- *   yield* Effect.atomic(Effect.gen(function*() {
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     const value = yield* TxRef.get(ref)
  *     if (value < 10) {
  *       yield* Effect.log(`retry due to value: ${value}`)