effect 4.0.0-beta.69 → 4.0.0-beta.70

package/dist/Effect.d.ts

@@ -118,6 +118,8 @@ export declare const TypeId: TypeId;
  * job. The workflow requires some context `R`, and may fail with an error of
  * type `E`, or succeed with a value of type `A`.
  *
+ * **Details**
+ *
  * `Effect` values model resourceful interaction with the outside world,
  * including synchronous, asynchronous, concurrent, and parallel interaction.
  * They use a fiber-based concurrency model, with built-in support for
@@ -300,7 +302,7 @@ export declare namespace All {
  * first failure; with concurrent execution, effects that have already started
  * may be interrupted, while effects not yet started are skipped.
  *
- * **Options**
+ * Options:
  *
  * Use `concurrency` to control sequential or concurrent execution. Use
  * `mode: "result"` to run every effect and collect each success or failure as a
@@ -414,7 +416,6 @@ export declare namespace All {
  * ```
  *
  * @see {@link forEach} for iterating over elements and applying an effect.
- *
  * @category Collecting
  * @since 2.0.0
  */
@@ -427,6 +428,8 @@ export declare const all: <const Arg extends Iterable<Effect<any, any, any>> | R
  * Applies an effectful function to each element and partitions failures and
  * successes.
  *
+ * **Details**
+ *
  * The returned tuple is `[excluded, satisfying]`, where:
  *
  * - `excluded` contains all failures.
@@ -456,6 +459,8 @@ export declare const partition: {
      * Applies an effectful function to each element and partitions failures and
      * successes.
      *
+     * **Details**
+     *
      * The returned tuple is `[excluded, satisfying]`, where:
      *
      * - `excluded` contains all failures.
@@ -487,6 +492,8 @@ export declare const partition: {
      * Applies an effectful function to each element and partitions failures and
      * successes.
      *
+     * **Details**
+     *
      * The returned tuple is `[excluded, satisfying]`, where:
      *
      * - `excluded` contains all failures.
@@ -518,6 +525,8 @@ export declare const partition: {
 /**
  * Applies an effectful function to each element and accumulates all failures.
  *
+ * **Details**
+ *
  * 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.
@@ -555,6 +564,8 @@ export declare const validate: {
     /**
      * Applies an effectful function to each element and accumulates all failures.
      *
+     * **Details**
+     *
      * 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.
@@ -595,6 +606,8 @@ export declare const validate: {
     /**
      * Applies an effectful function to each element and accumulates all failures.
      *
+     * **Details**
+     *
      * 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.
@@ -635,6 +648,8 @@ export declare const validate: {
     /**
      * Applies an effectful function to each element and accumulates all failures.
      *
+     * **Details**
+     *
      * 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.
@@ -675,6 +690,8 @@ export declare const validate: {
     /**
      * Applies an effectful function to each element and accumulates all failures.
      *
+     * **Details**
+     *
      * 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.
@@ -716,6 +733,8 @@ export declare const validate: {
 /**
  * Returns the first element that satisfies an effectful predicate.
  *
+ * **Details**
+ *
  * The predicate receives the element and its index. Evaluation short-circuits
  * as soon as an element matches.
  *
@@ -737,6 +756,8 @@ export declare const findFirst: {
     /**
      * Returns the first element that satisfies an effectful predicate.
      *
+     * **Details**
+     *
      * The predicate receives the element and its index. Evaluation short-circuits
      * as soon as an element matches.
      *
@@ -758,6 +779,8 @@ export declare const findFirst: {
     /**
      * Returns the first element that satisfies an effectful predicate.
      *
+     * **Details**
+     *
      * The predicate receives the element and its index. Evaluation short-circuits
      * as soon as an element matches.
      *
@@ -780,6 +803,8 @@ export declare const findFirst: {
 /**
  * Returns the first value that passes an effectful `FilterEffect`.
  *
+ * **Details**
+ *
  * The filter receives the element and index. Evaluation short-circuits on the
  * first `Result.succeed` and returns the transformed value in `Option.some`.
  *
@@ -790,6 +815,8 @@ export declare const findFirstFilter: {
     /**
      * Returns the first value that passes an effectful `FilterEffect`.
      *
+     * **Details**
+     *
      * The filter receives the element and index. Evaluation short-circuits on the
      * first `Result.succeed` and returns the transformed value in `Option.some`.
      *
@@ -800,6 +827,8 @@ export declare const findFirstFilter: {
     /**
      * Returns the first value that passes an effectful `FilterEffect`.
      *
+     * **Details**
+     *
      * The filter receives the element and index. Evaluation short-circuits on the
      * first `Result.succeed` and returns the transformed value in `Option.some`.
      *
@@ -819,18 +848,16 @@ export declare const findFirstFilter: {
  * If any effect fails, the iteration stops immediately (short-circuiting), and
  * the error is propagated.
  *
- * **Concurrency**
+ * Concurrency:
  *
  * The `concurrency` option controls how many operations are performed
  * concurrently. By default, the operations are performed sequentially.
  *
- * **Discarding Results**
+ * Discarding Results:
  *
  * If the `discard` option is set to `true`, the intermediate results are not
  * collected, and the final result of the operation is `void`.
  *
- * @see {@link all} for combining multiple effects into one.
- *
  * **Example** (Mapping over an iterable with effects)
  *
  * ```ts
@@ -875,6 +902,7 @@ export declare const findFirstFilter: {
  * // undefined
  * ```
  *
+ * @see {@link all} for combining multiple effects into one.
  * @category Collecting
  * @since 2.0.0
  */
@@ -890,18 +918,16 @@ export declare const forEach: {
      * If any effect fails, the iteration stops immediately (short-circuiting), and
      * the error is propagated.
      *
-     * **Concurrency**
+     * Concurrency:
      *
      * The `concurrency` option controls how many operations are performed
      * concurrently. By default, the operations are performed sequentially.
      *
-     * **Discarding Results**
+     * Discarding Results:
      *
      * If the `discard` option is set to `true`, the intermediate results are not
      * collected, and the final result of the operation is `void`.
      *
-     * @see {@link all} for combining multiple effects into one.
-     *
      * **Example** (Mapping over an iterable with effects)
      *
      * ```ts
@@ -946,6 +972,7 @@ export declare const forEach: {
      * // undefined
      * ```
      *
+     * @see {@link all} for combining multiple effects into one.
      * @category Collecting
      * @since 2.0.0
      */
@@ -964,18 +991,16 @@ export declare const forEach: {
      * If any effect fails, the iteration stops immediately (short-circuiting), and
      * the error is propagated.
      *
-     * **Concurrency**
+     * Concurrency:
      *
      * The `concurrency` option controls how many operations are performed
      * concurrently. By default, the operations are performed sequentially.
      *
-     * **Discarding Results**
+     * Discarding Results:
      *
      * If the `discard` option is set to `true`, the intermediate results are not
      * collected, and the final result of the operation is `void`.
      *
-     * @see {@link all} for combining multiple effects into one.
-     *
      * **Example** (Mapping over an iterable with effects)
      *
      * ```ts
@@ -1020,6 +1045,7 @@ export declare const forEach: {
      * // undefined
      * ```
      *
+     * @see {@link all} for combining multiple effects into one.
      * @category Collecting
      * @since 2.0.0
      */
@@ -1065,7 +1091,7 @@ export declare const whileLoop: <A, E, R>(options: {
  * Creates an `Effect` that represents an asynchronous computation guaranteed to
  * succeed.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `promise` when you are sure the operation will not reject.
  *
@@ -1079,13 +1105,11 @@ export declare const whileLoop: <A, E, R>(options: {
  * crash in the program, which can be further managed or logged using tools like
  * {@link catchDefect}.
  *
- * **Interruptions**
+ * Interruptions:
  *
  * An optional `AbortSignal` can be provided to allow for interruption of the
  * wrapped `Promise` API.
  *
- * @see {@link tryPromise} for a version that can handle failures.
- *
  * **Example** (Wrapping a non-rejecting Promise)
  *
  * ```ts
@@ -1106,6 +1130,7 @@ export declare const whileLoop: <A, E, R>(options: {
  * const program = delay("Async operation completed successfully!")
  * ```
  *
+ * @see {@link tryPromise} for a version that can handle failures.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1114,7 +1139,7 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * Creates an `Effect` that represents an asynchronous computation that might
  * fail.
  *
- * **When to Use**
+ * **When to use**
  *
  * In situations where you need to perform asynchronous operations that might
  * fail, such as fetching data from an API, you can use the `tryPromise`
@@ -1122,7 +1147,9 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * throw exceptions by capturing those exceptions and transforming them into
  * manageable errors.
  *
- * **Error Handling**
+ * **Details**
+ *
+ * Error Handling:
  *
  * There are two ways to handle errors with `tryPromise`:
  *
@@ -1131,7 +1158,7 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * 2. If you provide a `catch` function, the error is caught and the `catch`
  *    function maps it to an error of type `E`.
  *
- * **Interruptions**
+ * Interruptions:
  *
  * An optional `AbortSignal` can be provided to allow for interruption of the
  * wrapped `Promise` API.
@@ -1172,7 +1199,6 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * ```
  *
  * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
- *
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1183,13 +1209,11 @@ export declare const tryPromise: <A, E = Cause.UnknownError>(options: {
 /**
  * Creates an `Effect` that always succeeds with a given value.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use this function when you need an effect that completes successfully with a
  * specific value without any errors or external dependencies.
  *
- * @see {@link fail} to create an effect that represents a failure.
- *
  * **Example** (Creating a successful effect)
  *
  * ```ts
@@ -1202,6 +1226,7 @@ export declare const tryPromise: <A, E = Cause.UnknownError>(options: {
  * const success = Effect.succeed(42)
  * ```
  *
+ * @see {@link fail} to create an effect that represents a failure.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1245,7 +1270,7 @@ export declare const succeedSome: <A>(value: A) => Effect<Option<A>>;
 /**
  * Delays the creation of an `Effect` until it is actually needed.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `suspend` when you need to defer the evaluation of an effect until it is required. This is particularly useful for optimizing expensive computations, managing circular dependencies, or resolving type inference issues.
  *
@@ -1332,7 +1357,7 @@ export declare const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Eff
 /**
  * Creates an `Effect` that represents a synchronous side-effectful computation.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `sync` when you are sure the operation will not fail.
  *
@@ -1346,8 +1371,6 @@ export declare const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Eff
  * crash in the program, which can be further managed or logged using tools like
  * {@link catchDefect}.
  *
- * @see {@link try_ | try} for a version that can handle failures.
- *
  * **Example** (Capturing synchronous logging in an Effect)
  *
  * ```ts
@@ -1363,6 +1386,7 @@ export declare const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Eff
  * const program = log("Hello, World!")
  * ```
  *
+ * @see {@link try_ | try} for a version that can handle failures.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1370,6 +1394,8 @@ export declare const sync: <A>(thunk: LazyArg<A>) => Effect<A>;
 declare const void_: Effect<void>;
 export { 
 /**
+ * Returns an effect that succeeds with `void`.
+ *
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1377,6 +1403,8 @@ void_ as void };
 declare const undefined_: Effect<undefined>;
 export { 
 /**
+ * Returns an effect that succeeds with `undefined`.
+ *
  * @category Creating Effects
  * @since 4.0.0
  */
@@ -1384,6 +1412,11 @@ undefined_ as undefined };
 /**
  * Creates an `Effect` from a callback-based asynchronous API.
  *
+ * **When to use**
+ *
+ * Use `Effect.callback` when integrating APIs that complete through callbacks
+ * instead of returning a `Promise`.
+ *
  * **Details**
  *
  * The registration function receives a `resume` callback and, when requested,
@@ -1391,11 +1424,6 @@ undefined_ as undefined };
  * complete the fiber; later calls are ignored. Return an optional cleanup
  * effect from the registration function to run if the fiber is interrupted.
  *
- * **When to Use**
- *
- * Use `Effect.callback` when integrating APIs that complete through callbacks
- * instead of returning a `Promise`.
- *
  * **Example** (Integrating callback APIs)
  *
  * ```ts
@@ -1528,7 +1556,7 @@ export declare const bind: {
  * Provides a way to write effectful code using generator functions, simplifying
  * control flow and error handling.
  *
- * **When to Use**
+ * **When to use**
  *
  * `gen` allows you to write code that looks and behaves like synchronous
  * code, but it can handle asynchronous tasks, errors, and complex control flow
@@ -1580,7 +1608,7 @@ export declare const gen: {
      * Provides a way to write effectful code using generator functions, simplifying
      * control flow and error handling.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `gen` allows you to write code that looks and behaves like synchronous
      * code, but it can handle asynchronous tasks, errors, and complex control flow
@@ -1636,7 +1664,7 @@ export declare const gen: {
      * Provides a way to write effectful code using generator functions, simplifying
      * control flow and error handling.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `gen` allows you to write code that looks and behaves like synchronous
      * code, but it can handle asynchronous tasks, errors, and complex control flow
@@ -1708,14 +1736,12 @@ export declare namespace gen {
 /**
  * Creates an `Effect` that represents a recoverable error.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use this function to explicitly signal an error in an `Effect`. The error
  * will keep propagating unless it is handled. You can handle the error with
  * functions like {@link catchTag} or {@link catchTags}.
  *
- * @see {@link succeed} to create an effect that represents a successful value.
- *
  * **Example** (Creating a failed effect)
  *
  * ```ts
@@ -1730,6 +1756,7 @@ export declare namespace gen {
  * )
  * ```
  *
+ * @see {@link succeed} to create an effect that represents a successful value.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1737,6 +1764,8 @@ export declare const fail: <E>(error: E) => Effect<never, E>;
 /**
  * Creates an `Effect` that represents a recoverable error using a lazy evaluation.
  *
+ * **Details**
+ *
  * This function is useful when you need to create an error effect but want to
  * defer the computation of the error value until the effect is actually run.
  *
@@ -1760,6 +1789,8 @@ export declare const failSync: <E>(evaluate: LazyArg<E>) => Effect<never, E>;
 /**
  * Creates an `Effect` that represents a failure with a specific `Cause`.
  *
+ * **Details**
+ *
  * This function allows you to create effects that fail with complex error
  * structures, including multiple errors, defects, interruptions, and more.
  *
@@ -1783,6 +1814,8 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E>;
 /**
  * Creates an `Effect` that represents a failure with a `Cause` computed lazily.
  *
+ * **Details**
+ *
  * This function is useful when you need to create a failure effect with a
  * complex cause but want to defer the computation until the effect is run.
  *
@@ -1806,7 +1839,7 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ef
 /**
  * Creates an effect that terminates a fiber with a specified error.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `die` when encountering unexpected conditions in your code that should
  * not be handled as regular errors but instead represent unrecoverable defects.
@@ -1820,8 +1853,6 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ef
  * The error channel of the resulting effect is of type `never`, indicating that
  * it cannot recover from this failure.
  *
- * @see {@link die} for a variant that dies with an already computed defect.
- *
  * **Example** (Failing when division by zero)
  *
  * ```ts
@@ -1842,6 +1873,7 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ef
  * //   ...stack trace...
  * ```
  *
+ * @see {@link die} for a variant that dies with an already computed defect.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -1855,14 +1887,16 @@ export {
  * Creates an `Effect` that represents a synchronous computation that might
  * fail.
  *
- * **When to Use**
+ * **When to use**
  *
  * In situations where you need to perform synchronous operations that might
  * fail, such as parsing JSON, you can use the `try` constructor. This
  * constructor is designed to handle operations that could throw exceptions by
  * capturing those exceptions and transforming them into manageable errors.
  *
- * **Error Handling**
+ * **Details**
+ *
+ * Error Handling:
  *
  * There are two ways to handle errors with `try`:
  *
@@ -1871,9 +1905,6 @@ export {
  * 2. If you provide a `catch` function, the error is caught and the `catch`
  *    function maps it to an error of type `E`.
  *
- * @see {@link sync} if the effectful computation is synchronous and does not
- * throw errors.
- *
  * **Example** (Parsing JSON with typed error mapping)
  *
  * ```ts
@@ -1911,6 +1942,8 @@ export {
  * // Output: Exit.failure with custom Error message
  * ```
  *
+ * @see {@link sync} if the effectful computation is synchronous and does not
+ * throw errors.
  * @category Creating Effects
  * @since 2.0.0
  */
@@ -2003,6 +2036,8 @@ export declare const fromResult: <A, E>(result: Result.Result<A, E>) => Effect<A
 /**
  * Converts an `Option` into an `Effect`.
  *
+ * **Details**
+ *
  * `Option.some` becomes a successful effect with the contained value, while
  * `Option.none` becomes a failed effect with `NoSuchElementError`.
  *
@@ -2056,15 +2091,11 @@ export declare const fromNullishOr: <A>(value: A) => Effect<NonNullable<A>, Caus
  * Chains effects to produce new `Effect` instances, useful for combining
  * operations that depend on previous results.
  *
- * **Syntax**
+ * **When to use**
  *
- * ```ts skip-type-checking
- * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation))
- * // or
- * const flatMappedEffect = Effect.flatMap(myEffect, transformation)
- * // or
- * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation))
- * ```
+ * Use `flatMap` when you need to chain multiple effects, ensuring that each
+ * step produces a new `Effect` while flattening any nested effects that may
+ * occur.
  *
  * **Details**
  *
@@ -2076,11 +2107,18 @@ export declare const fromNullishOr: <A>(value: A) => Effect<NonNullable<A>, Caus
  * Since effects are immutable, `flatMap` always returns a new effect instead of
  * changing the original one.
  *
- * **When to Use**
+ * **Example** (Syntax)
  *
- * Use `flatMap` when you need to chain multiple effects, ensuring that each
- * step produces a new `Effect` while flattening any nested effects that may
- * occur.
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * const myEffect = Effect.succeed(1)
+ * const transformation = (n: number) => Effect.succeed(n + 1)
+ *
+ * const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))
+ * const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)
+ * const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))
+ * ```
  *
  * **Example** (Sequencing dependent effects)
  *
@@ -2112,7 +2150,6 @@ export declare const fromNullishOr: <A>(value: A) => Effect<NonNullable<A>, Caus
  * ```
  *
  * @see {@link tap} for a version that ignores the result of the effect.
- *
  * @category sequencing
  * @since 2.0.0
  */
@@ -2121,15 +2158,11 @@ export declare const flatMap: {
      * Chains effects to produce new `Effect` instances, useful for combining
      * operations that depend on previous results.
      *
-     * **Syntax**
+     * **When to use**
      *
-     * ```ts skip-type-checking
-     * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation))
-     * // or
-     * const flatMappedEffect = Effect.flatMap(myEffect, transformation)
-     * // or
-     * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation))
-     * ```
+     * Use `flatMap` when you need to chain multiple effects, ensuring that each
+     * step produces a new `Effect` while flattening any nested effects that may
+     * occur.
      *
      * **Details**
      *
@@ -2141,11 +2174,18 @@ export declare const flatMap: {
      * Since effects are immutable, `flatMap` always returns a new effect instead of
      * changing the original one.
      *
-     * **When to Use**
+     * **Example** (Syntax)
      *
-     * Use `flatMap` when you need to chain multiple effects, ensuring that each
-     * step produces a new `Effect` while flattening any nested effects that may
-     * occur.
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const transformation = (n: number) => Effect.succeed(n + 1)
+     *
+     * const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))
+     * const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)
+     * const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))
+     * ```
      *
      * **Example** (Sequencing dependent effects)
      *
@@ -2177,7 +2217,6 @@ export declare const flatMap: {
      * ```
      *
      * @see {@link tap} for a version that ignores the result of the effect.
-     *
      * @category sequencing
      * @since 2.0.0
      */
@@ -2186,15 +2225,11 @@ export declare const flatMap: {
      * Chains effects to produce new `Effect` instances, useful for combining
      * operations that depend on previous results.
      *
-     * **Syntax**
+     * **When to use**
      *
-     * ```ts skip-type-checking
-     * const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation))
-     * // or
-     * const flatMappedEffect = Effect.flatMap(myEffect, transformation)
-     * // or
-     * const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation))
-     * ```
+     * Use `flatMap` when you need to chain multiple effects, ensuring that each
+     * step produces a new `Effect` while flattening any nested effects that may
+     * occur.
      *
      * **Details**
      *
@@ -2206,11 +2241,18 @@ export declare const flatMap: {
      * Since effects are immutable, `flatMap` always returns a new effect instead of
      * changing the original one.
      *
-     * **When to Use**
+     * **Example** (Syntax)
      *
-     * Use `flatMap` when you need to chain multiple effects, ensuring that each
-     * step produces a new `Effect` while flattening any nested effects that may
-     * occur.
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const transformation = (n: number) => Effect.succeed(n + 1)
+     *
+     * const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))
+     * const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)
+     * const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))
+     * ```
      *
      * **Example** (Sequencing dependent effects)
      *
@@ -2242,7 +2284,6 @@ export declare const flatMap: {
      * ```
      *
      * @see {@link tap} for a version that ignores the result of the effect.
-     *
      * @category sequencing
      * @since 2.0.0
      */
@@ -2273,17 +2314,7 @@ export declare const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2
  * Runs this effect and then runs another effect, optionally using the first
  * effect's success value to choose the next effect.
  *
- * **Syntax**
- *
- * ```ts skip-type-checking
- * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
- * // or
- * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
- * // or
- * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
- * ```
- *
- * **When to Use**
+ * **When to use**
  *
  * Use `andThen` when one effect must run after another and the second effect
  * may depend on the first effect's success value.
@@ -2298,6 +2329,19 @@ export declare const flatten: <A, E, R, E2, R2>(self: Effect<Effect<A, E, R>, E2
  * Failures or requirements from either effect are preserved in the returned
  * effect.
  *
+ * **Example** (Syntax)
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * const myEffect = Effect.succeed(1)
+ * const anotherEffect = Effect.succeed("done")
+ *
+ * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))
+ * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)
+ * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))
+ * ```
+ *
  * **Example** (Sequencing a discount calculation after fetching a total)
  *
  * ```ts
@@ -2346,17 +2390,7 @@ export declare const andThen: {
      * Runs this effect and then runs another effect, optionally using the first
      * effect's success value to choose the next effect.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
-     * // or
-     * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
-     * // or
-     * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
-     * ```
-     *
-     * **When to Use**
+     * **When to use**
      *
      * Use `andThen` when one effect must run after another and the second effect
      * may depend on the first effect's success value.
@@ -2371,6 +2405,19 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const anotherEffect = Effect.succeed("done")
+     *
+     * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))
+     * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)
+     * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))
+     * ```
+     *
      * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
@@ -2419,17 +2466,7 @@ export declare const andThen: {
      * Runs this effect and then runs another effect, optionally using the first
      * effect's success value to choose the next effect.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
-     * // or
-     * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
-     * // or
-     * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
-     * ```
-     *
-     * **When to Use**
+     * **When to use**
      *
      * Use `andThen` when one effect must run after another and the second effect
      * may depend on the first effect's success value.
@@ -2444,6 +2481,19 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const anotherEffect = Effect.succeed("done")
+     *
+     * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))
+     * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)
+     * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))
+     * ```
+     *
      * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
@@ -2492,17 +2542,7 @@ export declare const andThen: {
      * Runs this effect and then runs another effect, optionally using the first
      * effect's success value to choose the next effect.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
-     * // or
-     * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
-     * // or
-     * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
-     * ```
-     *
-     * **When to Use**
+     * **When to use**
      *
      * Use `andThen` when one effect must run after another and the second effect
      * may depend on the first effect's success value.
@@ -2517,6 +2557,19 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const anotherEffect = Effect.succeed("done")
+     *
+     * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))
+     * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)
+     * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))
+     * ```
+     *
      * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
@@ -2565,17 +2618,7 @@ export declare const andThen: {
      * Runs this effect and then runs another effect, optionally using the first
      * effect's success value to choose the next effect.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
-     * // or
-     * const transformedEffect = Effect.andThen(myEffect, anotherEffect)
-     * // or
-     * const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))
-     * ```
-     *
-     * **When to Use**
+     * **When to use**
      *
      * Use `andThen` when one effect must run after another and the second effect
      * may depend on the first effect's success value.
@@ -2590,6 +2633,19 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const anotherEffect = Effect.succeed("done")
+     *
+     * const transformedWithPipe = pipe(myEffect, Effect.andThen(anotherEffect))
+     * const transformedWithDataFirst = Effect.andThen(myEffect, anotherEffect)
+     * const transformedWithMethod = myEffect.pipe(Effect.andThen(anotherEffect))
+     * ```
+     *
      * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
@@ -2639,7 +2695,7 @@ export declare const andThen: {
  * Runs a side effect with the result of an effect without changing the original
  * value.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `tap` when you want to perform a side effect, like logging or tracking,
  * without modifying the main value. This is useful when you need to observe or
@@ -2693,7 +2749,7 @@ export declare const tap: {
      * Runs a side effect with the result of an effect without changing the original
      * value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `tap` when you want to perform a side effect, like logging or tracking,
      * without modifying the main value. This is useful when you need to observe or
@@ -2747,7 +2803,7 @@ export declare const tap: {
      * Runs a side effect with the result of an effect without changing the original
      * value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `tap` when you want to perform a side effect, like logging or tracking,
      * without modifying the main value. This is useful when you need to observe or
@@ -2801,7 +2857,7 @@ export declare const tap: {
      * Runs a side effect with the result of an effect without changing the original
      * value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `tap` when you want to perform a side effect, like logging or tracking,
      * without modifying the main value. This is useful when you need to observe or
@@ -2855,7 +2911,7 @@ export declare const tap: {
      * Runs a side effect with the result of an effect without changing the original
      * value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use `tap` when you want to perform a side effect, like logging or tracking,
      * without modifying the main value. This is useful when you need to observe or
@@ -3028,16 +3084,6 @@ export declare const exit: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<
 /**
  * Transforms the value inside an effect by applying a function to it.
  *
- * **Syntax**
- *
- * ```ts skip-type-checking
- * const mappedEffect = pipe(myEffect, Effect.map(transformation))
- * // or
- * const mappedEffect = Effect.map(myEffect, transformation)
- * // or
- * const mappedEffect = myEffect.pipe(Effect.map(transformation))
- * ```
- *
  * **Details**
  *
  * `map` takes a function and applies it to the value contained within an
@@ -3047,6 +3093,19 @@ export declare const exit: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<
  * effect is not modified. Instead, a new effect is returned with the updated
  * value.
  *
+ * **Example** (Syntax)
+ *
+ * ```ts
+ * import { Effect, pipe } from "effect"
+ *
+ * const myEffect = Effect.succeed(1)
+ * const transformation = (n: number) => n + 1
+ *
+ * const mappedWithPipe = pipe(myEffect, Effect.map(transformation))
+ * const mappedWithDataFirst = Effect.map(myEffect, transformation)
+ * const mappedWithMethod = myEffect.pipe(Effect.map(transformation))
+ * ```
+ *
  * **Example** (Adding a service charge)
  *
  * ```ts
@@ -3068,7 +3127,6 @@ export declare const exit: <A, E, R>(self: Effect<A, E, R>) => Effect<Exit.Exit<
  * @see {@link mapError} for a version that operates on the error channel.
  * @see {@link mapBoth} for a version that operates on both channels.
  * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
- *
  * @category mapping
  * @since 2.0.0
  */
@@ -3076,16 +3134,6 @@ export declare const map: {
     /**
      * Transforms the value inside an effect by applying a function to it.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const mappedEffect = pipe(myEffect, Effect.map(transformation))
-     * // or
-     * const mappedEffect = Effect.map(myEffect, transformation)
-     * // or
-     * const mappedEffect = myEffect.pipe(Effect.map(transformation))
-     * ```
-     *
      * **Details**
      *
      * `map` takes a function and applies it to the value contained within an
@@ -3095,6 +3143,19 @@ export declare const map: {
      * effect is not modified. Instead, a new effect is returned with the updated
      * value.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const transformation = (n: number) => n + 1
+     *
+     * const mappedWithPipe = pipe(myEffect, Effect.map(transformation))
+     * const mappedWithDataFirst = Effect.map(myEffect, transformation)
+     * const mappedWithMethod = myEffect.pipe(Effect.map(transformation))
+     * ```
+     *
      * **Example** (Adding a service charge)
      *
      * ```ts
@@ -3116,7 +3177,6 @@ export declare const map: {
      * @see {@link mapError} for a version that operates on the error channel.
      * @see {@link mapBoth} for a version that operates on both channels.
      * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
-     *
      * @category mapping
      * @since 2.0.0
      */
@@ -3124,16 +3184,6 @@ export declare const map: {
     /**
      * Transforms the value inside an effect by applying a function to it.
      *
-     * **Syntax**
-     *
-     * ```ts skip-type-checking
-     * const mappedEffect = pipe(myEffect, Effect.map(transformation))
-     * // or
-     * const mappedEffect = Effect.map(myEffect, transformation)
-     * // or
-     * const mappedEffect = myEffect.pipe(Effect.map(transformation))
-     * ```
-     *
      * **Details**
      *
      * `map` takes a function and applies it to the value contained within an
@@ -3143,6 +3193,19 @@ export declare const map: {
      * effect is not modified. Instead, a new effect is returned with the updated
      * value.
      *
+     * **Example** (Syntax)
+     *
+     * ```ts
+     * import { Effect, pipe } from "effect"
+     *
+     * const myEffect = Effect.succeed(1)
+     * const transformation = (n: number) => n + 1
+     *
+     * const mappedWithPipe = pipe(myEffect, Effect.map(transformation))
+     * const mappedWithDataFirst = Effect.map(myEffect, transformation)
+     * const mappedWithMethod = myEffect.pipe(Effect.map(transformation))
+     * ```
+     *
      * **Example** (Adding a service charge)
      *
      * ```ts
@@ -3164,7 +3227,6 @@ export declare const map: {
      * @see {@link mapError} for a version that operates on the error channel.
      * @see {@link mapBoth} for a version that operates on both channels.
      * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
-     *
      * @category mapping
      * @since 2.0.0
      */
@@ -3173,6 +3235,8 @@ export declare const map: {
 /**
  * Replaces the value inside an effect with a constant value.
  *
+ * **Details**
+ *
  * `as` allows you to ignore the original value inside an effect and
  * replace it with a new constant value.
  *
@@ -3195,6 +3259,8 @@ export declare const as: {
     /**
      * Replaces the value inside an effect with a constant value.
      *
+     * **Details**
+     *
      * `as` allows you to ignore the original value inside an effect and
      * replace it with a new constant value.
      *
@@ -3217,6 +3283,8 @@ export declare const as: {
     /**
      * Replaces the value inside an effect with a constant value.
      *
+     * **Details**
+     *
      * `as` allows you to ignore the original value inside an effect and
      * replace it with a new constant value.
      *
@@ -3282,6 +3350,8 @@ export declare const asVoid: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E,
  * The `flip` function swaps the success and error channels of an effect,
  * so that the success becomes the error, and the error becomes the success.
  *
+ * **Details**
+ *
  * This function is useful when you need to reverse the flow of an effect,
  * treating the previously successful values as errors and vice versa. This can
  * be helpful in scenarios where you want to handle a success as a failure or
@@ -3308,17 +3378,16 @@ export declare const flip: <A, E, R>(self: Effect<A, E, R>) => Effect<E, A, R>;
 /**
  * Combines two effects into a single effect, producing a tuple with the results of both effects.
  *
+ * **Details**
+ *
  * The `zip` function executes the first effect (left) and then the second effect (right).
  * Once both effects succeed, their results are combined into a tuple.
  *
- * **Concurrency**
+ * Concurrency:
  *
  * By default, `zip` processes the effects sequentially. To execute the effects concurrently,
  * use the `{ concurrent: true }` option.
  *
- * @see {@link zipWith} for a version that combines the results with a custom function.
- * @see {@link validate} for a version that accumulates errors.
- *
  * **Example** (Combining two effects sequentially)
  *
  * ```ts
@@ -3370,6 +3439,8 @@ export declare const flip: <A, E, R>(self: Effect<A, E, R>) => Effect<E, A, R>;
  * // [ 1, 'hello' ]
  * ```
  *
+ * @see {@link zipWith} for a version that combines the results with a custom function.
+ * @see {@link validate} for a version that accumulates errors.
  * @category zipping
  * @since 2.0.0
  */
@@ -3377,17 +3448,16 @@ export declare const zip: {
     /**
      * Combines two effects into a single effect, producing a tuple with the results of both effects.
      *
+     * **Details**
+     *
      * The `zip` function executes the first effect (left) and then the second effect (right).
      * Once both effects succeed, their results are combined into a tuple.
      *
-     * **Concurrency**
+     * Concurrency:
      *
      * By default, `zip` processes the effects sequentially. To execute the effects concurrently,
      * use the `{ concurrent: true }` option.
      *
-     * @see {@link zipWith} for a version that combines the results with a custom function.
-     * @see {@link validate} for a version that accumulates errors.
-     *
      * **Example** (Combining two effects sequentially)
      *
      * ```ts
@@ -3439,6 +3509,8 @@ export declare const zip: {
      * // [ 1, 'hello' ]
      * ```
      *
+     * @see {@link zipWith} for a version that combines the results with a custom function.
+     * @see {@link validate} for a version that accumulates errors.
      * @category zipping
      * @since 2.0.0
      */
@@ -3448,17 +3520,16 @@ export declare const zip: {
     /**
      * Combines two effects into a single effect, producing a tuple with the results of both effects.
      *
+     * **Details**
+     *
      * The `zip` function executes the first effect (left) and then the second effect (right).
      * Once both effects succeed, their results are combined into a tuple.
      *
-     * **Concurrency**
+     * Concurrency:
      *
      * By default, `zip` processes the effects sequentially. To execute the effects concurrently,
      * use the `{ concurrent: true }` option.
      *
-     * @see {@link zipWith} for a version that combines the results with a custom function.
-     * @see {@link validate} for a version that accumulates errors.
-     *
      * **Example** (Combining two effects sequentially)
      *
      * ```ts
@@ -3510,6 +3581,8 @@ export declare const zip: {
      * // [ 1, 'hello' ]
      * ```
      *
+     * @see {@link zipWith} for a version that combines the results with a custom function.
+     * @see {@link validate} for a version that accumulates errors.
      * @category zipping
      * @since 2.0.0
      */
@@ -3521,13 +3594,15 @@ export declare const zip: {
  * Combines two effects sequentially and applies a function to their results to
  * produce a single value.
  *
- * **When to Use**
+ * **When to use**
  *
  * The `zipWith` function is similar to {@link zip}, but instead of returning a
  * tuple of results, it applies a provided function to the results of the two
  * effects, combining them into a single value.
  *
- * **Concurrency**
+ * **Details**
+ *
+ * Concurrency:
  *
  * By default, the effects are run sequentially. To execute them concurrently,
  * use the `{ concurrent: true }` option.
@@ -3568,13 +3643,15 @@ export declare const zipWith: {
      * Combines two effects sequentially and applies a function to their results to
      * produce a single value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * The `zipWith` function is similar to {@link zip}, but instead of returning a
      * tuple of results, it applies a provided function to the results of the two
      * effects, combining them into a single value.
      *
-     * **Concurrency**
+     * **Details**
+     *
+     * Concurrency:
      *
      * By default, the effects are run sequentially. To execute them concurrently,
      * use the `{ concurrent: true }` option.
@@ -3617,13 +3694,15 @@ export declare const zipWith: {
      * Combines two effects sequentially and applies a function to their results to
      * produce a single value.
      *
-     * **When to Use**
+     * **When to use**
      *
      * The `zipWith` function is similar to {@link zip}, but instead of returning a
      * tuple of results, it applies a provided function to the results of the two
      * effects, combining them into a single value.
      *
-     * **Concurrency**
+     * **Details**
+     *
+     * Concurrency:
      *
      * By default, the effects are run sequentially. To execute them concurrently,
      * use the `{ concurrent: true }` option.
@@ -3691,7 +3770,7 @@ catch_ as catch };
  * Catches and handles specific errors by their `_tag` field, which is used as a
  * discriminator.
  *
- * **When to Use**
+ * **When to use**
  *
  * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
  * that identifies the error type. You can use this function to handle specific
@@ -3733,7 +3812,7 @@ export declare const catchTag: {
      * Catches and handles specific errors by their `_tag` field, which is used as a
      * discriminator.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
      * that identifies the error type. You can use this function to handle specific
@@ -3775,7 +3854,7 @@ export declare const catchTag: {
      * Catches and handles specific errors by their `_tag` field, which is used as a
      * discriminator.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchTag` is useful when your errors are tagged with a readonly `_tag` field
      * that identifies the error type. You can use this function to handle specific
@@ -3817,7 +3896,7 @@ export declare const catchTag: {
 /**
  * Handles multiple errors in a single block of code using their `_tag` field.
  *
- * **When to Use**
+ * **When to use**
  *
  * `catchTags` is a convenient way to handle multiple error types at
  * once. Instead of using {@link catchTag} multiple times, you can pass an
@@ -3861,7 +3940,7 @@ export declare const catchTags: {
     /**
      * Handles multiple errors in a single block of code using their `_tag` field.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchTags` is a convenient way to handle multiple error types at
      * once. Instead of using {@link catchTag} multiple times, you can pass an
@@ -3925,7 +4004,7 @@ export declare const catchTags: {
     /**
      * Handles multiple errors in a single block of code using their `_tag` field.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchTags` is a convenient way to handle multiple error types at
      * once. Instead of using {@link catchTag} multiple times, you can pass an
@@ -3990,6 +4069,8 @@ export declare const catchTags: {
 /**
  * Catches a specific reason within a tagged error.
  *
+ * **Details**
+ *
  * Use this to handle nested error causes without removing the parent error
  * from the error channel. The handler receives the unwrapped reason.
  *
@@ -4027,6 +4108,8 @@ export declare const catchReason: {
     /**
      * Catches a specific reason within a tagged error.
      *
+     * **Details**
+     *
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
@@ -4064,6 +4147,8 @@ export declare const catchReason: {
     /**
      * Catches a specific reason within a tagged error.
      *
+     * **Details**
+     *
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
@@ -4227,6 +4312,8 @@ export declare const catchReasons: {
 /**
  * Type helper that keeps only error tags whose tagged error contains a tagged `reason` field.
  *
+ * **Details**
+ *
  * Used by `catchReasons` and `unwrapReason` to constrain the parent error tag to reason-bearing errors.
  *
  * @category error handling
@@ -4336,14 +4423,16 @@ export declare const unwrapReason: {
  * Handles both recoverable and unrecoverable errors by providing a recovery
  * effect.
  *
- * **When to Use**
+ * **When to use**
  *
  * The `catchCause` function allows you to handle all errors, including
  * unrecoverable defects, by providing a recovery effect. The recovery logic is
  * based on the `Cause` of the error, which provides detailed information about
  * the failure.
  *
- * **When to Recover from Defects**
+ * **Details**
+ *
+ * When to Recover from Defects:
  *
  * Defects are unexpected errors that typically shouldn't be recovered from, as
  * they often indicate serious issues. However, in some cases, such as
@@ -4376,14 +4465,16 @@ export declare const catchCause: {
      * Handles both recoverable and unrecoverable errors by providing a recovery
      * effect.
      *
-     * **When to Use**
+     * **When to use**
      *
      * The `catchCause` function allows you to handle all errors, including
      * unrecoverable defects, by providing a recovery effect. The recovery logic is
      * based on the `Cause` of the error, which provides detailed information about
      * the failure.
      *
-     * **When to Recover from Defects**
+     * **Details**
+     *
+     * When to Recover from Defects:
      *
      * Defects are unexpected errors that typically shouldn't be recovered from, as
      * they often indicate serious issues. However, in some cases, such as
@@ -4416,14 +4507,16 @@ export declare const catchCause: {
      * Handles both recoverable and unrecoverable errors by providing a recovery
      * effect.
      *
-     * **When to Use**
+     * **When to use**
      *
      * The `catchCause` function allows you to handle all errors, including
      * unrecoverable defects, by providing a recovery effect. The recovery logic is
      * based on the `Cause` of the error, which provides detailed information about
      * the failure.
      *
-     * **When to Recover from Defects**
+     * **Details**
+     *
+     * When to Recover from Defects:
      *
      * Defects are unexpected errors that typically shouldn't be recovered from, as
      * they often indicate serious issues. However, in some cases, such as
@@ -4456,7 +4549,7 @@ export declare const catchCause: {
 /**
  * Recovers from defects using a provided recovery function.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use this sparingly, usually at integration boundaries where defects must be
  * reported or translated for an external system.
@@ -4466,7 +4559,7 @@ export declare const catchCause: {
  * `catchDefect` handles unexpected defects, such as thrown exceptions or
  * values passed to `die`, without catching typed failures or interruptions.
  *
- * **When to Recover from Defects**
+ * When to Recover from Defects:
  *
  * Defects are unexpected errors that typically should not be recovered from, as
  * they often indicate serious issues. In some cases, such as dynamically loaded
@@ -4497,7 +4590,7 @@ export declare const catchDefect: {
     /**
      * Recovers from defects using a provided recovery function.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use this sparingly, usually at integration boundaries where defects must be
      * reported or translated for an external system.
@@ -4507,7 +4600,7 @@ export declare const catchDefect: {
      * `catchDefect` handles unexpected defects, such as thrown exceptions or
      * values passed to `die`, without catching typed failures or interruptions.
      *
-     * **When to Recover from Defects**
+     * When to Recover from Defects:
      *
      * Defects are unexpected errors that typically should not be recovered from, as
      * they often indicate serious issues. In some cases, such as dynamically loaded
@@ -4538,7 +4631,7 @@ export declare const catchDefect: {
     /**
      * Recovers from defects using a provided recovery function.
      *
-     * **When to Use**
+     * **When to use**
      *
      * Use this sparingly, usually at integration boundaries where defects must be
      * reported or translated for an external system.
@@ -4548,7 +4641,7 @@ export declare const catchDefect: {
      * `catchDefect` handles unexpected defects, such as thrown exceptions or
      * values passed to `die`, without catching typed failures or interruptions.
      *
-     * **When to Recover from Defects**
+     * When to Recover from Defects:
      *
      * Defects are unexpected errors that typically should not be recovered from, as
      * they often indicate serious issues. In some cases, such as dynamically loaded
@@ -4580,7 +4673,7 @@ export declare const catchDefect: {
 /**
  * Recovers from specific errors using a `Predicate` or `Refinement`.
  *
- * **When to Use**
+ * **When to use**
  *
  * `catchIf` lets you recover from errors that match a condition. Use a
  * `Refinement` for type narrowing or a `Predicate` for simple boolean
@@ -4620,7 +4713,7 @@ export declare const catchIf: {
     /**
      * Recovers from specific errors using a `Predicate` or `Refinement`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchIf` lets you recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
@@ -4660,7 +4753,7 @@ export declare const catchIf: {
     /**
      * Recovers from specific errors using a `Predicate` or `Refinement`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchIf` lets you recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
@@ -4700,7 +4793,7 @@ export declare const catchIf: {
     /**
      * Recovers from specific errors using a `Predicate` or `Refinement`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchIf` lets you recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
@@ -4740,7 +4833,7 @@ export declare const catchIf: {
     /**
      * Recovers from specific errors using a `Predicate` or `Refinement`.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchIf` lets you recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
@@ -4803,6 +4896,8 @@ export declare const catchFilter: {
 /**
  * Catches `NoSuchElementError` failures and converts them to `Option.none`.
  *
+ * **Details**
+ *
  * Success values become `Option.some`, `NoSuchElementError` becomes
  * `Option.none`, and all other errors are preserved.
  *
@@ -4825,6 +4920,8 @@ export declare const catchNoSuchElement: <A, E, R>(self: Effect<A, E, R>) => Eff
 /**
  * Recovers from specific failures based on a predicate.
  *
+ * **Details**
+ *
  * This function allows you to conditionally catch and recover from failures
  * that match a specific predicate. This is useful when you want to handle
  * only certain types of errors while letting others propagate.
@@ -4859,6 +4956,8 @@ export declare const catchCauseIf: {
     /**
      * Recovers from specific failures based on a predicate.
      *
+     * **Details**
+     *
      * This function allows you to conditionally catch and recover from failures
      * that match a specific predicate. This is useful when you want to handle
      * only certain types of errors while letting others propagate.
@@ -4893,6 +4992,8 @@ export declare const catchCauseIf: {
     /**
      * Recovers from specific failures based on a predicate.
      *
+     * **Details**
+     *
      * This function allows you to conditionally catch and recover from failures
      * that match a specific predicate. This is useful when you want to handle
      * only certain types of errors while letting others propagate.
@@ -4951,15 +5052,13 @@ export declare const catchCauseFilter: {
  * The `mapError` function is used to transform or modify the error
  * produced by an effect, without affecting its success value.
  *
+ * **Details**
+ *
  * 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.
  *
- * @see {@link map} for a version that operates on the success channel.
- * @see {@link mapBoth} for a version that operates on both channels.
- * @see {@link mapError} if you want to replace the error with a new one.
- *
  * **Example** (Transforming the error channel)
  *
  * ```ts
@@ -4979,6 +5078,9 @@ export declare const catchCauseFilter: {
  * )
  * ```
  *
+ * @see {@link map} for a version that operates on the success channel.
+ * @see {@link mapBoth} for a version that operates on both channels.
+ * @see {@link mapError} if you want to replace the error with a new one.
  * @category error handling
  * @since 2.0.0
  */
@@ -4987,15 +5089,13 @@ export declare const mapError: {
      * The `mapError` function is used to transform or modify the error
      * produced by an effect, without affecting its success value.
      *
+     * **Details**
+     *
      * 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.
      *
-     * @see {@link map} for a version that operates on the success channel.
-     * @see {@link mapBoth} for a version that operates on both channels.
-     * @see {@link mapError} if you want to replace the error with a new one.
-     *
      * **Example** (Transforming the error channel)
      *
      * ```ts
@@ -5015,6 +5115,9 @@ export declare const mapError: {
      * )
      * ```
      *
+     * @see {@link map} for a version that operates on the success channel.
+     * @see {@link mapBoth} for a version that operates on both channels.
+     * @see {@link mapError} if you want to replace the error with a new one.
      * @category error handling
      * @since 2.0.0
      */
@@ -5023,15 +5126,13 @@ export declare const mapError: {
      * The `mapError` function is used to transform or modify the error
      * produced by an effect, without affecting its success value.
      *
+     * **Details**
+     *
      * 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.
      *
-     * @see {@link map} for a version that operates on the success channel.
-     * @see {@link mapBoth} for a version that operates on both channels.
-     * @see {@link mapError} if you want to replace the error with a new one.
-     *
      * **Example** (Transforming the error channel)
      *
      * ```ts
@@ -5051,6 +5152,9 @@ export declare const mapError: {
      * )
      * ```
      *
+     * @see {@link map} for a version that operates on the success channel.
+     * @see {@link mapBoth} for a version that operates on both channels.
+     * @see {@link mapError} if you want to replace the error with a new one.
      * @category error handling
      * @since 2.0.0
      */
@@ -5175,13 +5279,11 @@ export declare const mapBoth: {
  * Converts typed failures from the error channel into defects, removing the
  * error type from the returned effect.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `orDie` when a typed failure represents an unrecoverable bug or invalid
  * state and should not be handled as a recoverable error.
  *
- * @see {@link mapError} to transform the error before converting it into a defect with {@link orDie}.
- *
  * **Example** (Converting typed failures into defects)
  *
  * ```ts
@@ -5204,6 +5306,7 @@ export declare const mapBoth: {
  * //   ...stack trace...
  * ```
  *
+ * @see {@link mapError} to transform the error before converting it into a defect with {@link orDie}.
  * @category Converting Failures to Defects
  * @since 2.0.0
  */
@@ -5311,6 +5414,8 @@ export declare const tapError: {
 /**
  * Runs an effectful handler when a failure's `_tag` matches.
  *
+ * **Details**
+ *
  * Use this with tagged-union errors to perform side effects for one tag or a
  * list of tags. When the handler succeeds, the original failure is preserved;
  * if the handler fails, its error is also included in the returned effect.
@@ -5347,6 +5452,8 @@ export declare const tapErrorTag: {
     /**
      * Runs an effectful handler when a failure's `_tag` matches.
      *
+     * **Details**
+     *
      * Use this with tagged-union errors to perform side effects for one tag or a
      * list of tags. When the handler succeeds, the original failure is preserved;
      * if the handler fails, its error is also included in the returned effect.
@@ -5383,6 +5490,8 @@ export declare const tapErrorTag: {
     /**
      * Runs an effectful handler when a failure's `_tag` matches.
      *
+     * **Details**
+     *
      * Use this with tagged-union errors to perform side effects for one tag or a
      * list of tags. When the handler succeeds, the original failure is preserved;
      * if the handler fails, its error is also included in the returned effect.
@@ -5514,6 +5623,8 @@ export declare const tapCause: {
 /**
  * Conditionally executes a side effect based on the cause of a failed effect.
  *
+ * **Details**
+ *
  * This function allows you to tap into the cause of an effect's failure only when
  * the cause matches a specific predicate. This is useful for conditional logging,
  * monitoring, or other side effects based on the type of failure.
@@ -5544,6 +5655,8 @@ export declare const tapCauseIf: {
     /**
      * Conditionally executes a side effect based on the cause of a failed effect.
      *
+     * **Details**
+     *
      * This function allows you to tap into the cause of an effect's failure only when
      * the cause matches a specific predicate. This is useful for conditional logging,
      * monitoring, or other side effects based on the type of failure.
@@ -5574,6 +5687,8 @@ export declare const tapCauseIf: {
     /**
      * Conditionally executes a side effect based on the cause of a failed effect.
      *
+     * **Details**
+     *
      * This function allows you to tap into the cause of an effect's failure only when
      * the cause matches a specific predicate. This is useful for conditional logging,
      * monitoring, or other side effects based on the type of failure.
@@ -5772,6 +5887,8 @@ export declare const tapDefect: {
 /**
  * Retries an effect until it succeeds, discarding failures.
  *
+ * **Details**
+ *
  * Yields between attempts so other fibers can run.
  *
  * **Example** (Retrying until success)
@@ -5853,6 +5970,11 @@ export declare namespace Retry {
 /**
  * Retries typed failures from an effect according to a retry policy.
  *
+ * **When to use**
+ *
+ * Use `retry` when typed failures may be transient, such as network issues or
+ * temporary resource unavailability.
+ *
  * **Details**
  *
  * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -5862,11 +5984,6 @@ export declare namespace Retry {
  *
  * Defects and interruptions are not retried as typed failures.
  *
- * **When to Use**
- *
- * Use `retry` when typed failures may be transient, such as network issues or
- * temporary resource unavailability.
- *
  * **Example** (Retrying with a schedule)
  *
  * ```ts
@@ -5893,7 +6010,6 @@ export declare namespace Retry {
  *
  * @see {@link retryOrElse} for a version that allows you to run a fallback.
  * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
- *
  * @category error handling
  * @since 2.0.0
  */
@@ -5901,6 +6017,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -5910,11 +6031,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -5941,7 +6057,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -5949,6 +6064,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -5958,11 +6078,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -5989,7 +6104,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -5997,6 +6111,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -6006,11 +6125,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -6037,7 +6151,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -6045,6 +6158,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -6054,11 +6172,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -6085,7 +6198,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -6093,6 +6205,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -6102,11 +6219,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -6133,7 +6245,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -6141,6 +6252,11 @@ export declare const retry: {
     /**
      * Retries typed failures from an effect according to a retry policy.
      *
+     * **When to use**
+     *
+     * Use `retry` when typed failures may be transient, such as network issues or
+     * temporary resource unavailability.
+     *
      * **Details**
      *
      * The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
@@ -6150,11 +6266,6 @@ export declare const retry: {
      *
      * Defects and interruptions are not retried as typed failures.
      *
-     * **When to Use**
-     *
-     * Use `retry` when typed failures may be transient, such as network issues or
-     * temporary resource unavailability.
-     *
      * **Example** (Retrying with a schedule)
      *
      * ```ts
@@ -6181,7 +6292,6 @@ export declare const retry: {
      *
      * @see {@link retryOrElse} for a version that allows you to run a fallback.
      * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
-     *
      * @category error handling
      * @since 2.0.0
      */
@@ -6190,6 +6300,11 @@ export declare const retry: {
 /**
  * Retries a failing effect and runs a fallback effect if retries are exhausted.
  *
+ * **When to use**
+ *
+ * This function is useful when you want to handle failures gracefully by
+ * specifying an alternative action after repeated failures.
+ *
  * **Details**
  *
  * The `Effect.retryOrElse` function attempts to retry a failing effect multiple
@@ -6198,13 +6313,6 @@ export declare const retry: {
  * If the retries are exhausted and the effect still fails, it runs a fallback
  * effect instead.
  *
- * **When to Use**
- *
- * This function is useful when you want to handle failures gracefully by
- * specifying an alternative action after repeated failures.
- *
- * @see {@link retry} for a version that does not run a fallback effect.
- *
  * **Example** (Falling back after retries are exhausted)
  *
  * ```ts
@@ -6241,6 +6349,7 @@ export declare const retry: {
  * // Network data
  * ```
  *
+ * @see {@link retry} for a version that does not run a fallback effect.
  * @category error handling
  * @since 2.0.0
  */
@@ -6248,6 +6357,11 @@ export declare const retryOrElse: {
     /**
      * Retries a failing effect and runs a fallback effect if retries are exhausted.
      *
+     * **When to use**
+     *
+     * This function is useful when you want to handle failures gracefully by
+     * specifying an alternative action after repeated failures.
+     *
      * **Details**
      *
      * The `Effect.retryOrElse` function attempts to retry a failing effect multiple
@@ -6256,13 +6370,6 @@ export declare const retryOrElse: {
      * If the retries are exhausted and the effect still fails, it runs a fallback
      * effect instead.
      *
-     * **When to Use**
-     *
-     * This function is useful when you want to handle failures gracefully by
-     * specifying an alternative action after repeated failures.
-     *
-     * @see {@link retry} for a version that does not run a fallback effect.
-     *
      * **Example** (Falling back after retries are exhausted)
      *
      * ```ts
@@ -6299,6 +6406,7 @@ export declare const retryOrElse: {
      * // Network data
      * ```
      *
+     * @see {@link retry} for a version that does not run a fallback effect.
      * @category error handling
      * @since 2.0.0
      */
@@ -6306,6 +6414,11 @@ export declare const retryOrElse: {
     /**
      * Retries a failing effect and runs a fallback effect if retries are exhausted.
      *
+     * **When to use**
+     *
+     * This function is useful when you want to handle failures gracefully by
+     * specifying an alternative action after repeated failures.
+     *
      * **Details**
      *
      * The `Effect.retryOrElse` function attempts to retry a failing effect multiple
@@ -6314,13 +6427,6 @@ export declare const retryOrElse: {
      * If the retries are exhausted and the effect still fails, it runs a fallback
      * effect instead.
      *
-     * **When to Use**
-     *
-     * This function is useful when you want to handle failures gracefully by
-     * specifying an alternative action after repeated failures.
-     *
-     * @see {@link retry} for a version that does not run a fallback effect.
-     *
      * **Example** (Falling back after retries are exhausted)
      *
      * ```ts
@@ -6357,6 +6463,7 @@ export declare const retryOrElse: {
      * // Network data
      * ```
      *
+     * @see {@link retry} for a version that does not run a fallback effect.
      * @category error handling
      * @since 2.0.0
      */
@@ -6397,7 +6504,7 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
 /**
  * Discards both the success and failure values of an effect.
  *
- * **When to Use**
+ * **When to use**
  *
  * `ignore` allows you to run an effect without caring about its result, whether
  * it succeeds or fails. This is useful when you only care about the side
@@ -6447,6 +6554,8 @@ export declare const ignore: <Arg extends Effect<any, any, any> | {
 /**
  * Ignores the effect's failure cause, including defects and interruptions.
  *
+ * **Details**
+ *
  * Use the `log` option to emit the full {@link Cause} when the effect fails,
  * and `message` to prepend a custom log message.
  *
@@ -6478,6 +6587,8 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
  * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
  * until it succeeds or the plan is exhausted.
  *
+ * **Details**
+ *
  * Each attempt updates `ExecutionPlan.CurrentMetadata` (attempt and step index),
  * and retry timing is derived per step (the first attempt uses the remaining
  * attempts schedule; later retries apply the step schedule at least once).
@@ -6513,6 +6624,8 @@ export declare const withExecutionPlan: {
      * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
+     * **Details**
+     *
      * Each attempt updates `ExecutionPlan.CurrentMetadata` (attempt and step index),
      * and retry timing is derived per step (the first attempt uses the remaining
      * attempts schedule; later retries apply the step schedule at least once).
@@ -6553,6 +6666,8 @@ export declare const withExecutionPlan: {
      * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
+     * **Details**
+     *
      * Each attempt updates `ExecutionPlan.CurrentMetadata` (attempt and step index),
      * and retry timing is derived per step (the first attempt uses the remaining
      * attempts schedule; later retries apply the step schedule at least once).
@@ -6593,6 +6708,8 @@ export declare const withExecutionPlan: {
 /**
  * Runs an effect and reports any errors to the configured `ErrorReporter`s.
  *
+ * **Details**
+ *
  * If the `defectsOnly` option is set to `true`, only defects (unrecoverable
  * errors) will be reported, while regular failures will be ignored.
  *
@@ -6722,6 +6839,12 @@ export declare const orElseSucceed: {
  * Runs a sequence of effects and returns the result of the first successful
  * one.
  *
+ * **When to use**
+ *
+ * Use `firstSuccessOf` when you have prioritized fallback strategies, such as
+ * attempting multiple APIs, reading configuration from several sources, or
+ * trying alternative resource locations in order.
+ *
  * **Details**
  *
  * This function executes the provided effects in sequence, stopping at the
@@ -6732,12 +6855,6 @@ export declare const orElseSucceed: {
  * effect. If the collection is empty, the returned effect defects with an
  * `Error` whose message is `"Received an empty collection of effects"`.
  *
- * **When to Use**
- *
- * Use `firstSuccessOf` when you have prioritized fallback strategies, such as
- * attempting multiple APIs, reading configuration from several sources, or
- * trying alternative resource locations in order.
- *
  * **Example** (Trying alternatives until one succeeds)
  *
  * ```ts
@@ -6767,14 +6884,14 @@ export declare const firstSuccessOf: <Eff extends Effect<any, any, any>>(effects
  * Adds a time limit to an effect, triggering a timeout if the effect exceeds
  * the duration.
  *
+ * **Details**
+ *
  * The `timeout` function allows you to specify a time limit for an
  * effect's execution. If the effect does not complete within the given time, a
  * `TimeoutException` is raised. This can be useful for controlling how long
  * your program waits for a task to finish, ensuring that it doesn't hang
  * indefinitely if the task takes too long.
  *
- * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
- *
  * **Example** (Failing when work takes too long)
  *
  * ```ts
@@ -6805,6 +6922,7 @@ export declare const firstSuccessOf: <Eff extends Effect<any, any, any>>(effects
  * // }
  * ```
  *
+ * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
  * @category Delays & Timeouts
  * @since 2.0.0
  */
@@ -6813,14 +6931,14 @@ export declare const timeout: {
      * Adds a time limit to an effect, triggering a timeout if the effect exceeds
      * the duration.
      *
+     * **Details**
+     *
      * The `timeout` function allows you to specify a time limit for an
      * effect's execution. If the effect does not complete within the given time, a
      * `TimeoutException` is raised. This can be useful for controlling how long
      * your program waits for a task to finish, ensuring that it doesn't hang
      * indefinitely if the task takes too long.
      *
-     * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
-     *
      * **Example** (Failing when work takes too long)
      *
      * ```ts
@@ -6851,6 +6969,7 @@ export declare const timeout: {
      * // }
      * ```
      *
+     * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      * @category Delays & Timeouts
      * @since 2.0.0
      */
@@ -6859,14 +6978,14 @@ export declare const timeout: {
      * Adds a time limit to an effect, triggering a timeout if the effect exceeds
      * the duration.
      *
+     * **Details**
+     *
      * The `timeout` function allows you to specify a time limit for an
      * effect's execution. If the effect does not complete within the given time, a
      * `TimeoutException` is raised. This can be useful for controlling how long
      * your program waits for a task to finish, ensuring that it doesn't hang
      * indefinitely if the task takes too long.
      *
-     * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
-     *
      * **Example** (Failing when work takes too long)
      *
      * ```ts
@@ -6897,6 +7016,7 @@ export declare const timeout: {
      * // }
      * ```
      *
+     * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      * @category Delays & Timeouts
      * @since 2.0.0
      */
@@ -7044,6 +7164,8 @@ export declare const timeoutOption: {
 /**
  * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
  *
+ * **Details**
+ *
  * This function is useful when you want to set a maximum duration for an operation
  * and provide an alternative action if the timeout is exceeded.
  *
@@ -7082,6 +7204,8 @@ export declare const timeoutOrElse: {
     /**
      * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
      *
+     * **Details**
+     *
      * This function is useful when you want to set a maximum duration for an operation
      * and provide an alternative action if the timeout is exceeded.
      *
@@ -7123,6 +7247,8 @@ export declare const timeoutOrElse: {
     /**
      * Applies a timeout to an effect, with a fallback effect executed if the timeout is reached.
      *
+     * **Details**
+     *
      * This function is useful when you want to set a maximum duration for an operation
      * and provide an alternative action if the timeout is exceeded.
      *
@@ -7256,6 +7382,8 @@ export declare const sleep: (duration: Duration.Input) => Effect<void>;
 /**
  * Measures the runtime of an effect and returns the duration with its result.
  *
+ * **Details**
+ *
  * The original success, failure, or interruption is preserved; only the success
  * value is paired with the duration.
  *
@@ -7277,6 +7405,11 @@ export declare const timed: <A, E, R>(self: Effect<A, E, R>) => Effect<[duration
 /**
  * Runs multiple effects concurrently and returns the first successful result.
  *
+ * **When to use**
+ *
+ * Use `raceAll` when early failures should be ignored until a success occurs
+ * or all effects fail.
+ *
  * **Details**
  *
  * Early failures do not finish the race; `raceAll` keeps waiting until one
@@ -7284,13 +7417,6 @@ export declare const timed: <A, E, R>(self: Effect<A, E, R>) => Effect<[duration
  * remaining effects are interrupted. If every effect fails, the returned effect
  * fails with a cause containing the collected failure reasons.
  *
- * **When to Use**
- *
- * Use `raceAll` when early failures should be ignored until a success occurs
- * or all effects fail.
- *
- * @see {@link race} for a version that handles only two effects.
- *
  * **Example** (Racing many effects)
  *
  * ```ts
@@ -7307,6 +7433,7 @@ export declare const timed: <A, E, R>(self: Effect<A, E, R>) => Effect<[duration
  * // Result: "Fast" (after ~100ms)
  * ```
  *
+ * @see {@link race} for a version that handles only two effects.
  * @category Racing
  * @since 2.0.0
  */
@@ -7356,6 +7483,8 @@ export declare const raceAllFirst: <Eff extends Effect<any, any, any>>(all: Iter
 /**
  * Races two effects and returns the first successful result.
  *
+ * **Details**
+ *
  * If one effect succeeds, the other is interrupted and `onWinner` can observe the
  * winning fiber. If both fail, the race fails.
  *
@@ -7383,6 +7512,8 @@ export declare const race: {
     /**
      * Races two effects and returns the first successful result.
      *
+     * **Details**
+     *
      * If one effect succeeds, the other is interrupted and `onWinner` can observe the
      * winning fiber. If both fail, the race fails.
      *
@@ -7416,6 +7547,8 @@ export declare const race: {
     /**
      * Races two effects and returns the first successful result.
      *
+     * **Details**
+     *
      * If one effect succeeds, the other is interrupted and `onWinner` can observe the
      * winning fiber. If both fail, the race fails.
      *
@@ -7451,6 +7584,8 @@ export declare const race: {
  * Races two effects and returns the result of the first one to complete, whether
  * it succeeds or fails.
  *
+ * **Details**
+ *
  * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
  *
  * **Example** (Observing the winning fiber)
@@ -7481,6 +7616,8 @@ export declare const raceFirst: {
      * Races two effects and returns the result of the first one to complete, whether
      * it succeeds or fails.
      *
+     * **Details**
+     *
      * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
      *
      * **Example** (Observing the winning fiber)
@@ -7517,6 +7654,8 @@ export declare const raceFirst: {
      * Races two effects and returns the result of the first one to complete, whether
      * it succeeds or fails.
      *
+     * **Details**
+     *
      * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
      *
      * **Example** (Observing the winning fiber)
@@ -8260,6 +8399,11 @@ export declare const filterMapOrFail: {
  * Conditionally runs an effect based on the result of an effectful boolean
  * condition.
  *
+ * **When to use**
+ *
+ * Use this when an effectful check decides whether to run another effect while
+ * representing the skipped case explicitly.
+ *
  * **Details**
  *
  * The condition effect is evaluated first. If it succeeds with `true`, the
@@ -8267,11 +8411,6 @@ export declare const filterMapOrFail: {
  * succeeds with `false`, the source effect is skipped and the result is
  * `Option.none`. If the condition effect fails, that failure is preserved.
  *
- * **When to Use**
- *
- * Use this when an effectful check decides whether to run another effect while
- * representing the skipped case explicitly.
- *
  * **Example** (Conditionally running an effect)
  *
  * ```ts
@@ -8290,7 +8429,6 @@ export declare const filterMapOrFail: {
  * ```
  *
  * @see {@link when} for conditional execution with a boolean condition.
- *
  * @category Conditional Operators
  * @since 2.0.0
  */
@@ -8299,6 +8437,11 @@ export declare const when: {
      * Conditionally runs an effect based on the result of an effectful boolean
      * condition.
      *
+     * **When to use**
+     *
+     * Use this when an effectful check decides whether to run another effect while
+     * representing the skipped case explicitly.
+     *
      * **Details**
      *
      * The condition effect is evaluated first. If it succeeds with `true`, the
@@ -8306,11 +8449,6 @@ export declare const when: {
      * succeeds with `false`, the source effect is skipped and the result is
      * `Option.none`. If the condition effect fails, that failure is preserved.
      *
-     * **When to Use**
-     *
-     * Use this when an effectful check decides whether to run another effect while
-     * representing the skipped case explicitly.
-     *
      * **Example** (Conditionally running an effect)
      *
      * ```ts
@@ -8329,7 +8467,6 @@ export declare const when: {
      * ```
      *
      * @see {@link when} for conditional execution with a boolean condition.
-     *
      * @category Conditional Operators
      * @since 2.0.0
      */
@@ -8338,6 +8475,11 @@ export declare const when: {
      * Conditionally runs an effect based on the result of an effectful boolean
      * condition.
      *
+     * **When to use**
+     *
+     * Use this when an effectful check decides whether to run another effect while
+     * representing the skipped case explicitly.
+     *
      * **Details**
      *
      * The condition effect is evaluated first. If it succeeds with `true`, the
@@ -8345,11 +8487,6 @@ export declare const when: {
      * succeeds with `false`, the source effect is skipped and the result is
      * `Option.none`. If the condition effect fails, that failure is preserved.
      *
-     * **When to Use**
-     *
-     * Use this when an effectful check decides whether to run another effect while
-     * representing the skipped case explicitly.
-     *
      * **Example** (Conditionally running an effect)
      *
      * ```ts
@@ -8368,7 +8505,6 @@ export declare const when: {
      * ```
      *
      * @see {@link when} for conditional execution with a boolean condition.
-     *
      * @category Conditional Operators
      * @since 2.0.0
      */
@@ -8378,6 +8514,11 @@ export declare const when: {
  * Handles both success and failure cases of an effect without performing side
  * effects.
  *
+ * **When to use**
+ *
+ * This is useful for structuring your code to respond differently to success or
+ * failure without triggering side effects.
+ *
  * **Details**
  *
  * `match` lets you define custom handlers for both success and failure
@@ -8385,13 +8526,6 @@ export declare const when: {
  * to process the result if the effect succeeds, or handle the error if the
  * effect fails.
  *
- * **When to Use**
- *
- * This is useful for structuring your code to respond differently to success or
- * failure without triggering side effects.
- *
- * @see {@link matchEffect} if you need to perform side effects in the handlers.
- *
  * **Example** (Matching success and failure values)
  *
  * ```ts
@@ -8424,6 +8558,7 @@ export declare const when: {
  * // Output: "failure: Uh oh!"
  * ```
  *
+ * @see {@link matchEffect} if you need to perform side effects in the handlers.
  * @category Pattern Matching
  * @since 2.0.0
  */
@@ -8432,6 +8567,11 @@ export declare const match: {
      * Handles both success and failure cases of an effect without performing side
      * effects.
      *
+     * **When to use**
+     *
+     * This is useful for structuring your code to respond differently to success or
+     * failure without triggering side effects.
+     *
      * **Details**
      *
      * `match` lets you define custom handlers for both success and failure
@@ -8439,14 +8579,7 @@ export declare const match: {
      * to process the result if the effect succeeds, or handle the error if the
      * effect fails.
      *
-     * **When to Use**
-     *
-     * This is useful for structuring your code to respond differently to success or
-     * failure without triggering side effects.
-     *
-     * @see {@link matchEffect} if you need to perform side effects in the handlers.
-     *
-     * **Example** (Matching success and failure values)
+     * **Example** (Matching success and failure values)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -8478,6 +8611,7 @@ export declare const match: {
      * // Output: "failure: Uh oh!"
      * ```
      *
+     * @see {@link matchEffect} if you need to perform side effects in the handlers.
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -8489,6 +8623,11 @@ export declare const match: {
      * Handles both success and failure cases of an effect without performing side
      * effects.
      *
+     * **When to use**
+     *
+     * This is useful for structuring your code to respond differently to success or
+     * failure without triggering side effects.
+     *
      * **Details**
      *
      * `match` lets you define custom handlers for both success and failure
@@ -8496,13 +8635,6 @@ export declare const match: {
      * to process the result if the effect succeeds, or handle the error if the
      * effect fails.
      *
-     * **When to Use**
-     *
-     * This is useful for structuring your code to respond differently to success or
-     * failure without triggering side effects.
-     *
-     * @see {@link matchEffect} if you need to perform side effects in the handlers.
-     *
      * **Example** (Matching success and failure values)
      *
      * ```ts
@@ -8535,6 +8667,7 @@ export declare const match: {
      * // Output: "failure: Uh oh!"
      * ```
      *
+     * @see {@link matchEffect} if you need to perform side effects in the handlers.
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -8547,6 +8680,12 @@ export declare const match: {
  * Handles both success and failure cases of an effect without performing side
  * effects, with eager evaluation for resolved effects.
  *
+ * **When to use**
+ *
+ * Use this when you need to handle both success and failure cases and want
+ * optimal performance for resolved effects. This is particularly useful in
+ * scenarios where you frequently work with already computed values.
+ *
  * **Details**
  *
  * `matchEager` works like `match` but provides better performance for resolved
@@ -8554,12 +8693,6 @@ export declare const match: {
  * the handlers immediately without fiber scheduling. For unresolved effects,
  * it falls back to the regular `match` behavior.
  *
- * **When to Use**
- *
- * Use this when you need to handle both success and failure cases and want
- * optimal performance for resolved effects. This is particularly useful in
- * scenarios where you frequently work with already computed values.
- *
  * **Example** (Pattern matching eagerly when possible)
  *
  * ```ts
@@ -8576,7 +8709,6 @@ export declare const match: {
  *
  * @see {@link match} for the non-eager version.
  * @see {@link matchEffect} if you need to perform side effects in the handlers.
- *
  * @category Pattern Matching
  * @since 4.0.0
  */
@@ -8585,6 +8717,12 @@ export declare const matchEager: {
      * Handles both success and failure cases of an effect without performing side
      * effects, with eager evaluation for resolved effects.
      *
+     * **When to use**
+     *
+     * Use this when you need to handle both success and failure cases and want
+     * optimal performance for resolved effects. This is particularly useful in
+     * scenarios where you frequently work with already computed values.
+     *
      * **Details**
      *
      * `matchEager` works like `match` but provides better performance for resolved
@@ -8592,12 +8730,6 @@ export declare const matchEager: {
      * the handlers immediately without fiber scheduling. For unresolved effects,
      * it falls back to the regular `match` behavior.
      *
-     * **When to Use**
-     *
-     * Use this when you need to handle both success and failure cases and want
-     * optimal performance for resolved effects. This is particularly useful in
-     * scenarios where you frequently work with already computed values.
-     *
      * **Example** (Pattern matching eagerly when possible)
      *
      * ```ts
@@ -8614,7 +8746,6 @@ export declare const matchEager: {
      *
      * @see {@link match} for the non-eager version.
      * @see {@link matchEffect} if you need to perform side effects in the handlers.
-     *
      * @category Pattern Matching
      * @since 4.0.0
      */
@@ -8626,6 +8757,12 @@ export declare const matchEager: {
      * Handles both success and failure cases of an effect without performing side
      * effects, with eager evaluation for resolved effects.
      *
+     * **When to use**
+     *
+     * Use this when you need to handle both success and failure cases and want
+     * optimal performance for resolved effects. This is particularly useful in
+     * scenarios where you frequently work with already computed values.
+     *
      * **Details**
      *
      * `matchEager` works like `match` but provides better performance for resolved
@@ -8633,12 +8770,6 @@ export declare const matchEager: {
      * the handlers immediately without fiber scheduling. For unresolved effects,
      * it falls back to the regular `match` behavior.
      *
-     * **When to Use**
-     *
-     * Use this when you need to handle both success and failure cases and want
-     * optimal performance for resolved effects. This is particularly useful in
-     * scenarios where you frequently work with already computed values.
-     *
      * **Example** (Pattern matching eagerly when possible)
      *
      * ```ts
@@ -8655,7 +8786,6 @@ export declare const matchEager: {
      *
      * @see {@link match} for the non-eager version.
      * @see {@link matchEffect} if you need to perform side effects in the handlers.
-     *
      * @category Pattern Matching
      * @since 4.0.0
      */
@@ -8667,17 +8797,17 @@ export declare const matchEager: {
 /**
  * Handles failures by matching the cause of failure.
  *
- * **Details**
- *
- * The `matchCause` function allows you to handle failures with access to the
- * full cause of the failure within a fiber.
- *
- * **When to Use**
+ * **When to use**
  *
  * This is useful for differentiating between different types of errors, such as
  * regular failures, defects, or interruptions. You can provide specific
  * handling logic for each failure type based on the cause.
  *
+ * **Details**
+ *
+ * The `matchCause` function allows you to handle failures with access to the
+ * full cause of the failure within a fiber.
+ *
  * **Example** (Matching on success or failure causes)
  *
  * ```ts
@@ -8697,7 +8827,6 @@ export declare const matchEager: {
  * @see {@link matchCauseEffect} if you need to perform side effects in the
  * handlers.
  * @see {@link match} if you don't need to handle the cause of the failure.
- *
  * @category Pattern Matching
  * @since 2.0.0
  */
@@ -8705,17 +8834,17 @@ export declare const matchCause: {
     /**
      * Handles failures by matching the cause of failure.
      *
-     * **Details**
-     *
-     * The `matchCause` function allows you to handle failures with access to the
-     * full cause of the failure within a fiber.
-     *
-     * **When to Use**
+     * **When to use**
      *
      * This is useful for differentiating between different types of errors, such as
      * regular failures, defects, or interruptions. You can provide specific
      * handling logic for each failure type based on the cause.
      *
+     * **Details**
+     *
+     * The `matchCause` function allows you to handle failures with access to the
+     * full cause of the failure within a fiber.
+     *
      * **Example** (Matching on success or failure causes)
      *
      * ```ts
@@ -8735,7 +8864,6 @@ export declare const matchCause: {
      * @see {@link matchCauseEffect} if you need to perform side effects in the
      * handlers.
      * @see {@link match} if you don't need to handle the cause of the failure.
-     *
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -8746,17 +8874,17 @@ export declare const matchCause: {
     /**
      * Handles failures by matching the cause of failure.
      *
-     * **Details**
-     *
-     * The `matchCause` function allows you to handle failures with access to the
-     * full cause of the failure within a fiber.
-     *
-     * **When to Use**
+     * **When to use**
      *
      * This is useful for differentiating between different types of errors, such as
      * regular failures, defects, or interruptions. You can provide specific
      * handling logic for each failure type based on the cause.
      *
+     * **Details**
+     *
+     * The `matchCause` function allows you to handle failures with access to the
+     * full cause of the failure within a fiber.
+     *
      * **Example** (Matching on success or failure causes)
      *
      * ```ts
@@ -8776,7 +8904,6 @@ export declare const matchCause: {
      * @see {@link matchCauseEffect} if you need to perform side effects in the
      * handlers.
      * @see {@link match} if you don't need to handle the cause of the failure.
-     *
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -8788,18 +8915,18 @@ export declare const matchCause: {
 /**
  * Handles failures by matching the cause of failure with eager evaluation.
  *
+ * **When to use**
+ *
+ * This is useful when you have effects that are likely to be already resolved
+ * and you want to avoid the overhead of the effect pipeline. For pending effects,
+ * it automatically falls back to the regular `matchCause` behavior.
+ *
  * **Details**
  *
  * `matchCauseEager` works like `matchCause` but provides better performance for resolved
  * effects by immediately applying the matching function instead of deferring it
  * through the effect pipeline.
  *
- * **When to Use**
- *
- * This is useful when you have effects that are likely to be already resolved
- * and you want to avoid the overhead of the effect pipeline. For pending effects,
- * it automatically falls back to the regular `matchCause` behavior.
- *
  * **Example** (Eagerly matching already completed effects)
  *
  * ```ts
@@ -8818,18 +8945,18 @@ export declare const matchCauseEager: {
     /**
      * Handles failures by matching the cause of failure with eager evaluation.
      *
+     * **When to use**
+     *
+     * This is useful when you have effects that are likely to be already resolved
+     * and you want to avoid the overhead of the effect pipeline. For pending effects,
+     * it automatically falls back to the regular `matchCause` behavior.
+     *
      * **Details**
      *
      * `matchCauseEager` works like `matchCause` but provides better performance for resolved
      * effects by immediately applying the matching function instead of deferring it
      * through the effect pipeline.
      *
-     * **When to Use**
-     *
-     * This is useful when you have effects that are likely to be already resolved
-     * and you want to avoid the overhead of the effect pipeline. For pending effects,
-     * it automatically falls back to the regular `matchCause` behavior.
-     *
      * **Example** (Eagerly matching already completed effects)
      *
      * ```ts
@@ -8851,18 +8978,18 @@ export declare const matchCauseEager: {
     /**
      * Handles failures by matching the cause of failure with eager evaluation.
      *
+     * **When to use**
+     *
+     * This is useful when you have effects that are likely to be already resolved
+     * and you want to avoid the overhead of the effect pipeline. For pending effects,
+     * it automatically falls back to the regular `matchCause` behavior.
+     *
      * **Details**
      *
      * `matchCauseEager` works like `matchCause` but provides better performance for resolved
      * effects by immediately applying the matching function instead of deferring it
      * through the effect pipeline.
      *
-     * **When to Use**
-     *
-     * This is useful when you have effects that are likely to be already resolved
-     * and you want to avoid the overhead of the effect pipeline. For pending effects,
-     * it automatically falls back to the regular `matchCause` behavior.
-     *
      * **Example** (Eagerly matching already completed effects)
      *
      * ```ts
@@ -8885,6 +9012,8 @@ export declare const matchCauseEager: {
 /**
  * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
  *
+ * **Details**
+ *
  * If the effect is an `Exit`, the matching handler runs immediately; otherwise it behaves like
  * {@link matchCauseEffect}.
  *
@@ -8895,6 +9024,8 @@ export declare const matchCauseEffectEager: {
     /**
      * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
      *
+     * **Details**
+     *
      * If the effect is an `Exit`, the matching handler runs immediately; otherwise it behaves like
      * {@link matchCauseEffect}.
      *
@@ -8908,6 +9039,8 @@ export declare const matchCauseEffectEager: {
     /**
      * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
      *
+     * **Details**
+     *
      * If the effect is an `Exit`, the matching handler runs immediately; otherwise it behaves like
      * {@link matchCauseEffect}.
      *
@@ -9094,19 +9227,16 @@ export declare const matchCauseEffect: {
 /**
  * Handles both success and failure by running effectful handlers.
  *
+ * **When to use**
+ *
+ * Use this when the failure or success branch must run additional effects.
+ *
  * **Details**
  *
  * Use `matchEffect` when either branch needs to return an `Effect`, such as
  * performing logging, recovery, notification, or other effectful work. The
  * returned effect succeeds or fails according to the handler that is run.
  *
- * **When to Use**
- *
- * Use this when the failure or success branch must run additional effects.
- *
- * @see {@link match} if you don't need side effects and only want to handle the
- * result or failure.
- *
  * **Example** (Matching success and failure with effectful handlers)
  *
  * ```ts
@@ -9148,6 +9278,8 @@ export declare const matchCauseEffect: {
  * // failure: Uh oh!
  * ```
  *
+ * @see {@link match} if you don't need side effects and only want to handle the
+ * result or failure.
  * @category Pattern Matching
  * @since 2.0.0
  */
@@ -9155,19 +9287,16 @@ export declare const matchEffect: {
     /**
      * Handles both success and failure by running effectful handlers.
      *
+     * **When to use**
+     *
+     * Use this when the failure or success branch must run additional effects.
+     *
      * **Details**
      *
      * Use `matchEffect` when either branch needs to return an `Effect`, such as
      * performing logging, recovery, notification, or other effectful work. The
      * returned effect succeeds or fails according to the handler that is run.
      *
-     * **When to Use**
-     *
-     * Use this when the failure or success branch must run additional effects.
-     *
-     * @see {@link match} if you don't need side effects and only want to handle the
-     * result or failure.
-     *
      * **Example** (Matching success and failure with effectful handlers)
      *
      * ```ts
@@ -9209,6 +9338,8 @@ export declare const matchEffect: {
      * // failure: Uh oh!
      * ```
      *
+     * @see {@link match} if you don't need side effects and only want to handle the
+     * result or failure.
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -9219,19 +9350,16 @@ export declare const matchEffect: {
     /**
      * Handles both success and failure by running effectful handlers.
      *
+     * **When to use**
+     *
+     * Use this when the failure or success branch must run additional effects.
+     *
      * **Details**
      *
      * Use `matchEffect` when either branch needs to return an `Effect`, such as
      * performing logging, recovery, notification, or other effectful work. The
      * returned effect succeeds or fails according to the handler that is run.
      *
-     * **When to Use**
-     *
-     * Use this when the failure or success branch must run additional effects.
-     *
-     * @see {@link match} if you don't need side effects and only want to handle the
-     * result or failure.
-     *
      * **Example** (Matching success and failure with effectful handlers)
      *
      * ```ts
@@ -9273,6 +9401,8 @@ export declare const matchEffect: {
      * // failure: Uh oh!
      * ```
      *
+     * @see {@link match} if you don't need side effects and only want to handle the
+     * result or failure.
      * @category Pattern Matching
      * @since 2.0.0
      */
@@ -9284,6 +9414,8 @@ export declare const matchEffect: {
 /**
  * Determines whether an effect fails.
  *
+ * **Details**
+ *
  * Defects are not converted; if the effect dies, the resulting effect dies too.
  *
  * **Example** (Checking whether an effect fails)
@@ -9307,6 +9439,8 @@ export declare const isFailure: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
 /**
  * Returns whether an effect completes successfully.
  *
+ * **Details**
+ *
  * Returns `false` for failures in the error channel, but defects still fail the
  * effect.
  *
@@ -9335,6 +9469,8 @@ export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
 /**
  * Returns the complete context.
  *
+ * **Details**
+ *
  * This function allows you to access all services that are currently available
  * in the effect's environment. This can be useful for debugging, introspection,
  * or when you need to pass the entire context to another function.
@@ -9375,6 +9511,8 @@ export declare const context: <R = never>() => Effect<Context.Context<R>, never,
 /**
  * Transforms the current context using the provided function.
  *
+ * **Details**
+ *
  * This function allows you to access the complete context and perform
  * computations based on all available services. This is useful when you need
  * to conditionally execute logic based on what services are available.
@@ -9987,6 +10125,8 @@ export declare const updateContext: {
  * Runs an effect with a service implementation transformed by the provided
  * function.
  *
+ * **Details**
+ *
  * The service must be available in the effect's context; `updateService`
  * replaces it for the wrapped effect with the value returned by the updater.
  *
@@ -10021,6 +10161,8 @@ export declare const updateService: {
      * Runs an effect with a service implementation transformed by the provided
      * function.
      *
+     * **Details**
+     *
      * The service must be available in the effect's context; `updateService`
      * replaces it for the wrapped effect with the value returned by the updater.
      *
@@ -10055,6 +10197,8 @@ export declare const updateService: {
      * Runs an effect with a service implementation transformed by the provided
      * function.
      *
+     * **Details**
+     *
      * The service must be available in the effect's context; `updateService`
      * replaces it for the wrapped effect with the value returned by the updater.
      *
@@ -10090,14 +10234,14 @@ export declare const updateService: {
  * The `provideService` function is used to provide an actual
  * implementation for a service in the context of an effect.
  *
+ * **Details**
+ *
  * This function allows you to associate a service with its implementation so
  * that it can be used in your program. You define the service (e.g., a random
  * number generator), and then you use `provideService` to link that
  * service to its implementation. Once the implementation is provided, the
  * effect can be run successfully without further requirements.
  *
- * @see {@link provide} for providing multiple layers to an effect.
- *
  * **Example** (Providing a service value)
  *
  * ```ts
@@ -10129,6 +10273,7 @@ export declare const updateService: {
  * // data
  * ```
  *
+ * @see {@link provide} for providing multiple layers to an effect.
  * @category Context
  * @since 2.0.0
  */
@@ -10137,14 +10282,14 @@ export declare const provideService: {
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
      *
+     * **Details**
+     *
      * This function allows you to associate a service with its implementation so
      * that it can be used in your program. You define the service (e.g., a random
      * number generator), and then you use `provideService` to link that
      * service to its implementation. Once the implementation is provided, the
      * effect can be run successfully without further requirements.
      *
-     * @see {@link provide} for providing multiple layers to an effect.
-     *
      * **Example** (Providing a service value)
      *
      * ```ts
@@ -10176,6 +10321,7 @@ export declare const provideService: {
      * // data
      * ```
      *
+     * @see {@link provide} for providing multiple layers to an effect.
      * @category Context
      * @since 2.0.0
      */
@@ -10184,14 +10330,14 @@ export declare const provideService: {
          * The `provideService` function is used to provide an actual
          * implementation for a service in the context of an effect.
          *
+         * **Details**
+         *
          * This function allows you to associate a service with its implementation so
          * that it can be used in your program. You define the service (e.g., a random
          * number generator), and then you use `provideService` to link that
          * service to its implementation. Once the implementation is provided, the
          * effect can be run successfully without further requirements.
          *
-         * @see {@link provide} for providing multiple layers to an effect.
-         *
          * **Example** (Providing a service value)
          *
          * ```ts
@@ -10223,6 +10369,7 @@ export declare const provideService: {
          * // data
          * ```
          *
+         * @see {@link provide} for providing multiple layers to an effect.
          * @category Context
          * @since 2.0.0
          */
@@ -10231,14 +10378,14 @@ export declare const provideService: {
          * The `provideService` function is used to provide an actual
          * implementation for a service in the context of an effect.
          *
+         * **Details**
+         *
          * This function allows you to associate a service with its implementation so
          * that it can be used in your program. You define the service (e.g., a random
          * number generator), and then you use `provideService` to link that
          * service to its implementation. Once the implementation is provided, the
          * effect can be run successfully without further requirements.
          *
-         * @see {@link provide} for providing multiple layers to an effect.
-         *
          * **Example** (Providing a service value)
          *
          * ```ts
@@ -10270,6 +10417,7 @@ export declare const provideService: {
          * // data
          * ```
          *
+         * @see {@link provide} for providing multiple layers to an effect.
          * @category Context
          * @since 2.0.0
          */
@@ -10279,14 +10427,14 @@ export declare const provideService: {
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
      *
+     * **Details**
+     *
      * This function allows you to associate a service with its implementation so
      * that it can be used in your program. You define the service (e.g., a random
      * number generator), and then you use `provideService` to link that
      * service to its implementation. Once the implementation is provided, the
      * effect can be run successfully without further requirements.
      *
-     * @see {@link provide} for providing multiple layers to an effect.
-     *
      * **Example** (Providing a service value)
      *
      * ```ts
@@ -10318,6 +10466,7 @@ export declare const provideService: {
      * // data
      * ```
      *
+     * @see {@link provide} for providing multiple layers to an effect.
      * @category Context
      * @since 2.0.0
      */
@@ -10326,14 +10475,14 @@ export declare const provideService: {
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
      *
+     * **Details**
+     *
      * This function allows you to associate a service with its implementation so
      * that it can be used in your program. You define the service (e.g., a random
      * number generator), and then you use `provideService` to link that
      * service to its implementation. Once the implementation is provided, the
      * effect can be run successfully without further requirements.
      *
-     * @see {@link provide} for providing multiple layers to an effect.
-     *
      * **Example** (Providing a service value)
      *
      * ```ts
@@ -10365,6 +10514,7 @@ export declare const provideService: {
      * // data
      * ```
      *
+     * @see {@link provide} for providing multiple layers to an effect.
      * @category Context
      * @since 2.0.0
      */
@@ -10800,6 +10950,8 @@ export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, rel
  * This function constructs a scoped resource from an Effect that acquires a
  * disposable value.
  *
+ * **Details**
+ *
  * The resource is automatically disposed when the surrounding
  * {@link Scope} is closed, using {@link Symbol.dispose} for
  * synchronous disposables or {@link Symbol.asyncDispose} for asynchronous
@@ -10809,8 +10961,6 @@ export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, rel
  * JavaScript disposal protocal instead of requiring an explicit release
  * function.
  *
- * @see [JavaScript `using` declarations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using)
- *
  * **Example** (Acquiring a disposable resource)
  *
  * ```ts
@@ -10831,6 +10981,7 @@ export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, rel
  * )
  * ```
  *
+ * @see [JavaScript `using` declarations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/using)
  * @category resource management
  * @since 4.0.0
  */
@@ -10841,6 +10992,8 @@ export declare const acquireDisposable: <A extends AsyncDisposable | Disposable,
  * etc.) will not be interrupted, and that the resource will always be released
  * when the `Effect` value completes execution.
  *
+ * **Details**
+ *
  * `acquireUseRelease` does the following:
  *
  *   1. Ensures that the `Effect` value that acquires the resource will not be
@@ -10913,6 +11066,8 @@ export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acqu
  * The finalizer is guaranteed to be run when the scope is closed, and it may
  * depend on the `Exit` value that the scope is closed with.
  *
+ * **Details**
+ *
  * Finalizers are useful for cleanup operations that must run regardless of
  * whether the effect succeeds or fails. They're commonly used for resource
  * cleanup, logging, or other side effects that should always occur.
@@ -10956,6 +11111,8 @@ export declare const addFinalizer: <R>(finalizer: (exit: Exit.Exit<unknown, unkn
  * specified `finalizer` is guaranteed to be executed, whether this effect
  * succeeds, fails, or is interrupted.
  *
+ * **Details**
+ *
  * For use cases that need access to the effect's result, see `onExit`.
  *
  * Finalizers offer very powerful guarantees, but they are low-level, and
@@ -10997,6 +11154,8 @@ export declare const ensuring: {
      * specified `finalizer` is guaranteed to be executed, whether this effect
      * succeeds, fails, or is interrupted.
      *
+     * **Details**
+     *
      * For use cases that need access to the effect's result, see `onExit`.
      *
      * Finalizers offer very powerful guarantees, but they are low-level, and
@@ -11038,6 +11197,8 @@ export declare const ensuring: {
      * specified `finalizer` is guaranteed to be executed, whether this effect
      * succeeds, fails, or is interrupted.
      *
+     * **Details**
+     *
      * For use cases that need access to the effect's result, see `onExit`.
      *
      * Finalizers offer very powerful guarantees, but they are low-level, and
@@ -11452,24 +11613,19 @@ export declare const onExitFilter: {
  * Returns an effect that lazily computes a result and caches it for subsequent
  * evaluations.
  *
- * **Details**
- *
- * This function wraps an effect and ensures that its result is computed only
- * once. Once the result is computed, it is cached, meaning that subsequent
- * evaluations of the same effect will return the cached result without
- * re-executing the logic.
- *
- * **When to Use**
+ * **When to use**
  *
  * Use this function when you have an expensive or time-consuming operation that
  * you want to avoid repeating. The first evaluation will compute the result,
  * and all following evaluations will immediately return the cached value,
  * improving performance and reducing unnecessary work.
  *
- * @see {@link cachedWithTTL} for a similar function that includes a
- * time-to-live duration for the cached value.
- * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
- * additional effect for manually invalidating the cached value.
+ * **Details**
+ *
+ * This function wraps an effect and ensures that its result is computed only
+ * once. Once the result is computed, it is cached, meaning that subsequent
+ * evaluations of the same effect will return the cached result without
+ * re-executing the logic.
  *
  * **Example** (Memoizing an effect until invalidated)
  *
@@ -11509,6 +11665,10 @@ export declare const onExitFilter: {
  * // result 3
  * ```
  *
+ * @see {@link cachedWithTTL} for a similar function that includes a
+ * time-to-live duration for the cached value.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
  * @category Caching
  * @since 2.0.0
  */
@@ -11517,6 +11677,17 @@ export declare const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A
  * Returns an effect that caches its result for a specified `Duration`,
  * known as "timeToLive" (TTL).
  *
+ * **When to use**
+ *
+ * Use this function when you have an effect that involves costly operations or
+ * computations, and you want to avoid repeating them within a short time frame.
+ *
+ * It's ideal for scenarios where the result of an effect doesn't change
+ * frequently and can be reused for a specified duration.
+ *
+ * By caching the result, you can improve efficiency and reduce unnecessary
+ * computations, especially in performance-critical applications.
+ *
  * **Details**
  *
  * This function is used to cache the result of an effect for a specified amount
@@ -11529,22 +11700,6 @@ export declare const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A
  * After the specified duration has passed, the cache expires, and the effect
  * will be recomputed upon the next evaluation.
  *
- * **When to Use**
- *
- * Use this function when you have an effect that involves costly operations or
- * computations, and you want to avoid repeating them within a short time frame.
- *
- * It's ideal for scenarios where the result of an effect doesn't change
- * frequently and can be reused for a specified duration.
- *
- * By caching the result, you can improve efficiency and reduce unnecessary
- * computations, especially in performance-critical applications.
- *
- * @see {@link cached} for a similar function that caches the result
- * indefinitely.
- * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
- * additional effect for manually invalidating the cached value.
- *
  * **Example** (Memoizing an effect with TTL)
  *
  * ```ts
@@ -11577,6 +11732,10 @@ export declare const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A
  * // result 2
  * ```
  *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
  * @category Caching
  * @since 2.0.0
  */
@@ -11585,6 +11744,17 @@ export declare const cachedWithTTL: {
      * Returns an effect that caches its result for a specified `Duration`,
      * known as "timeToLive" (TTL).
      *
+     * **When to use**
+     *
+     * Use this function when you have an effect that involves costly operations or
+     * computations, and you want to avoid repeating them within a short time frame.
+     *
+     * It's ideal for scenarios where the result of an effect doesn't change
+     * frequently and can be reused for a specified duration.
+     *
+     * By caching the result, you can improve efficiency and reduce unnecessary
+     * computations, especially in performance-critical applications.
+     *
      * **Details**
      *
      * This function is used to cache the result of an effect for a specified amount
@@ -11597,22 +11767,6 @@ export declare const cachedWithTTL: {
      * After the specified duration has passed, the cache expires, and the effect
      * will be recomputed upon the next evaluation.
      *
-     * **When to Use**
-     *
-     * Use this function when you have an effect that involves costly operations or
-     * computations, and you want to avoid repeating them within a short time frame.
-     *
-     * It's ideal for scenarios where the result of an effect doesn't change
-     * frequently and can be reused for a specified duration.
-     *
-     * By caching the result, you can improve efficiency and reduce unnecessary
-     * computations, especially in performance-critical applications.
-     *
-     * @see {@link cached} for a similar function that caches the result
-     * indefinitely.
-     * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
-     * additional effect for manually invalidating the cached value.
-     *
      * **Example** (Memoizing an effect with TTL)
      *
      * ```ts
@@ -11645,6 +11799,10 @@ export declare const cachedWithTTL: {
      * // result 2
      * ```
      *
+     * @see {@link cached} for a similar function that caches the result
+     * indefinitely.
+     * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+     * additional effect for manually invalidating the cached value.
      * @category Caching
      * @since 2.0.0
      */
@@ -11653,19 +11811,7 @@ export declare const cachedWithTTL: {
      * Returns an effect that caches its result for a specified `Duration`,
      * known as "timeToLive" (TTL).
      *
-     * **Details**
-     *
-     * This function is used to cache the result of an effect for a specified amount
-     * of time. This means that the first time the effect is evaluated, its result
-     * is computed and stored.
-     *
-     * If the effect is evaluated again within the specified `timeToLive`, the
-     * cached result will be used, avoiding recomputation.
-     *
-     * After the specified duration has passed, the cache expires, and the effect
-     * will be recomputed upon the next evaluation.
-     *
-     * **When to Use**
+     * **When to use**
      *
      * Use this function when you have an effect that involves costly operations or
      * computations, and you want to avoid repeating them within a short time frame.
@@ -11676,10 +11822,17 @@ export declare const cachedWithTTL: {
      * By caching the result, you can improve efficiency and reduce unnecessary
      * computations, especially in performance-critical applications.
      *
-     * @see {@link cached} for a similar function that caches the result
-     * indefinitely.
-     * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
-     * additional effect for manually invalidating the cached value.
+     * **Details**
+     *
+     * This function is used to cache the result of an effect for a specified amount
+     * of time. This means that the first time the effect is evaluated, its result
+     * is computed and stored.
+     *
+     * If the effect is evaluated again within the specified `timeToLive`, the
+     * cached result will be used, avoiding recomputation.
+     *
+     * After the specified duration has passed, the cache expires, and the effect
+     * will be recomputed upon the next evaluation.
      *
      * **Example** (Memoizing an effect with TTL)
      *
@@ -11713,6 +11866,10 @@ export declare const cachedWithTTL: {
      * // result 2
      * ```
      *
+     * @see {@link cached} for a similar function that caches the result
+     * indefinitely.
+     * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+     * additional effect for manually invalidating the cached value.
      * @category Caching
      * @since 2.0.0
      */
@@ -11722,6 +11879,16 @@ export declare const cachedWithTTL: {
  * Caches an effect's result for a specified duration and allows manual
  * invalidation before expiration.
  *
+ * **When to use**
+ *
+ * Use this function when you have an effect whose result needs to be cached for
+ * a certain period, but you also want the option to refresh the cache manually
+ * before the expiration time.
+ *
+ * This is useful when you need to ensure that the cached data remains valid for
+ * a certain period but still want to invalidate it if the underlying data
+ * changes or if you want to force a recomputation.
+ *
  * **Details**
  *
  * This function behaves similarly to {@link cachedWithTTL} by caching the
@@ -11735,21 +11902,6 @@ export declare const cachedWithTTL: {
  * Once the cache is invalidated, the next time the effect is evaluated, the
  * result will be recomputed, and the cache will be refreshed.
  *
- * **When to Use**
- *
- * Use this function when you have an effect whose result needs to be cached for
- * a certain period, but you also want the option to refresh the cache manually
- * before the expiration time.
- *
- * This is useful when you need to ensure that the cached data remains valid for
- * a certain period but still want to invalidate it if the underlying data
- * changes or if you want to force a recomputation.
- *
- * @see {@link cached} for a similar function that caches the result
- * indefinitely.
- * @see {@link cachedWithTTL} for a similar function that caches the result for
- * a specified duration but does not include an effect for manual invalidation.
- *
  * **Example** (Memoizing with TTL and invalidation)
  *
  * ```ts
@@ -11785,6 +11937,10 @@ export declare const cachedWithTTL: {
  * // result 2
  * ```
  *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedWithTTL} for a similar function that caches the result for
+ * a specified duration but does not include an effect for manual invalidation.
  * @category Caching
  * @since 2.0.0
  */
@@ -11793,6 +11949,16 @@ export declare const cachedInvalidateWithTTL: {
      * Caches an effect's result for a specified duration and allows manual
      * invalidation before expiration.
      *
+     * **When to use**
+     *
+     * Use this function when you have an effect whose result needs to be cached for
+     * a certain period, but you also want the option to refresh the cache manually
+     * before the expiration time.
+     *
+     * This is useful when you need to ensure that the cached data remains valid for
+     * a certain period but still want to invalidate it if the underlying data
+     * changes or if you want to force a recomputation.
+     *
      * **Details**
      *
      * This function behaves similarly to {@link cachedWithTTL} by caching the
@@ -11806,21 +11972,6 @@ export declare const cachedInvalidateWithTTL: {
      * Once the cache is invalidated, the next time the effect is evaluated, the
      * result will be recomputed, and the cache will be refreshed.
      *
-     * **When to Use**
-     *
-     * Use this function when you have an effect whose result needs to be cached for
-     * a certain period, but you also want the option to refresh the cache manually
-     * before the expiration time.
-     *
-     * This is useful when you need to ensure that the cached data remains valid for
-     * a certain period but still want to invalidate it if the underlying data
-     * changes or if you want to force a recomputation.
-     *
-     * @see {@link cached} for a similar function that caches the result
-     * indefinitely.
-     * @see {@link cachedWithTTL} for a similar function that caches the result for
-     * a specified duration but does not include an effect for manual invalidation.
-     *
      * **Example** (Memoizing with TTL and invalidation)
      *
      * ```ts
@@ -11856,6 +12007,10 @@ export declare const cachedInvalidateWithTTL: {
      * // result 2
      * ```
      *
+     * @see {@link cached} for a similar function that caches the result
+     * indefinitely.
+     * @see {@link cachedWithTTL} for a similar function that caches the result for
+     * a specified duration but does not include an effect for manual invalidation.
      * @category Caching
      * @since 2.0.0
      */
@@ -11864,6 +12019,16 @@ export declare const cachedInvalidateWithTTL: {
      * Caches an effect's result for a specified duration and allows manual
      * invalidation before expiration.
      *
+     * **When to use**
+     *
+     * Use this function when you have an effect whose result needs to be cached for
+     * a certain period, but you also want the option to refresh the cache manually
+     * before the expiration time.
+     *
+     * This is useful when you need to ensure that the cached data remains valid for
+     * a certain period but still want to invalidate it if the underlying data
+     * changes or if you want to force a recomputation.
+     *
      * **Details**
      *
      * This function behaves similarly to {@link cachedWithTTL} by caching the
@@ -11877,21 +12042,6 @@ export declare const cachedInvalidateWithTTL: {
      * Once the cache is invalidated, the next time the effect is evaluated, the
      * result will be recomputed, and the cache will be refreshed.
      *
-     * **When to Use**
-     *
-     * Use this function when you have an effect whose result needs to be cached for
-     * a certain period, but you also want the option to refresh the cache manually
-     * before the expiration time.
-     *
-     * This is useful when you need to ensure that the cached data remains valid for
-     * a certain period but still want to invalidate it if the underlying data
-     * changes or if you want to force a recomputation.
-     *
-     * @see {@link cached} for a similar function that caches the result
-     * indefinitely.
-     * @see {@link cachedWithTTL} for a similar function that caches the result for
-     * a specified duration but does not include an effect for manual invalidation.
-     *
      * **Example** (Memoizing with TTL and invalidation)
      *
      * ```ts
@@ -11927,6 +12077,10 @@ export declare const cachedInvalidateWithTTL: {
      * // result 2
      * ```
      *
+     * @see {@link cached} for a similar function that caches the result
+     * indefinitely.
+     * @see {@link cachedWithTTL} for a similar function that caches the result for
+     * a specified duration but does not include an effect for manual invalidation.
      * @category Caching
      * @since 2.0.0
      */
@@ -12813,6 +12967,8 @@ export declare const repeatOrElse: {
 /**
  * Returns an array of `n` identical effects.
  *
+ * **Details**
+ *
  * Use with `Effect.all` to run the replicated effects and collect results.
  *
  * @category Collecting
@@ -12822,6 +12978,8 @@ export declare const replicate: {
     /**
      * Returns an array of `n` identical effects.
      *
+     * **Details**
+     *
      * Use with `Effect.all` to run the replicated effects and collect results.
      *
      * @category Collecting
@@ -12831,6 +12989,8 @@ export declare const replicate: {
     /**
      * Returns an array of `n` identical effects.
      *
+     * **Details**
+     *
      * Use with `Effect.all` to run the replicated effects and collect results.
      *
      * @category Collecting
@@ -12841,6 +13001,8 @@ export declare const replicate: {
 /**
  * Performs this effect `n` times and collects results with `Effect.all` semantics.
  *
+ * **Details**
+ *
  * Use `concurrency` to control parallelism and `discard: true` to ignore results.
  *
  * **Example** (Replicating an effect)
@@ -12861,6 +13023,8 @@ export declare const replicateEffect: {
     /**
      * Performs this effect `n` times and collects results with `Effect.all` semantics.
      *
+     * **Details**
+     *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
      * **Example** (Replicating an effect)
@@ -12884,6 +13048,8 @@ export declare const replicateEffect: {
     /**
      * Performs this effect `n` times and collects results with `Effect.all` semantics.
      *
+     * **Details**
+     *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
      * **Example** (Replicating an effect)
@@ -12907,6 +13073,8 @@ export declare const replicateEffect: {
     /**
      * Performs this effect `n` times and collects results with `Effect.all` semantics.
      *
+     * **Details**
+     *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
      * **Example** (Replicating an effect)
@@ -12930,6 +13098,8 @@ export declare const replicateEffect: {
     /**
      * Performs this effect `n` times and collects results with `Effect.all` semantics.
      *
+     * **Details**
+     *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
      * **Example** (Replicating an effect)
@@ -13746,6 +13916,8 @@ export declare const spanLinks: Effect<ReadonlyArray<SpanLink>>;
 /**
  * For all spans in this effect, add a link with the provided span.
  *
+ * **Details**
+ *
  * This is useful for connecting spans that are related but not in a direct
  * parent-child relationship. For example, you might want to link spans from
  * parallel operations or connect spans across different traces.
@@ -13799,6 +13971,8 @@ export declare const linkSpans: {
     /**
      * For all spans in this effect, add a link with the provided span.
      *
+     * **Details**
+     *
      * This is useful for connecting spans that are related but not in a direct
      * parent-child relationship. For example, you might want to link spans from
      * parallel operations or connect spans across different traces.
@@ -13852,6 +14026,8 @@ export declare const linkSpans: {
     /**
      * For all spans in this effect, add a link with the provided span.
      *
+     * **Details**
+     *
      * This is useful for connecting spans that are related but not in a direct
      * parent-child relationship. For example, you might want to link spans from
      * parallel operations or connect spans across different traces.
@@ -13932,6 +14108,8 @@ export declare const makeSpan: (name: string, options?: SpanOptionsNoTrace) => E
  * Create a new span for tracing, and automatically close it when the Scope
  * finalizes.
  *
+ * **Details**
+ *
  * The span is not added to the current span stack, so no child spans will be
  * created for it.
  *
@@ -13958,6 +14136,8 @@ export declare const makeSpanScoped: (name: string, options?: SpanOptionsNoTrace
  * Create a new span for tracing, and automatically close it when the effect
  * completes.
  *
+ * **Details**
+ *
  * The span is not added to the current span stack, so no child spans will be
  * created for it.
  *
@@ -13984,6 +14164,8 @@ export declare const useSpan: {
      * Create a new span for tracing, and automatically close it when the effect
      * completes.
      *
+     * **Details**
+     *
      * The span is not added to the current span stack, so no child spans will be
      * created for it.
      *
@@ -14010,6 +14192,8 @@ export declare const useSpan: {
      * Create a new span for tracing, and automatically close it when the effect
      * completes.
      *
+     * **Details**
+     *
      * The span is not added to the current span stack, so no child spans will be
      * created for it.
      *
@@ -14103,6 +14287,8 @@ export declare const withSpan: {
 /**
  * Wraps the effect with a new span for tracing.
  *
+ * **Details**
+ *
  * The span is ended when the Scope is finalized.
  *
  * **Example** (Creating a scoped child span)
@@ -14126,6 +14312,8 @@ export declare const withSpanScoped: {
     /**
      * Wraps the effect with a new span for tracing.
      *
+     * **Details**
+     *
      * The span is ended when the Scope is finalized.
      *
      * **Example** (Creating a scoped child span)
@@ -14149,6 +14337,8 @@ export declare const withSpanScoped: {
     /**
      * Wraps the effect with a new span for tracing.
      *
+     * **Details**
+     *
      * The span is ended when the Scope is finalized.
      *
      * **Example** (Creating a scoped child span)
@@ -14332,6 +14522,8 @@ export declare const request: {
  * Low-level entry point that registers a request with a resolver and delivers the exit value via `onExit`.
  * Use this when you already have a `Context` and need to enqueue a request outside an `Effect`.
  *
+ * **Details**
+ *
  * It returns a canceler that removes the pending request entry.
  *
  * @category Requests & Batching
@@ -14347,6 +14539,8 @@ export declare const requestUnsafe: <A extends Request.Any>(self: A, options: {
  * returning the fiber immediately, without waiting for it to begin executing
  * the effect.
  *
+ * **Details**
+ *
  * You can use the `forkChild` method whenever you want to execute an effect in a
  * new fiber, concurrently and without "blocking" the fiber executing other
  * effects. Using fibers can be tricky, so instead of using this method
@@ -14645,7 +14839,7 @@ export interface RunOptions {
  * The foundational function for running effects, returning a "fiber" that can
  * be observed or interrupted.
  *
- * **When to Use**
+ * **When to use**
  *
  * `runFork` is used to run an effect in the background by creating a
  * fiber. It is the base function for all other run functions. It starts a fiber
@@ -14713,6 +14907,8 @@ export declare const runForkWith: <R>(context: Context.Context<R>) => <A, E>(eff
 /**
  * Forks an effect with the provided services, registers `onExit` as a fiber observer, and returns an interruptor.
  *
+ * **Details**
+ *
  * The returned interruptor calls `fiber.interruptUnsafe`, optionally with an interruptor id.
  *
  * **Example** (Running with services and a callback)
@@ -14758,6 +14954,8 @@ export declare const runCallbackWith: <R>(context: Context.Context<R>) => <A, E>
  * Runs an effect asynchronously, registering `onExit` as a fiber observer and
  * returning an interruptor.
  *
+ * **Details**
+ *
  * The interruptor calls `fiber.interruptUnsafe` with the optional interruptor
  * id.
  *
@@ -14798,7 +14996,7 @@ export declare const runCallback: <A, E>(effect: Effect<A, E, never>, options?:
 /**
  * Executes an effect and returns the result as a `Promise`.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `runPromise` when you need to execute an effect and work with the
  * result using `Promise` syntax, typically for compatibility with other
@@ -14807,8 +15005,6 @@ export declare const runCallback: <A, E>(effect: Effect<A, E, never>, options?:
  * If the effect succeeds, the promise will resolve with the result. If the
  * effect fails, the promise will reject with an error.
  *
- * @see {@link runPromiseExit} for a version that returns an `Exit` type instead of rejecting.
- *
  * **Example** (Running a successful effect as a Promise)
  *
  * ```ts
@@ -14829,6 +15025,7 @@ export declare const runCallback: <A, E>(effect: Effect<A, E, never>, options?:
  * // (FiberFailure) Error: my error
  * ```
  *
+ * @see {@link runPromiseExit} for a version that returns an `Exit` type instead of rejecting.
  * @category Running Effects
  * @since 2.0.0
  */
@@ -14867,7 +15064,7 @@ export declare const runPromiseWith: <R>(context: Context.Context<R>) => <A, E>(
  * Runs an effect and returns a `Promise` that resolves to an `Exit`, which
  * represents the outcome (success or failure) of the effect.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `runPromiseExit` when you need to determine if an effect succeeded
  * or failed, including any defects, and you want to work with a `Promise`.
@@ -14948,7 +15145,7 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
 /**
  * Executes an effect synchronously and returns its success value.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `runSync` only for effects that can complete synchronously.
  *
@@ -14958,9 +15155,6 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
  * `runSync` throws a `FiberFailure` instead of returning a value. Use
  * `runSyncExit` when you want the failure captured as an `Exit`.
  *
- * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
- * throwing an error.
- *
  * **Example** (Running a synchronous effect)
  *
  * ```ts
@@ -15002,6 +15196,8 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
  * // (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work
  * ```
  *
+ * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
+ * throwing an error.
  * @category Running Effects
  * @since 2.0.0
  */
@@ -15041,7 +15237,7 @@ export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(eff
  * Runs an effect synchronously and returns the result as an `Exit` type, which
  * represents the outcome (success or failure) of the effect.
  *
- * **When to Use**
+ * **When to use**
  *
  * Use `runSyncExit` to find out whether an effect succeeded or failed,
  * including any defects, without dealing with asynchronous operations.
@@ -15152,6 +15348,8 @@ export declare const runSyncExitWith: <R>(context: Context.Context<R>) => <A, E>
 /**
  * Type helpers for functions built with `Effect.fn` and `Effect.fnUntraced`.
  *
+ * **Details**
+ *
  * Use these to describe generator-based signatures and traced or untraced variants.
  *
  * @since 3.11.0
@@ -15751,6 +15949,8 @@ export declare namespace fn {
 /**
  * Creates an Effect-returning function without tracing.
  *
+ * **Details**
+ *
  * `Effect.fnUntraced` also acts as a `pipe` function, so you can append transforms after the body.
  *
  * **Example** (Defining untraced effect functions)
@@ -15773,6 +15973,8 @@ export declare const fnUntraced: fn.Untraced;
 /**
  * Creates a traced function with an optional span name and `SpanOptionsNoTrace` that adds spans and stack frames, plus pipeable post-processing that receives the Effect and the original arguments.
  *
+ * **Details**
+ *
  * Pipeable functions run after the body and can transform the resulting Effect.
  *
  * **Example** (Defining traced effect functions)
@@ -15829,6 +16031,8 @@ export declare const clockWith: <A, E, R>(f: (clock: Clock) => Effect<A, E, R>)
 /**
  * Creates a logger function that logs at the specified level.
  *
+ * **Details**
+ *
  * If no level is provided, the logger uses the fiber's current log level and
  * extracts any `Cause` values from the message list.
  *
@@ -16126,6 +16330,8 @@ export declare const annotateLogs: {
 /**
  * Adds log annotations to the current scope.
  *
+ * **Details**
+ *
  * 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.
@@ -16153,6 +16359,8 @@ export declare const annotateLogsScoped: {
     /**
      * Adds log annotations to the current scope.
      *
+     * **Details**
+     *
      * 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.
@@ -16180,6 +16388,8 @@ export declare const annotateLogsScoped: {
     /**
      * Adds log annotations to the current scope.
      *
+     * **Details**
+     *
      * 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.
@@ -16240,6 +16450,8 @@ export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A
 /**
  * Updates the `Metric` every time the `Effect` is executed.
  *
+ * **Details**
+ *
  * Also accepts an optional function which can be used to map the `Exit` value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
@@ -16291,6 +16503,8 @@ export declare const track: {
     /**
      * Updates the `Metric` every time the `Effect` is executed.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16342,6 +16556,8 @@ export declare const track: {
     /**
      * Updates the `Metric` every time the `Effect` is executed.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16393,6 +16609,8 @@ export declare const track: {
     /**
      * Updates the `Metric` every time the `Effect` is executed.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16444,6 +16662,8 @@ export declare const track: {
     /**
      * Updates the `Metric` every time the `Effect` is executed.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16497,6 +16717,8 @@ export declare const track: {
  * Updates the provided `Metric` every time the wrapped `Effect` succeeds with
  * a value.
  *
+ * **Details**
+ *
  * Also accepts an optional function which can be used to map the success value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
@@ -16545,6 +16767,8 @@ export declare const trackSuccesses: {
      * Updates the provided `Metric` every time the wrapped `Effect` succeeds with
      * a value.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16593,6 +16817,8 @@ export declare const trackSuccesses: {
      * Updates the provided `Metric` every time the wrapped `Effect` succeeds with
      * a value.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16641,6 +16867,8 @@ export declare const trackSuccesses: {
      * Updates the provided `Metric` every time the wrapped `Effect` succeeds with
      * a value.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16689,6 +16917,8 @@ export declare const trackSuccesses: {
      * Updates the provided `Metric` every time the wrapped `Effect` succeeds with
      * a value.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16738,6 +16968,8 @@ export declare const trackSuccesses: {
  * Updates the provided `Metric` every time the wrapped `Effect` fails with an
  * **expected** error.
  *
+ * **Details**
+ *
  * Also accepts an optional function which can be used to map the error value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
@@ -16788,6 +17020,8 @@ export declare const trackErrors: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **expected** error.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16838,6 +17072,8 @@ export declare const trackErrors: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **expected** error.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16888,6 +17124,8 @@ export declare const trackErrors: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **expected** error.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16938,6 +17176,8 @@ export declare const trackErrors: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **expected** error.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -16989,6 +17229,8 @@ export declare const trackErrors: {
  * Updates the provided `Metric` every time the wrapped `Effect` fails with an
  * **unexpected** error (i.e. a defect).
  *
+ * **Details**
+ *
  * Also accepts an optional function which can be used to map the defect value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
@@ -17040,6 +17282,8 @@ export declare const trackDefects: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **unexpected** error (i.e. a defect).
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -17091,6 +17335,8 @@ export declare const trackDefects: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **unexpected** error (i.e. a defect).
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -17142,6 +17388,8 @@ export declare const trackDefects: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **unexpected** error (i.e. a defect).
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -17193,6 +17441,8 @@ export declare const trackDefects: {
      * Updates the provided `Metric` every time the wrapped `Effect` fails with an
      * **unexpected** error (i.e. a defect).
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
@@ -17245,6 +17495,8 @@ export declare const trackDefects: {
  * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)
  * that the wrapped `Effect` took to complete.
  *
+ * **Details**
+ *
  * Also accepts an optional function which can be used to map the `Duration`
  * that the wrapped `Effect` took to complete into a valid `Input` for the
  * `Metric`.
@@ -17292,6 +17544,8 @@ export declare const trackDuration: {
      * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)
      * that the wrapped `Effect` took to complete.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Duration`
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
@@ -17339,6 +17593,8 @@ export declare const trackDuration: {
      * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)
      * that the wrapped `Effect` took to complete.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Duration`
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
@@ -17386,6 +17642,8 @@ export declare const trackDuration: {
      * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)
      * that the wrapped `Effect` took to complete.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Duration`
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
@@ -17433,6 +17691,8 @@ export declare const trackDuration: {
      * Updates the provided `Metric` with the `Duration` of time (in nanoseconds)
      * that the wrapped `Effect` took to complete.
      *
+     * **Details**
+     *
      * Also accepts an optional function which can be used to map the `Duration`
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
@@ -17487,6 +17747,8 @@ declare const Transaction_base: Context.ServiceClass<Transaction, "effect/Effect
 /**
  * Service that holds the current transaction state, it includes
  *
+ * **Details**
+ *
  * - a journal that stores any non committed change to TxRef values
  * - a retry flag to know if the transaction should be retried
  *
@@ -17512,6 +17774,8 @@ export declare class Transaction extends Transaction_base {
  * 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**
+ *
  * If called inside an active transaction, `tx` composes with the current transaction and reuses
  * its journal and retry state instead of creating a nested boundary.
  *
@@ -17555,10 +17819,9 @@ export declare const tx: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Excl
 /**
  * Signals that the current transaction needs to be retried.
  *
- * NOTE: the transaction retries on any change to transactional values (i.e. TxRef) accessed in its body.
+ * **Details**
  *
- * @category Transactions
- * @since 4.0.0
+ * NOTE: the transaction retries on any change to transactional values (i.e. TxRef) accessed in its body.
  *
  * **Example** (Retrying transactions)
  *
@@ -17588,6 +17851,9 @@ export declare const tx: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Excl
  *
  * Effect.runPromise(program).catch(console.error)
  * ```
+ *
+ * @category Transactions
+ * @since 4.0.0
  */
 export declare const txRetry: Effect<never, never, Transaction>;
 /**
@@ -18011,6 +18277,8 @@ export declare const effectify: {
 /**
  * Ensures that an effect's success type extends a given type `A`.
  *
+ * **Details**
+ *
  * This function provides compile-time type checking to ensure that the success
  * value of an effect conforms to a specific type constraint.
  *
@@ -18038,6 +18306,8 @@ export declare const satisfiesSuccessType: <A>() => <A2 extends A, E, R>(effect:
 /**
  * Ensures that an effect's error type extends a given type `E`.
  *
+ * **Details**
+ *
  * This function provides compile-time type checking to ensure that the error
  * type of an effect conforms to a specific type constraint.
  *
@@ -18067,6 +18337,8 @@ export declare const satisfiesErrorType: <E>() => <A, E2 extends E, R>(effect: E
 /**
  * Ensures that an effect's requirements type extends a given type `R`.
  *
+ * **Details**
+ *
  * This function provides compile-time type checking to ensure that the
  * requirements (context) type of an effect conforms to a specific type constraint.
  *
@@ -18095,13 +18367,15 @@ export declare const satisfiesServicesType: <R>() => <A, E, R2 extends R>(effect
  * An optimized version of `map` that checks if an effect is already resolved
  * and applies the mapping function eagerly when possible.
  *
- * **When to Use**
+ * **When to use**
  *
  * `mapEager` provides better performance for effects that are already resolved
  * by applying the transformation immediately instead of deferring it through
  * the effect pipeline.
  *
- * **Behavior**
+ * **Details**
+ *
+ * Behavior:
  *
  * - For **Success effects**: Applies the mapping function immediately to the value
  * - For **Failure effects**: Returns the failure as-is without applying the mapping
@@ -18129,13 +18403,15 @@ export declare const mapEager: {
      * An optimized version of `map` that checks if an effect is already resolved
      * and applies the mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the mapping function immediately to the value
      * - For **Failure effects**: Returns the failure as-is without applying the mapping
@@ -18163,13 +18439,15 @@ export declare const mapEager: {
      * An optimized version of `map` that checks if an effect is already resolved
      * and applies the mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the mapping function immediately to the value
      * - For **Failure effects**: Returns the failure as-is without applying the mapping
@@ -18198,13 +18476,15 @@ export declare const mapEager: {
  * An optimized version of `mapError` that checks if an effect is already resolved
  * and applies the error mapping function eagerly when possible.
  *
- * **When to Use**
+ * **When to use**
  *
  * `mapErrorEager` provides better performance for effects that are already resolved
  * by applying the error transformation immediately instead of deferring it through
  * the effect pipeline.
  *
- * **Behavior**
+ * **Details**
+ *
+ * Behavior:
  *
  * - For **Success effects**: Returns the success as-is (no error to transform)
  * - For **Failure effects**: Applies the mapping function immediately to the error
@@ -18235,13 +18515,15 @@ export declare const mapErrorEager: {
      * An optimized version of `mapError` that checks if an effect is already resolved
      * and applies the error mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapErrorEager` provides better performance for effects that are already resolved
      * by applying the error transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Returns the success as-is (no error to transform)
      * - For **Failure effects**: Applies the mapping function immediately to the error
@@ -18272,13 +18554,15 @@ export declare const mapErrorEager: {
      * An optimized version of `mapError` that checks if an effect is already resolved
      * and applies the error mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapErrorEager` provides better performance for effects that are already resolved
      * by applying the error transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Returns the success as-is (no error to transform)
      * - For **Failure effects**: Applies the mapping function immediately to the error
@@ -18310,13 +18594,15 @@ export declare const mapErrorEager: {
  * An optimized version of `mapBoth` that checks if an effect is already resolved
  * and applies the appropriate mapping function eagerly when possible.
  *
- * **When to Use**
+ * **When to use**
  *
  * `mapBothEager` provides better performance for effects that are already resolved
  * by applying the transformation immediately instead of deferring it through
  * the effect pipeline.
  *
- * **Behavior**
+ * **Details**
+ *
+ * Behavior:
  *
  * - For **Success effects**: Applies the `onSuccess` function immediately to the value
  * - For **Failure effects**: Applies the `onFailure` function immediately to the error
@@ -18349,13 +18635,15 @@ export declare const mapBothEager: {
      * An optimized version of `mapBoth` that checks if an effect is already resolved
      * and applies the appropriate mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapBothEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the `onSuccess` function immediately to the value
      * - For **Failure effects**: Applies the `onFailure` function immediately to the error
@@ -18391,13 +18679,15 @@ export declare const mapBothEager: {
      * An optimized version of `mapBoth` that checks if an effect is already resolved
      * and applies the appropriate mapping function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `mapBothEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the `onSuccess` function immediately to the value
      * - For **Failure effects**: Applies the `onFailure` function immediately to the error
@@ -18434,13 +18724,15 @@ export declare const mapBothEager: {
  * An optimized version of `flatMap` that checks if an effect is already resolved
  * and applies the flatMap function eagerly when possible.
  *
- * **When to Use**
+ * **When to use**
  *
  * `flatMapEager` provides better performance for effects that are already resolved
  * by applying the transformation immediately instead of deferring it through
  * the effect pipeline.
  *
- * **Behavior**
+ * **Details**
+ *
+ * Behavior:
  *
  * - For **Success effects**: Applies the flatMap function immediately to the value
  * - For **Failure effects**: Returns the failure as-is without applying the flatMap
@@ -18471,13 +18763,15 @@ export declare const flatMapEager: {
      * An optimized version of `flatMap` that checks if an effect is already resolved
      * and applies the flatMap function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `flatMapEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the flatMap function immediately to the value
      * - For **Failure effects**: Returns the failure as-is without applying the flatMap
@@ -18508,13 +18802,15 @@ export declare const flatMapEager: {
      * An optimized version of `flatMap` that checks if an effect is already resolved
      * and applies the flatMap function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `flatMapEager` provides better performance for effects that are already resolved
      * by applying the transformation immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Applies the flatMap function immediately to the value
      * - For **Failure effects**: Returns the failure as-is without applying the flatMap
@@ -18546,13 +18842,15 @@ export declare const flatMapEager: {
  * An optimized version of `catch` that checks if an effect is already resolved
  * and applies the catch function eagerly when possible.
  *
- * **When to Use**
+ * **When to use**
  *
  * `catchEager` provides better performance for effects that are already resolved
  * by applying the error recovery immediately instead of deferring it through
  * the effect pipeline.
  *
- * **Behavior**
+ * **Details**
+ *
+ * Behavior:
  *
  * - For **Success effects**: Returns the success as-is (no error to catch)
  * - For **Failure effects**: Applies the catch function immediately to the error
@@ -18593,13 +18891,15 @@ export declare const catchEager: {
      * An optimized version of `catch` that checks if an effect is already resolved
      * and applies the catch function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchEager` provides better performance for effects that are already resolved
      * by applying the error recovery immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Returns the success as-is (no error to catch)
      * - For **Failure effects**: Applies the catch function immediately to the error
@@ -18640,13 +18940,15 @@ export declare const catchEager: {
      * An optimized version of `catch` that checks if an effect is already resolved
      * and applies the catch function eagerly when possible.
      *
-     * **When to Use**
+     * **When to use**
      *
      * `catchEager` provides better performance for effects that are already resolved
      * by applying the error recovery immediately instead of deferring it through
      * the effect pipeline.
      *
-     * **Behavior**
+     * **Details**
+     *
+     * Behavior:
      *
      * - For **Success effects**: Returns the success as-is (no error to catch)
      * - For **Failure effects**: Applies the catch function immediately to the error
@@ -18687,6 +18989,8 @@ export declare const catchEager: {
 /**
  * Creates untraced function effects with eager evaluation optimization.
  *
+ * **Details**
+ *
  * Executes generator functions eagerly when all yielded effects are synchronous,
  * stopping at the first async effect and deferring to normal execution.
  *