effect 4.0.0-beta.71 → 4.0.0-beta.73

package/dist/Effect.d.ts

@@ -232,7 +232,7 @@ export type Error<T> = T extends Effect<infer _A, infer _E, infer _R> ? _E : nev
  */
 export type Services<T> = T extends Effect<infer _A, infer _E, infer _R> ? _R : never;
 /**
- * Tests if a value is an `Effect`.
+ * Checks whether a value is an `Effect`.
  *
  * **Example** (Checking whether a value is an Effect)
  *
@@ -1228,11 +1228,9 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  *
  * **When to use**
  *
- * Use when in situations where you need to perform asynchronous operations that might
- * fail, such as fetching data from an API, you can use the `tryPromise`
- * constructor. This constructor is designed to handle operations that could
- * throw exceptions by capturing those exceptions and transforming them into
- * manageable errors.
+ * Use when you need to perform asynchronous operations that might fail, such
+ * as fetching data from an API, and want thrown exceptions or rejected promises
+ * captured as Effect errors.
  *
  * **Details**
  *
@@ -1355,7 +1353,7 @@ export declare const succeedNone: Effect<Option<never>>;
  */
 export declare const succeedSome: <A>(value: A) => Effect<Option<A>>;
 /**
- * Delays the creation of an `Effect` until it is actually needed.
+ * Creates an `Effect` lazily, delaying construction until it is needed.
  *
  * **When to use**
  *
@@ -1555,8 +1553,8 @@ export declare const callback: <A, E = never, R = never>(register: (this: Schedu
  */
 export declare const never: Effect<never>;
 /**
- * An `Effect` containing an empty record `{}`, used as the starting point for
- * do notation chains.
+ * Effect that succeeds with an empty record `{}`, used as the starting point
+ * for do notation chains.
  *
  * **Example** (Starting do notation)
  *
@@ -1953,10 +1951,13 @@ export declare const fail: <E>(error: E) => Effect<never, E>;
 /**
  * Creates an `Effect` that represents a recoverable error using a lazy evaluation.
  *
+ * **When to use**
+ *
+ * Use to defer computing a recoverable error value until the effect is run.
+ *
  * **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.
+ * The error-producing function is evaluated each time the effect is executed.
  *
  * **Example** (Lazily creating failures)
  *
@@ -2003,10 +2004,13 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E>;
 /**
  * Creates an `Effect` that represents a failure with a `Cause` computed lazily.
  *
+ * **When to use**
+ *
+ * Use to defer computing a full `Cause` until the effect is run.
+ *
  * **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.
+ * The cause-producing function is evaluated each time the effect is executed.
  *
  * **Example** (Lazily creating a Cause)
  *
@@ -3151,7 +3155,7 @@ export declare const tap: {
     <A, E, R, B, E2, R2>(self: Effect<A, E, R>, f: Effect<B, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
- * Encapsulates both success and failure of an `Effect` into a `Result` type.
+ * Converts both success and failure of an `Effect` into a `Result` type.
  *
  * **When to use**
  *
@@ -3206,7 +3210,7 @@ export declare const tap: {
  */
 export declare const result: <A, E, R>(self: Effect<A, E, R>) => Effect<Result.Result<A, E>, never, R>;
 /**
- * Convert success to `Option.some` and failure to `Option.none`.
+ * Converts success to `Option.some` and failure to `Option.none`.
  *
  * **When to use**
  *
@@ -3564,9 +3568,7 @@ export declare const as: {
     <A, E, R, B>(self: Effect<A, E, R>, value: B): Effect<B, E, R>;
 };
 /**
- * This function maps the success value of an `Effect` value to a `Some` value
- * in an `Option` value. If the original `Effect` value fails, the returned
- * `Effect` value will also fail.
+ * Maps the success value of an `Effect` to `Some`, preserving failures.
  *
  * **Example** (Wrapping success in Option.some)
  *
@@ -3584,10 +3586,7 @@ export declare const as: {
  */
 export declare const asSome: <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E, R>;
 /**
- * This function maps the success value of an `Effect` value to `void`. If the
- * original `Effect` value succeeds, the returned `Effect` value will also
- * succeed. If the original `Effect` value fails, the returned `Effect` value
- * will fail with the same error.
+ * Maps the success value of an `Effect` to `void`, preserving failures.
  *
  * **Example** (Discarding success values)
  *
@@ -3605,15 +3604,16 @@ export declare const asSome: <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A
  */
 export declare const asVoid: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R>;
 /**
- * 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.
+ * Swaps an effect's success and failure channels.
+ *
+ * **When to use**
+ *
+ * Use to handle the failure value as a success, or to move the success value
+ * into the failure channel.
  *
  * **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
- * treat an error as a valid result.
+ * For an `Effect<A, E, R>`, the returned effect has type `Effect<E, A, R>`.
  *
  * **Example** (Swapping success and failure channels)
  *
@@ -3869,9 +3869,8 @@ export declare const zip: {
  *
  * **When to use**
  *
- * Use when 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.
+ * Use when you need to run two effects sequentially and combine their results
+ * with a function instead of keeping the results as a tuple.
  *
  * **Details**
  *
@@ -3918,9 +3917,8 @@ export declare const zipWith: {
      *
      * **When to use**
      *
-     * Use when 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.
+     * Use when you need to run two effects sequentially and combine their results
+     * with a function instead of keeping the results as a tuple.
      *
      * **Details**
      *
@@ -3969,9 +3967,8 @@ export declare const zipWith: {
      *
      * **When to use**
      *
-     * Use when 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.
+     * Use when you need to run two effects sequentially and combine their results
+     * with a function instead of keeping the results as a tuple.
      *
      * **Details**
      *
@@ -4180,12 +4177,9 @@ export declare const catchTag: {
  *
  * **When to use**
  *
- * Use when `catchTags` is a convenient way to handle multiple error types at
- * once. Instead of using {@link catchTag} multiple times, you can pass an
- * object where each key is an error type's `_tag`, and the value is the handler
- * for that specific error. This allows you to catch and recover from multiple
- * error types in a single call. You can also provide a fallback handler for
- * unhandled errors.
+ * Use when one recovery step should handle several tagged error types by
+ * matching their readonly `_tag` fields. Pass a handler table whose keys are
+ * tags, plus an optional fallback for unmatched errors.
  *
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
@@ -4224,12 +4218,9 @@ export declare const catchTags: {
      *
      * **When to use**
      *
-     * Use when `catchTags` is a convenient way to handle multiple error types at
-     * once. Instead of using {@link catchTag} multiple times, you can pass an
-     * object where each key is an error type's `_tag`, and the value is the handler
-     * for that specific error. This allows you to catch and recover from multiple
-     * error types in a single call. You can also provide a fallback handler for
-     * unhandled errors.
+     * Use when one recovery step should handle several tagged error types by
+     * matching their readonly `_tag` fields. Pass a handler table whose keys are
+     * tags, plus an optional fallback for unmatched errors.
      *
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
@@ -4288,12 +4279,9 @@ export declare const catchTags: {
      *
      * **When to use**
      *
-     * Use when `catchTags` is a convenient way to handle multiple error types at
-     * once. Instead of using {@link catchTag} multiple times, you can pass an
-     * object where each key is an error type's `_tag`, and the value is the handler
-     * for that specific error. This allows you to catch and recover from multiple
-     * error types in a single call. You can also provide a fallback handler for
-     * unhandled errors.
+     * Use when one recovery step should handle several tagged error types by
+     * matching their readonly `_tag` fields. Pass a handler table whose keys are
+     * tags, plus an optional fallback for unmatched errors.
      *
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
@@ -4738,10 +4726,8 @@ export declare const unwrapReason: {
  *
  * **When to use**
  *
- * Use when 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.
+ * Use when recovery needs the full `Cause`, including recoverable failures,
+ * defects, and interruptions, instead of only the typed error value.
  *
  * **Details**
  *
@@ -4780,10 +4766,8 @@ export declare const catchCause: {
      *
      * **When to use**
      *
-     * Use when 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.
+     * Use when recovery needs the full `Cause`, including recoverable failures,
+     * defects, and interruptions, instead of only the typed error value.
      *
      * **Details**
      *
@@ -4822,10 +4806,8 @@ export declare const catchCause: {
      *
      * **When to use**
      *
-     * Use when 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.
+     * Use when recovery needs the full `Cause`, including recoverable failures,
+     * defects, and interruptions, instead of only the typed error value.
      *
      * **Details**
      *
@@ -4988,7 +4970,7 @@ export declare const catchDefect: {
  *
  * **When to use**
  *
- * Use when `catchIf` lets you recover from errors that match a condition. Use a
+ * Use when you need to recover from errors that match a condition. Use a
  * `Refinement` for type narrowing or a `Predicate` for simple boolean
  * matching. Non-matching errors re-fail with the original cause. Defects and
  * interrupts are not caught.
@@ -5028,7 +5010,7 @@ export declare const catchIf: {
      *
      * **When to use**
      *
-     * Use when `catchIf` lets you recover from errors that match a condition. Use a
+     * Use when you need to recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
@@ -5068,7 +5050,7 @@ export declare const catchIf: {
      *
      * **When to use**
      *
-     * Use when `catchIf` lets you recover from errors that match a condition. Use a
+     * Use when you need to recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
@@ -5108,7 +5090,7 @@ export declare const catchIf: {
      *
      * **When to use**
      *
-     * Use when `catchIf` lets you recover from errors that match a condition. Use a
+     * Use when you need to recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
@@ -5148,7 +5130,7 @@ export declare const catchIf: {
      *
      * **When to use**
      *
-     * Use when `catchIf` lets you recover from errors that match a condition. Use a
+     * Use when you need to recover from errors that match a condition. Use a
      * `Refinement` for type narrowing or a `Predicate` for simple boolean
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
@@ -5493,8 +5475,7 @@ export declare const catchCauseFilter: {
     <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(self: Effect<A, E, R>, filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>): Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>;
 };
 /**
- * The `mapError` function is used to transform or modify the error
- * produced by an effect, without affecting its success value.
+ * Transforms the failure value of an effect without changing its success value.
  *
  * **When to use**
  *
@@ -5502,10 +5483,8 @@ export declare const catchCauseFilter: {
  *
  * **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.
+ * Only the failure channel is transformed. The success channel and requirements
+ * are preserved.
  *
  * **Example** (Transforming the error channel)
  *
@@ -5534,8 +5513,7 @@ export declare const catchCauseFilter: {
  */
 export declare const mapError: {
     /**
-     * The `mapError` function is used to transform or modify the error
-     * produced by an effect, without affecting its success value.
+     * Transforms the failure value of an effect without changing its success value.
      *
      * **When to use**
      *
@@ -5543,10 +5521,8 @@ export declare const mapError: {
      *
      * **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.
+     * Only the failure channel is transformed. The success channel and requirements
+     * are preserved.
      *
      * **Example** (Transforming the error channel)
      *
@@ -5575,8 +5551,7 @@ export declare const mapError: {
      */
     <E, E2>(f: (e: E) => E2): <A, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
     /**
-     * The `mapError` function is used to transform or modify the error
-     * produced by an effect, without affecting its success value.
+     * Transforms the failure value of an effect without changing its success value.
      *
      * **When to use**
      *
@@ -5584,10 +5559,8 @@ export declare const mapError: {
      *
      * **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.
+     * Only the failure channel is transformed. The success channel and requirements
+     * are preserved.
      *
      * **Example** (Transforming the error channel)
      *
@@ -6091,7 +6064,7 @@ export declare const tapCause: {
     <A, E, R, X, E2, R2>(self: Effect<A, E, R>, f: (cause: Cause.Cause<E>) => Effect<X, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
- * Conditionally executes a side effect based on the cause of a failed effect.
+ * Executes a side effect conditionally when a failed effect's cause matches a predicate.
  *
  * **Details**
  *
@@ -6123,7 +6096,7 @@ export declare const tapCause: {
  */
 export declare const tapCauseIf: {
     /**
-     * Conditionally executes a side effect based on the cause of a failed effect.
+     * Executes a side effect conditionally when a failed effect's cause matches a predicate.
      *
      * **Details**
      *
@@ -6155,7 +6128,7 @@ export declare const tapCauseIf: {
      */
     <E, B, E2, R2>(predicate: Predicate.Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>;
     /**
-     * Conditionally executes a side effect based on the cause of a failed effect.
+     * Executes a side effect conditionally when a failed effect's cause matches a predicate.
      *
      * **Details**
      *
@@ -6188,7 +6161,7 @@ export declare const tapCauseIf: {
     <A, E, R, B, E2, R2>(self: Effect<A, E, R>, predicate: Predicate.Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Effect<B, E2, R2>): Effect<A, E | E2, R | R2>;
 };
 /**
- * Conditionally executes a side effect based on the cause of a failed effect.
+ * Executes a side effect conditionally when a failed effect's cause passes a filter.
  *
  * **When to use**
  *
@@ -6210,7 +6183,7 @@ export declare const tapCauseIf: {
  */
 export declare const tapCauseFilter: {
     /**
-     * Conditionally executes a side effect based on the cause of a failed effect.
+     * Executes a side effect conditionally when a failed effect's cause passes a filter.
      *
      * **When to use**
      *
@@ -6232,7 +6205,7 @@ export declare const tapCauseFilter: {
      */
     <E, B, E2, R2, EB, X extends Cause.Cause<any>>(filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (a: EB, cause: Cause.Cause<E>) => Effect<B, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E2, R | R2>;
     /**
-     * Conditionally executes a side effect based on the cause of a failed effect.
+     * Executes a side effect conditionally when a failed effect's cause passes a filter.
      *
      * **When to use**
      *
@@ -7061,9 +7034,8 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
  *
  * **When to use**
  *
- * Use when `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
- * effects of the effect and do not need to handle or process its outcome.
+ * Use when an effect should run for its side effects while both success and
+ * failure values are discarded.
  *
  * Use the `log` option to emit the full {@link Cause} when the effect fails,
  * and `message` to prepend a custom log message.
@@ -7139,7 +7111,7 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
     readonly message?: string | undefined;
 } | undefined) => [Arg] extends [Effect<infer _A, infer _E, infer _R>] ? Effect<void, never, _R> : <A, E, R>(self: Effect<A, E, R>) => Effect<void, never, R>;
 /**
- * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
+ * Applies an `ExecutionPlan` to an effect, retrying with step-provided resources
  * until it succeeds or the plan is exhausted.
  *
  * **Details**
@@ -7176,7 +7148,7 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
  */
 export declare const withExecutionPlan: {
     /**
-     * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
+     * Applies an `ExecutionPlan` to an effect, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
      * **Details**
@@ -7218,7 +7190,7 @@ export declare const withExecutionPlan: {
         requirements: PlanR;
     }>): <A, E extends Input, R>(effect: Effect<A, E, R>) => Effect<A, E | PlanE, Exclude<R, Provides> | PlanR>;
     /**
-     * Apply an `ExecutionPlan` to an effect, retrying with step-provided resources
+     * Applies an `ExecutionPlan` to an effect, retrying with step-provided resources
      * until it succeeds or the plan is exhausted.
      *
      * **Details**
@@ -7781,8 +7753,8 @@ export declare const timeoutOption: {
  *
  * **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.
+ * The fallback effect is created lazily by `orElse` and may introduce its own
+ * success, failure, and requirement types.
  *
  * **Gotchas**
  *
@@ -7835,8 +7807,8 @@ export declare const timeoutOrElse: {
      *
      * **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.
+     * The fallback effect is created lazily by `orElse` and may introduce its own
+     * success, failure, and requirement types.
      *
      * **Gotchas**
      *
@@ -7892,8 +7864,8 @@ export declare const timeoutOrElse: {
      *
      * **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.
+     * The fallback effect is created lazily by `orElse` and may introduce its own
+     * success, failure, and requirement types.
      *
      * **Gotchas**
      *
@@ -8031,7 +8003,7 @@ export declare const delay: {
  */
 export declare const sleep: (duration: Duration.Input) => Effect<void>;
 /**
- * Measures the runtime of an effect and returns the duration with its result.
+ * Returns the runtime duration of an effect together with its result.
  *
  * **Details**
  *
@@ -8561,7 +8533,7 @@ export declare const filterMap: {
     <A, B, X>(elements: Iterable<A>, filter: Filter.Filter<NoInfer<A>, B, X>): Effect<Array<B>>;
 };
 /**
- * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
+ * Filters and maps elements of an iterable effectfully with a `FilterEffect`.
  *
  * **When to use**
  *
@@ -8586,7 +8558,7 @@ export declare const filterMap: {
  */
 export declare const filterMapEffect: {
     /**
-     * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
+     * Filters and maps elements of an iterable effectfully with a `FilterEffect`.
      *
      * **When to use**
      *
@@ -8613,7 +8585,7 @@ export declare const filterMapEffect: {
         readonly concurrency?: Concurrency | undefined;
     }): (elements: Iterable<A>) => Effect<Array<B>, E, R>;
     /**
-     * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
+     * Filters and maps elements of an iterable effectfully with a `FilterEffect`.
      *
      * **When to use**
      *
@@ -9252,7 +9224,7 @@ export declare const filterMapOrFail: {
     <A, E, R, B, X>(self: Effect<A, E, R>, filter: Filter.Filter<A, B, X>): Effect<B, Cause.NoSuchElementError | E, R>;
 };
 /**
- * Conditionally runs an effect based on the result of an effectful boolean
+ * Runs an effect conditionally based on the result of an effectful boolean
  * condition.
  *
  * **When to use**
@@ -9289,7 +9261,7 @@ export declare const filterMapOrFail: {
  */
 export declare const when: {
     /**
-     * Conditionally runs an effect based on the result of an effectful boolean
+     * Runs an effect conditionally based on the result of an effectful boolean
      * condition.
      *
      * **When to use**
@@ -9326,7 +9298,7 @@ export declare const when: {
      */
     <E2 = never, R2 = never>(condition: Effect<boolean, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, E | E2, R | R2>;
     /**
-     * Conditionally runs an effect based on the result of an effectful boolean
+     * Runs an effect conditionally based on the result of an effectful boolean
      * condition.
      *
      * **When to use**
@@ -9863,7 +9835,7 @@ export declare const matchCauseEager: {
     }): Effect<A2 | A3, never, R>;
 };
 /**
- * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
+ * Handles success or failure eagerly with effectful handlers when the effect is already resolved.
  *
  * **When to use**
  *
@@ -9885,7 +9857,7 @@ export declare const matchCauseEager: {
  */
 export declare const matchCauseEffectEager: {
     /**
-     * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
+     * Handles success or failure eagerly with effectful handlers when the effect is already resolved.
      *
      * **When to use**
      *
@@ -9910,7 +9882,7 @@ export declare const matchCauseEffectEager: {
         readonly onSuccess: (a: A) => Effect<A3, E3, R3>;
     }): <R>(self: Effect<A, E, R>) => Effect<A2 | A3, E2 | E3, R2 | R3 | R>;
     /**
-     * Eagerly handles success or failure with effectful handlers when the effect is already resolved.
+     * Handles success or failure eagerly with effectful handlers when the effect is already resolved.
      *
      * **When to use**
      *
@@ -10873,6 +10845,11 @@ export declare const service: <I, S>(service: Context.Key<I, S>) => Effect<S, ne
 /**
  * Optionally accesses a service from the environment.
  *
+ * **When to use**
+ *
+ * Use to read an optional dependency from the current context without making
+ * that dependency part of the effect's required environment.
+ *
  * **Details**
  *
  * This function attempts to access a service from the environment. If the
@@ -11143,8 +11120,7 @@ export declare const updateService: {
     <XA, E, R, I, A>(self: Effect<XA, E, R>, service: Context.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>;
 };
 /**
- * The `provideService` function is used to provide an actual
- * implementation for a service in the context of an effect.
+ * Provides one concrete service implementation to an effect.
  *
  * **When to use**
  *
@@ -11152,11 +11128,8 @@ export declare const updateService: {
  *
  * **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.
+ * The service requirement identified by the `Context.Key` is removed from the
+ * effect requirements after the implementation is provided.
  *
  * **Example** (Providing a service value)
  *
@@ -11197,8 +11170,7 @@ export declare const updateService: {
  */
 export declare const provideService: {
     /**
-     * The `provideService` function is used to provide an actual
-     * implementation for a service in the context of an effect.
+     * Provides one concrete service implementation to an effect.
      *
      * **When to use**
      *
@@ -11206,11 +11178,8 @@ export declare const provideService: {
      *
      * **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.
+     * The service requirement identified by the `Context.Key` is removed from the
+     * effect requirements after the implementation is provided.
      *
      * **Example** (Providing a service value)
      *
@@ -11251,8 +11220,7 @@ export declare const provideService: {
      */
     <I, S>(service: Context.Key<I, S>): {
         /**
-         * The `provideService` function is used to provide an actual
-         * implementation for a service in the context of an effect.
+         * Provides one concrete service implementation to an effect.
          *
          * **When to use**
          *
@@ -11260,11 +11228,8 @@ export declare const provideService: {
          *
          * **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.
+         * The service requirement identified by the `Context.Key` is removed from the
+         * effect requirements after the implementation is provided.
          *
          * **Example** (Providing a service value)
          *
@@ -11305,8 +11270,7 @@ export declare const provideService: {
          */
         (implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
         /**
-         * The `provideService` function is used to provide an actual
-         * implementation for a service in the context of an effect.
+         * Provides one concrete service implementation to an effect.
          *
          * **When to use**
          *
@@ -11314,11 +11278,8 @@ export declare const provideService: {
          *
          * **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.
+         * The service requirement identified by the `Context.Key` is removed from the
+         * effect requirements after the implementation is provided.
          *
          * **Example** (Providing a service value)
          *
@@ -11360,8 +11321,7 @@ export declare const provideService: {
         <A, E, R>(self: Effect<A, E, R>, implementation: S): Effect<A, E, Exclude<R, I>>;
     };
     /**
-     * The `provideService` function is used to provide an actual
-     * implementation for a service in the context of an effect.
+     * Provides one concrete service implementation to an effect.
      *
      * **When to use**
      *
@@ -11369,11 +11329,8 @@ export declare const provideService: {
      *
      * **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.
+     * The service requirement identified by the `Context.Key` is removed from the
+     * effect requirements after the implementation is provided.
      *
      * **Example** (Providing a service value)
      *
@@ -11414,8 +11371,7 @@ export declare const provideService: {
      */
     <I, S>(service: Context.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>;
     /**
-     * The `provideService` function is used to provide an actual
-     * implementation for a service in the context of an effect.
+     * Provides one concrete service implementation to an effect.
      *
      * **When to use**
      *
@@ -11423,11 +11379,8 @@ export declare const provideService: {
      *
      * **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.
+     * The service requirement identified by the `Context.Key` is removed from the
+     * effect requirements after the implementation is provided.
      *
      * **Example** (Providing a service value)
      *
@@ -11765,9 +11718,16 @@ export declare const withConcurrency: {
  */
 export declare const scope: Effect<Scope, never, Scope>;
 /**
- * Scopes all resources used in this workflow to the lifetime of the workflow,
- * ensuring that their finalizers are run as soon as this workflow completes
- * execution, whether by success, failure, or interruption.
+ * Runs an effect with a scope that closes when the effect completes.
+ *
+ * **When to use**
+ *
+ * Use to acquire scoped resources for the duration of a single workflow.
+ *
+ * **Details**
+ *
+ * Finalizers for resources acquired inside the workflow run as soon as the
+ * workflow completes, whether by success, failure, or interruption.
  *
  * **Example** (Running a scoped acquisition)
  *
@@ -11902,8 +11862,7 @@ export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, rel
     readonly interruptible?: boolean;
 }) => Effect<A, E, R | R2 | Scope>;
 /**
- * This function constructs a scoped resource from an Effect that acquires a
- * disposable value.
+ * Acquires a scoped resource that implements JavaScript disposal protocols.
  *
  * **When to use**
  *
@@ -11949,10 +11908,7 @@ export declare const acquireRelease: <A, E, R, R2>(acquire: Effect<A, E, R>, rel
  */
 export declare const acquireDisposable: <A extends AsyncDisposable | Disposable, E, R>(acquire: Effect<A, E, R>) => Effect<A, E, R | Scope>;
 /**
- * This function is used to ensure that an `Effect` value that represents the
- * acquisition of a resource (for example, opening a file, launching a thread,
- * etc.) will not be interrupted, and that the resource will always be released
- * when the `Effect` value completes execution.
+ * Runs resource acquisition, usage, and release as one bracketed effect.
  *
  * **When to use**
  *
@@ -12030,9 +11986,7 @@ export declare const acquireDisposable: <A extends AsyncDisposable | Disposable,
  */
 export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acquire: Effect<Resource, E, R>, use: (a: Resource) => Effect<A, E2, R2>, release: (a: Resource, exit: Exit.Exit<A, E2>) => Effect<void, E3, R3>) => Effect<A, E | E2 | E3, R | R2 | R3>;
 /**
- * This function adds a finalizer to the scope of the calling `Effect` value.
- * 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.
+ * Adds a finalizer to the current scope.
  *
  * **When to use**
  *
@@ -12040,9 +11994,8 @@ export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acqu
  *
  * **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.
+ * The finalizer runs when the surrounding scope is closed and receives the
+ * `Exit` value used to close the scope.
  *
  * **Example** (Registering scope finalizers)
  *
@@ -12446,8 +12399,8 @@ export declare const onErrorFilter: {
  */
 export declare const onExitPrimitive: <A, E, R, XE = never, XR = never>(self: Effect<A, E, R>, f: (exit: Exit.Exit<A, E>) => Effect<void, XE, XR> | undefined, interruptible?: boolean) => Effect<A, E | XE, R | XR>;
 /**
- * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
- * or is interrupted.
+ * Ensures that a cleanup function runs whether this effect succeeds, fails, or
+ * is interrupted.
  *
  * **Example** (Observing every exit)
  *
@@ -12474,8 +12427,8 @@ export declare const onExitPrimitive: <A, E, R, XE = never, XR = never>(self: Ef
  */
 export declare const onExit: {
     /**
-     * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
-     * or is interrupted.
+     * Ensures that a cleanup function runs whether this effect succeeds, fails, or
+     * is interrupted.
      *
      * **Example** (Observing every exit)
      *
@@ -12502,8 +12455,8 @@ export declare const onExit: {
      */
     <A, E, XE = never, XR = never>(f: (exit: Exit.Exit<A, E>) => Effect<void, XE, XR>): <R>(self: Effect<A, E, R>) => Effect<A, E | XE, R | XR>;
     /**
-     * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
-     * or is interrupted.
+     * Ensures that a cleanup function runs whether this effect succeeds, fails, or
+     * is interrupted.
      *
      * **Example** (Observing every exit)
      *
@@ -12934,18 +12887,14 @@ export declare const cachedWithTTL: {
     <A, E, R>(self: Effect<A, E, R>, timeToLive: Duration.Input): Effect<Effect<A, E, R>>;
 };
 /**
- * Caches an effect's result for a specified duration and allows manual
+ * Creates a cached effect result for a specified duration and allows manual
  * invalidation before expiration.
  *
  * **When to use**
  *
- * Use when you 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.
+ * Use when an effect result should be cached for a bounded time and callers
+ * also need a manual invalidation effect to force recomputation before
+ * expiration.
  *
  * **Details**
  *
@@ -13004,18 +12953,14 @@ export declare const cachedWithTTL: {
  */
 export declare const cachedInvalidateWithTTL: {
     /**
-     * Caches an effect's result for a specified duration and allows manual
+     * Creates a cached effect result for a specified duration and allows manual
      * invalidation before expiration.
      *
      * **When to use**
      *
-     * Use when you 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.
+     * Use when an effect result should be cached for a bounded time and callers
+     * also need a manual invalidation effect to force recomputation before
+     * expiration.
      *
      * **Details**
      *
@@ -13074,18 +13019,14 @@ export declare const cachedInvalidateWithTTL: {
      */
     (timeToLive: Duration.Input): <A, E, R>(self: Effect<A, E, R>) => Effect<[Effect<A, E, R>, Effect<void>]>;
     /**
-     * Caches an effect's result for a specified duration and allows manual
+     * Creates a cached effect result for a specified duration and allows manual
      * invalidation before expiration.
      *
      * **When to use**
      *
-     * Use when you 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.
+     * Use when an effect result should be cached for a bounded time and callers
+     * also need a manual invalidation effect to force recomputation before
+     * expiration.
      *
      * **Details**
      *
@@ -13319,9 +13260,8 @@ export declare const uninterruptible: <A, E, R>(self: Effect<A, E, R>) => Effect
  */
 export declare const uninterruptibleMask: <A, E, R>(f: (restore: <AX, EX, RX>(effect: Effect<AX, EX, RX>) => Effect<AX, EX, RX>) => Effect<A, E, R>) => Effect<A, E, R>;
 /**
- * This function behaves like {@link interruptible}, but it also provides a
- * `restore` function. This function can be used to restore the interruptibility
- * of any specific region of code.
+ * Runs an effect in an interruptible region while providing `restore` for
+ * locally restoring the previous interruptibility.
  *
  * **Example** (Controlling interruptibility locally)
  *
@@ -15116,7 +15056,7 @@ export declare const spanAnnotations: Effect<Readonly<Record<string, unknown>>>;
  */
 export declare const spanLinks: Effect<ReadonlyArray<SpanLink>>;
 /**
- * For all spans in this effect, add a link with the provided span.
+ * Adds a link with the provided span to all spans in this effect.
  *
  * **Details**
  *
@@ -15171,7 +15111,7 @@ export declare const spanLinks: Effect<ReadonlyArray<SpanLink>>;
  */
 export declare const linkSpans: {
     /**
-     * For all spans in this effect, add a link with the provided span.
+     * Adds a link with the provided span to all spans in this effect.
      *
      * **Details**
      *
@@ -15226,7 +15166,7 @@ export declare const linkSpans: {
      */
     (span: AnySpan | ReadonlyArray<AnySpan>, attributes?: Record<string, unknown>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
     /**
-     * For all spans in this effect, add a link with the provided span.
+     * Adds a link with the provided span to all spans in this effect.
      *
      * **Details**
      *
@@ -15420,7 +15360,7 @@ export declare const useSpan: {
     <A, E, R>(name: string, options: SpanOptionsNoTrace, evaluate: (span: Span) => Effect<A, E, R>): Effect<A, E, R>;
 };
 /**
- * Wraps the effect with a new span for tracing.
+ * Wraps the effect with a child span for tracing.
  *
  * **Example** (Wrapping an effect in a child span)
  *
@@ -15442,7 +15382,7 @@ export declare const useSpan: {
  */
 export declare const withSpan: {
     /**
-     * Wraps the effect with a new span for tracing.
+     * Wraps the effect with a child span for tracing.
      *
      * **Example** (Wrapping an effect in a child span)
      *
@@ -15464,7 +15404,7 @@ export declare const withSpan: {
      */
     <Args extends ReadonlyArray<any>>(name: string, options?: SpanOptionsNoTrace | ((...args: NoInfer<Args>) => SpanOptionsNoTrace) | undefined, traceOptions?: TraceOptions | undefined): <A, E, R>(self: Effect<A, E, R>, ...args: Args) => Effect<A, E, Exclude<R, ParentSpan>>;
     /**
-     * Wraps the effect with a new span for tracing.
+     * Wraps the effect with a child span for tracing.
      *
      * **Example** (Wrapping an effect in a child span)
      *
@@ -15487,7 +15427,7 @@ export declare const withSpan: {
     <A, E, R>(self: Effect<A, E, R>, name: string, options?: SpanOptions | undefined): Effect<A, E, Exclude<R, ParentSpan>>;
 };
 /**
- * Wraps the effect with a new span for tracing.
+ * Wraps the effect with a scoped child span for tracing.
  *
  * **Details**
  *
@@ -15512,7 +15452,7 @@ export declare const withSpan: {
  */
 export declare const withSpanScoped: {
     /**
-     * Wraps the effect with a new span for tracing.
+     * Wraps the effect with a scoped child span for tracing.
      *
      * **Details**
      *
@@ -15537,7 +15477,7 @@ export declare const withSpanScoped: {
      */
     (name: string, options?: SpanOptions): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, ParentSpan> | Scope>;
     /**
-     * Wraps the effect with a new span for tracing.
+     * Wraps the effect with a scoped child span for tracing.
      *
      * **Details**
      *
@@ -15745,7 +15685,7 @@ export declare const request: {
     <A extends Request.Any, EX = never, RX = never>(self: A, resolver: RequestResolver<A> | Effect<RequestResolver<A>, EX, RX>): Effect<Request.Success<A>, Request.Error<A> | EX, Request.Services<A> | RX>;
 };
 /**
- * Low-level entry point that registers a request with a resolver and delivers the exit value via `onExit`.
+ * Registers a request with a resolver and delivers the exit value via `onExit`.
  *
  * **When to use**
  *
@@ -16029,7 +15969,7 @@ export declare const forkDetach: <Arg extends Effect<any, any, any> | {
  */
 export declare const awaitAllChildren: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
 /**
- * Access the fiber currently executing the effect.
+ * Accesses the fiber currently executing the effect.
  *
  * **Example** (Accessing the current fiber)
  *
@@ -16047,7 +15987,7 @@ export declare const awaitAllChildren: <A, E, R>(self: Effect<A, E, R>) => Effec
  */
 export declare const fiber: Effect<Fiber<unknown, unknown>>;
 /**
- * Access the current fiber id executing the effect.
+ * Accesses the current fiber id executing the effect.
  *
  * **Example** (Accessing the current fiber id)
  *
@@ -16099,17 +16039,14 @@ export interface RunOptions {
     readonly onFiberStart?: ((fiber: Fiber<unknown, unknown>) => void) | undefined;
 }
 /**
- * The foundational function for running effects, returning a "fiber" that can
+ * Runs an effect in the background, returning a fiber that can
  * be observed or interrupted.
  *
  * **When to use**
  *
- * Use when `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
- * that can be observed or interrupted.
- *
- * Unless you specifically need a `Promise` or synchronous operation,
- * `runFork` is a good default choice.
+ * Use when an effect should start in the background and return a fiber that can
+ * be observed or interrupted. Prefer this when you do not need a `Promise` or
+ * synchronous result.
  *
  * **Example** (Running an effect in the background)
  *
@@ -16412,7 +16349,8 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
  *
  * **When to use**
  *
- * Use when you use `runSync` only for effects that can complete synchronously.
+ * Use when you need to execute an effect that is guaranteed to complete
+ * synchronously.
  *
  * **Details**
  *
@@ -16499,7 +16437,7 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
  */
 export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>) => A;
 /**
- * Runs an effect synchronously and returns the result as an `Exit` type, which
+ * Runs an effect synchronously and captures the outcome safely as an `Exit` type, which
  * represents the outcome (success or failure) of the effect.
  *
  * **When to use**
@@ -16573,7 +16511,7 @@ export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(eff
  */
 export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E>;
 /**
- * Runs an effect synchronously with provided services, returning an Exit result.
+ * Runs an effect synchronously with provided services, returning an Exit result safely.
  *
  * **Example** (Running synchronously with services as Exit)
  *
@@ -19030,12 +18968,12 @@ declare const Transaction_base: Context.ServiceClass<Transaction, "effect/Effect
     }>;
 }>;
 /**
- * Service that holds the current transaction state, it includes
+ * Service that holds the current transaction state.
  *
  * **Details**
  *
- * - a journal that stores any non committed change to TxRef values
- * - a retry flag to know if the transaction should be retried
+ * It includes a journal that stores non-committed changes to `TxRef` values and
+ * a retry flag that records whether the transaction should be retried.
  *
  * **Example** (Building transactions)
  *
@@ -19102,7 +19040,7 @@ export declare class Transaction extends Transaction_base {
  */
 export declare const tx: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Exclude<R, Transaction>>;
 /**
- * Signals that the current transaction needs to be retried.
+ * Retries the current transaction by signaling that it must be retried.
  *
  * **Details**
  *
@@ -19649,14 +19587,12 @@ export declare const satisfiesErrorType: <E>() => <A, E2 extends E, R>(effect: E
  */
 export declare const satisfiesServicesType: <R>() => <A, E, R2 extends R>(effect: Effect<A, E, R2>) => Effect<A, E, R2>;
 /**
- * An optimized version of `map` that checks if an effect is already resolved
- * and applies the mapping function eagerly when possible.
+ * Applies `map` eagerly when an effect is already resolved.
  *
  * **When to use**
  *
- * Use when `mapEager` provides better performance for effects that are already resolved
- * by applying the transformation immediately instead of deferring it through
- * the effect pipeline.
+ * Use when an already-resolved effect should apply a success transformation
+ * immediately while pending effects still use regular mapping.
  *
  * **Details**
  *
@@ -19685,14 +19621,12 @@ export declare const satisfiesServicesType: <R>() => <A, E, R2 extends R>(effect
  */
 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.
+     * Applies `map` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved effect should apply a success transformation
+     * immediately while pending effects still use regular mapping.
      *
      * **Details**
      *
@@ -19721,14 +19655,12 @@ export declare const mapEager: {
      */
     <A, B>(f: (a: A) => B): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
     /**
-     * An optimized version of `map` that checks if an effect is already resolved
-     * and applies the mapping function eagerly when possible.
+     * Applies `map` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved effect should apply a success transformation
+     * immediately while pending effects still use regular mapping.
      *
      * **Details**
      *
@@ -19758,14 +19690,13 @@ export declare const mapEager: {
     <A, E, R, B>(self: Effect<A, E, R>, f: (a: A) => B): Effect<B, E, R>;
 };
 /**
- * An optimized version of `mapError` that checks if an effect is already resolved
- * and applies the error mapping function eagerly when possible.
+ * Applies `mapError` eagerly when an effect is already resolved.
  *
  * **When to use**
  *
- * Use when `mapErrorEager` provides better performance for effects that are already resolved
- * by applying the error transformation immediately instead of deferring it through
- * the effect pipeline.
+ * Use when an already-resolved failed effect should apply an error
+ * transformation immediately while pending effects still use regular error
+ * mapping.
  *
  * **Details**
  *
@@ -19797,14 +19728,13 @@ export declare const mapEager: {
  */
 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.
+     * Applies `mapError` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapErrorEager` provides better performance for effects that are already resolved
-     * by applying the error transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved failed effect should apply an error
+     * transformation immediately while pending effects still use regular error
+     * mapping.
      *
      * **Details**
      *
@@ -19836,14 +19766,13 @@ export declare const mapErrorEager: {
      */
     <E, E2>(f: (e: E) => E2): <A, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
     /**
-     * An optimized version of `mapError` that checks if an effect is already resolved
-     * and applies the error mapping function eagerly when possible.
+     * Applies `mapError` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapErrorEager` provides better performance for effects that are already resolved
-     * by applying the error transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved failed effect should apply an error
+     * transformation immediately while pending effects still use regular error
+     * mapping.
      *
      * **Details**
      *
@@ -19876,14 +19805,12 @@ export declare const mapErrorEager: {
     <A, E, R, E2>(self: Effect<A, E, R>, f: (e: E) => E2): Effect<A, E2, R>;
 };
 /**
- * An optimized version of `mapBoth` that checks if an effect is already resolved
- * and applies the appropriate mapping function eagerly when possible.
+ * Applies `mapBoth` eagerly when an effect is already resolved.
  *
  * **When to use**
  *
- * Use when `mapBothEager` provides better performance for effects that are already resolved
- * by applying the transformation immediately instead of deferring it through
- * the effect pipeline.
+ * Use when an already-resolved effect should transform either success or
+ * failure immediately while pending effects still use regular channel mapping.
  *
  * **Details**
  *
@@ -19917,14 +19844,12 @@ export declare const mapErrorEager: {
  */
 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.
+     * Applies `mapBoth` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapBothEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved effect should transform either success or
+     * failure immediately while pending effects still use regular channel mapping.
      *
      * **Details**
      *
@@ -19961,14 +19886,12 @@ export declare const mapBothEager: {
         readonly onSuccess: (a: A) => A2;
     }): <R>(self: Effect<A, E, R>) => Effect<A2, E2, R>;
     /**
-     * An optimized version of `mapBoth` that checks if an effect is already resolved
-     * and applies the appropriate mapping function eagerly when possible.
+     * Applies `mapBoth` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `mapBothEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved effect should transform either success or
+     * failure immediately while pending effects still use regular channel mapping.
      *
      * **Details**
      *
@@ -20006,14 +19929,12 @@ export declare const mapBothEager: {
     }): Effect<A2, E2, R>;
 };
 /**
- * An optimized version of `flatMap` that checks if an effect is already resolved
- * and applies the flatMap function eagerly when possible.
+ * Applies `flatMap` eagerly when an effect is already resolved.
  *
  * **When to use**
  *
- * Use when `flatMapEager` provides better performance for effects that are already resolved
- * by applying the transformation immediately instead of deferring it through
- * the effect pipeline.
+ * Use when an already-resolved successful effect should bind immediately to the
+ * next effect while pending effects still use regular flat mapping.
  *
  * **Details**
  *
@@ -20045,14 +19966,12 @@ export declare const mapBothEager: {
  */
 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.
+     * Applies `flatMap` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `flatMapEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved successful effect should bind immediately to the
+     * next effect while pending effects still use regular flat mapping.
      *
      * **Details**
      *
@@ -20084,14 +20003,12 @@ export declare const flatMapEager: {
      */
     <A, B, E2, R2>(f: (a: A) => Effect<B, E2, R2>): <E, R>(self: Effect<A, E, R>) => Effect<B, E | E2, R | R2>;
     /**
-     * An optimized version of `flatMap` that checks if an effect is already resolved
-     * and applies the flatMap function eagerly when possible.
+     * Applies `flatMap` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `flatMapEager` provides better performance for effects that are already resolved
-     * by applying the transformation immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved successful effect should bind immediately to the
+     * next effect while pending effects still use regular flat mapping.
      *
      * **Details**
      *
@@ -20124,14 +20041,12 @@ export declare const flatMapEager: {
     <A, E, R, B, E2, R2>(self: Effect<A, E, R>, f: (a: A) => Effect<B, E2, R2>): Effect<B, E | E2, R | R2>;
 };
 /**
- * An optimized version of `catch` that checks if an effect is already resolved
- * and applies the catch function eagerly when possible.
+ * Applies `catch` eagerly when an effect is already resolved.
  *
  * **When to use**
  *
- * Use when `catchEager` provides better performance for effects that are already resolved
- * by applying the error recovery immediately instead of deferring it through
- * the effect pipeline.
+ * Use when an already-resolved failed effect should recover immediately while
+ * pending effects still use regular error recovery.
  *
  * **Details**
  *
@@ -20173,14 +20088,12 @@ export declare const flatMapEager: {
  */
 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.
+     * Applies `catch` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `catchEager` provides better performance for effects that are already resolved
-     * by applying the error recovery immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved failed effect should recover immediately while
+     * pending effects still use regular error recovery.
      *
      * **Details**
      *
@@ -20222,14 +20135,12 @@ export declare const catchEager: {
      */
     <E, B, E2, R2>(f: (e: NoInfer<E>) => Effect<B, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A | B, E2, R | R2>;
     /**
-     * An optimized version of `catch` that checks if an effect is already resolved
-     * and applies the catch function eagerly when possible.
+     * Applies `catch` eagerly when an effect is already resolved.
      *
      * **When to use**
      *
-     * Use when `catchEager` provides better performance for effects that are already resolved
-     * by applying the error recovery immediately instead of deferring it through
-     * the effect pipeline.
+     * Use when an already-resolved failed effect should recover immediately while
+     * pending effects still use regular error recovery.
      *
      * **Details**
      *