effect 4.0.0-beta.68 → 4.0.0-beta.69

package/dist/Effect.d.ts

@@ -20,7 +20,7 @@
  * - **Testable**: Built-in support for testing with controlled environments
  * - **Interruptible**: Effects can be safely interrupted and cancelled
  *
- * **Example** (Usage)
+ * **Example** (Creating and running effects)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -39,7 +39,7 @@
  * Effect.runPromise(program).then(console.log) // 13
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Handling typed failures)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -192,7 +192,7 @@ export type Services<T> = T extends Effect<infer _A, infer _E, infer _R> ? _R :
 /**
  * Tests if a value is an `Effect`.
  *
- * **Example** (Usage)
+ * **Example** (Checking whether a value is an Effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -307,7 +307,7 @@ export declare namespace All {
  * `Result` in the same output shape. Use `discard: true` to ignore successful
  * values and return `void`.
  *
- * **Example** (Combining Effects in Tuples)
+ * **Example** (Collecting tuple results in order)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -328,7 +328,7 @@ export declare namespace All {
  * // [ 42, 'Hello' ]
  * ```
  *
- * **Example** (Combining Effects in Iterables)
+ * **Example** (Collecting iterable results in order)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -349,7 +349,7 @@ export declare namespace All {
  * // [ 1, 2, 3 ]
  * ```
  *
- * **Example** (Combining Effects in Structs)
+ * **Example** (Collecting struct results by key)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -370,7 +370,7 @@ export declare namespace All {
  * // { a: 42, b: 'Hello' }
  * ```
  *
- * **Example** (Combining Effects in Records)
+ * **Example** (Collecting record results by key)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -391,7 +391,7 @@ export declare namespace All {
  * // { key1: 1, key2: 2 }
  * ```
  *
- * **Example** (Short-Circuiting Behavior)
+ * **Example** (Stopping on the first failure)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -435,7 +435,7 @@ export declare const all: <const Arg extends Iterable<Effect<any, any, any>> | R
  * This function runs every effect and never fails. Use `concurrency` to control
  * parallelism.
  *
- * **Example** (Usage)
+ * **Example** (Separating successes and failures)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -464,7 +464,7 @@ export declare const partition: {
      * This function runs every effect and never fails. Use `concurrency` to control
      * parallelism.
      *
-     * **Example** (Usage)
+     * **Example** (Separating successes and failures)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -495,7 +495,7 @@ export declare const partition: {
      * This function runs every effect and never fails. Use `concurrency` to control
      * parallelism.
      *
-     * **Example** (Usage)
+     * **Example** (Separating successes and failures)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -525,7 +525,7 @@ export declare const partition: {
  * Use `discard: true` to ignore successful values while still validating all
  * elements.
  *
- * **Example** (Usage)
+ * **Example** (Validating every element)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -562,7 +562,7 @@ export declare const validate: {
      * Use `discard: true` to ignore successful values while still validating all
      * elements.
      *
-     * **Example** (Usage)
+     * **Example** (Validating every element)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -602,7 +602,7 @@ export declare const validate: {
      * Use `discard: true` to ignore successful values while still validating all
      * elements.
      *
-     * **Example** (Usage)
+     * **Example** (Validating every element)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -642,7 +642,7 @@ export declare const validate: {
      * Use `discard: true` to ignore successful values while still validating all
      * elements.
      *
-     * **Example** (Usage)
+     * **Example** (Validating every element)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -682,7 +682,7 @@ export declare const validate: {
      * Use `discard: true` to ignore successful values while still validating all
      * elements.
      *
-     * **Example** (Usage)
+     * **Example** (Validating every element)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -719,7 +719,7 @@ export declare const validate: {
  * The predicate receives the element and its index. Evaluation short-circuits
  * as soon as an element matches.
  *
- * **Example** (Usage)
+ * **Example** (Finding the first successful match)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -740,7 +740,7 @@ export declare const findFirst: {
      * The predicate receives the element and its index. Evaluation short-circuits
      * as soon as an element matches.
      *
-     * **Example** (Usage)
+     * **Example** (Finding the first successful match)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -761,7 +761,7 @@ export declare const findFirst: {
      * The predicate receives the element and its index. Evaluation short-circuits
      * as soon as an element matches.
      *
-     * **Example** (Usage)
+     * **Example** (Finding the first successful match)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -831,7 +831,7 @@ export declare const findFirstFilter: {
  *
  * @see {@link all} for combining multiple effects into one.
  *
- * **Example** (Applying Effects to Iterable Elements)
+ * **Example** (Mapping over an iterable with effects)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -852,7 +852,7 @@ export declare const findFirstFilter: {
  * // [ 2, 4, 6, 8, 10 ]
  * ```
  *
- * **Example** (Using discard to Ignore Results)
+ * **Example** (Running effects without collecting results)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -902,7 +902,7 @@ export declare const forEach: {
      *
      * @see {@link all} for combining multiple effects into one.
      *
-     * **Example** (Applying Effects to Iterable Elements)
+     * **Example** (Mapping over an iterable with effects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -923,7 +923,7 @@ export declare const forEach: {
      * // [ 2, 4, 6, 8, 10 ]
      * ```
      *
-     * **Example** (Using discard to Ignore Results)
+     * **Example** (Running effects without collecting results)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -976,7 +976,7 @@ export declare const forEach: {
      *
      * @see {@link all} for combining multiple effects into one.
      *
-     * **Example** (Applying Effects to Iterable Elements)
+     * **Example** (Mapping over an iterable with effects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -997,7 +997,7 @@ export declare const forEach: {
      * // [ 2, 4, 6, 8, 10 ]
      * ```
      *
-     * **Example** (Using discard to Ignore Results)
+     * **Example** (Running effects without collecting results)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -1031,7 +1031,7 @@ export declare const forEach: {
 /**
  * Executes a body effect repeatedly while a condition holds true.
  *
- * **Example** (Usage)
+ * **Example** (Repeating an effectful loop)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1086,7 +1086,7 @@ export declare const whileLoop: <A, E, R>(options: {
  *
  * @see {@link tryPromise} for a version that can handle failures.
  *
- * **Example** (Delayed Message)
+ * **Example** (Wrapping a non-rejecting Promise)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1136,7 +1136,7 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * An optional `AbortSignal` can be provided to allow for interruption of the
  * wrapped `Promise` API.
  *
- * **Example** (Fetching a TODO Item)
+ * **Example** (Wrapping a fetch request that may fail)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1152,7 +1152,7 @@ export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike
  * const program = getTodo(1)
  * ```
  *
- * **Example** (Custom Error Handling)
+ * **Example** (Mapping Promise rejections to a tagged error)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -1190,7 +1190,7 @@ export declare const tryPromise: <A, E = Cause.UnknownError>(options: {
  *
  * @see {@link fail} to create an effect that represents a failure.
  *
- * **Example** (Creating a Successful Effect)
+ * **Example** (Creating a successful effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1209,7 +1209,7 @@ export declare const succeed: <A>(value: A) => Effect<A>;
 /**
  * Returns an effect which succeeds with `None`.
  *
- * **Example** (Usage)
+ * **Example** (Succeeding with Option.none)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1227,7 +1227,7 @@ export declare const succeedNone: Effect<Option<never>>;
 /**
  * Returns an effect which succeeds with the value wrapped in a `Some`.
  *
- * **Example** (Usage)
+ * **Example** (Succeeding with Option.some)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1256,7 +1256,7 @@ export declare const succeedSome: <A>(value: A) => Effect<Option<A>>;
  * - **Handling Circular Dependencies**: Useful in managing circular dependencies, such as recursive functions that need to avoid eager evaluation to prevent stack overflow.
  * - **Unifying Return Types**: Can help TypeScript unify return types in situations where multiple branches of logic return different effects, simplifying type inference.
  *
- * **Example** (Lazy Evaluation with Side Effects)
+ * **Example** (Lazily evaluating side effects)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1274,7 +1274,7 @@ export declare const succeedSome: <A>(value: A) => Effect<Option<A>>;
  * console.log(Effect.runSync(good)) // Output: 2
  * ```
  *
- * **Example** (Recursive Fibonacci)
+ * **Example** (Suspending recursive Fibonacci evaluation)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1300,7 +1300,7 @@ export declare const succeedSome: <A>(value: A) => Effect<Option<A>>;
  * // Output: 3524578
  * ```
  *
- * **Example** (Using Effect.suspend to Help TypeScript Infer Types)
+ * **Example** (Helping TypeScript infer recursive effect types)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1348,7 +1348,7 @@ export declare const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Eff
  *
  * @see {@link try_ | try} for a version that can handle failures.
  *
- * **Example** (Logging a Message)
+ * **Example** (Capturing synchronous logging in an Effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1396,7 +1396,7 @@ undefined_ as undefined };
  * Use `Effect.callback` when integrating APIs that complete through callbacks
  * instead of returning a `Promise`.
  *
- * **Example** (Usage)
+ * **Example** (Integrating callback APIs)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1421,7 +1421,7 @@ export declare const callback: <A, E = never, R = never>(register: (this: Schedu
  * Returns an effect that will never produce anything. The moral equivalent of
  * `while(true) {}`, only without the wasted CPU cycles.
  *
- * **Example** (Usage)
+ * **Example** (Creating a never-ending effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1444,7 +1444,7 @@ export declare const never: Effect<never>;
  * An `Effect` containing an empty record `{}`, used as the starting point for
  * do notation chains.
  *
- * **Example** (Usage)
+ * **Example** (Starting do notation)
  *
  * ```ts
  * import { Effect, pipe } from "effect"
@@ -1539,7 +1539,7 @@ export declare const bind: {
  * explicit control over the execution of effects. You can `yield*` values from
  * effects and return the final result at the end.
  *
- * **Example** (Usage)
+ * **Example** (Sequencing effects with generators)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -1591,7 +1591,7 @@ export declare const gen: {
      * explicit control over the execution of effects. You can `yield*` values from
      * effects and return the final result at the end.
      *
-     * **Example** (Usage)
+     * **Example** (Sequencing effects with generators)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -1647,7 +1647,7 @@ export declare const gen: {
      * explicit control over the execution of effects. You can `yield*` values from
      * effects and return the final result at the end.
      *
-     * **Example** (Usage)
+     * **Example** (Sequencing effects with generators)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -1716,7 +1716,7 @@ export declare namespace gen {
  *
  * @see {@link succeed} to create an effect that represents a successful value.
  *
- * **Example** (Creating a Failed Effect)
+ * **Example** (Creating a failed effect)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -1740,7 +1740,7 @@ export declare const fail: <E>(error: E) => Effect<never, E>;
  * 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.
  *
- * **Example** (Usage)
+ * **Example** (Lazily creating failures)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -1763,7 +1763,7 @@ export declare const failSync: <E>(evaluate: LazyArg<E>) => Effect<never, E>;
  * This function allows you to create effects that fail with complex error
  * structures, including multiple errors, defects, interruptions, and more.
  *
- * **Example** (Usage)
+ * **Example** (Failing with a full Cause)
  *
  * ```ts
  * import { Cause, Effect } from "effect"
@@ -1786,7 +1786,7 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E>;
  * 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.
  *
- * **Example** (Usage)
+ * **Example** (Lazily creating a Cause)
  *
  * ```ts
  * import { Cause, Effect } from "effect"
@@ -1822,7 +1822,7 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ef
  *
  * @see {@link die} for a variant that dies with an already computed defect.
  *
- * **Example** (Terminating on Division by Zero with a Specified Error)
+ * **Example** (Failing when division by zero)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1874,7 +1874,7 @@ export {
  * @see {@link sync} if the effectful computation is synchronous and does not
  * throw errors.
  *
- * **Example** (Basic Usage with Default Error Handling)
+ * **Example** (Parsing JSON with typed error mapping)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1894,7 +1894,7 @@ export {
  * // Output: Exit.failure with Error
  * ```
  *
- * **Example** (Custom Error Handling)
+ * **Example** (Mapping synchronous exceptions to a tagged error)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -1918,7 +1918,7 @@ try_ as try };
 /**
  * Yields control back to the Effect runtime, allowing other fibers to execute.
  *
- * **Example** (Usage)
+ * **Example** (Yielding to other fibers)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1939,7 +1939,7 @@ export declare const yieldNow: Effect<void>;
 /**
  * Yields control back to the Effect runtime with a specified priority, allowing other fibers to execute.
  *
- * **Example** (Usage)
+ * **Example** (Yielding with priority)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1960,7 +1960,7 @@ export declare const yieldNowWith: (priority?: number) => Effect<void>;
 /**
  * Provides access to the current fiber within an effect computation.
  *
- * **Example** (Usage)
+ * **Example** (Reading the current fiber)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -1980,7 +1980,7 @@ export declare const withFiber: <A, E = never, R = never>(evaluate: (fiber: Fibe
 /**
  * Converts a `Result` to an `Effect`.
  *
- * **Example** (Usage)
+ * **Example** (Converting a Result into an Effect)
  *
  * ```ts
  * import { Effect, Result } from "effect"
@@ -2006,7 +2006,7 @@ export declare const fromResult: <A, E>(result: Result.Result<A, E>) => Effect<A
  * `Option.some` becomes a successful effect with the contained value, while
  * `Option.none` becomes a failed effect with `NoSuchElementError`.
  *
- * **Example** (Usage)
+ * **Example** (Converting an Option into an Effect)
  *
  * ```ts
  * import { Effect, Option } from "effect"
@@ -2030,7 +2030,7 @@ export declare const fromOption: <A>(option: Option<A>) => Effect<A, Cause.NoSuc
  * Converts a nullable value to an `Effect`, failing with a `NoSuchElementError`
  * when the value is `null` or `undefined`.
  *
- * **Example** (Usage)
+ * **Example** (Failing on nullish values)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -2082,7 +2082,7 @@ export declare const fromNullishOr: <A>(value: A) => Effect<NonNullable<A>, Caus
  * step produces a new `Effect` while flattening any nested effects that may
  * occur.
  *
- * **Example** (Usage)
+ * **Example** (Sequencing dependent effects)
  *
  * ```ts
  * import { Data, Effect, pipe } from "effect"
@@ -2147,7 +2147,7 @@ export declare const flatMap: {
      * step produces a new `Effect` while flattening any nested effects that may
      * occur.
      *
-     * **Example** (Usage)
+     * **Example** (Sequencing dependent effects)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2212,7 +2212,7 @@ export declare const flatMap: {
      * step produces a new `Effect` while flattening any nested effects that may
      * occur.
      *
-     * **Example** (Usage)
+     * **Example** (Sequencing dependent effects)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2251,7 +2251,7 @@ export declare const flatMap: {
 /**
  * Flattens an `Effect` that produces another `Effect` into a single effect.
  *
- * **Example** (Usage)
+ * **Example** (Flattening nested effects)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -2298,7 +2298,7 @@ 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** (Applying a Discount Based on Fetched Amount)
+ * **Example** (Sequencing a discount calculation after fetching a total)
  *
  * ```ts
  * import { Data, Effect, pipe } from "effect"
@@ -2371,7 +2371,7 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
-     * **Example** (Applying a Discount Based on Fetched Amount)
+     * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2444,7 +2444,7 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
-     * **Example** (Applying a Discount Based on Fetched Amount)
+     * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2517,7 +2517,7 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
-     * **Example** (Applying a Discount Based on Fetched Amount)
+     * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2590,7 +2590,7 @@ export declare const andThen: {
      * Failures or requirements from either effect are preserved in the returned
      * effect.
      *
-     * **Example** (Applying a Discount Based on Fetched Amount)
+     * **Example** (Sequencing a discount calculation after fetching a total)
      *
      * ```ts
      * import { Data, Effect, pipe } from "effect"
@@ -2929,7 +2929,7 @@ export declare const tap: {
  * The resulting effect cannot fail directly because all recoverable failures
  * are represented inside the `Result` type.
  *
- * **Example** (Usage)
+ * **Example** (Capturing success or failure as Result)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -2962,7 +2962,7 @@ export declare const result: <A, E, R>(self: Effect<A, E, R>) => Effect<Result.R
  * Success values become `Option.some`, recoverable failures become
  * `Option.none`, and defects still fail the effect.
  *
- * **Example** (Usage)
+ * **Example** (Capturing success or failure as Option)
  *
  * ```ts
  * import { Console, Effect, Option } from "effect"
@@ -3000,7 +3000,7 @@ export declare const option: <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A
  * the `Exit.Failure` type. The error type is set to `never`, indicating that
  * the effect is structured to never fail directly.
  *
- * **Example** (Usage)
+ * **Example** (Capturing completion as Exit)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3047,7 +3047,7 @@ 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** (Adding a Service Charge)
+ * **Example** (Adding a service charge)
  *
  * ```ts
  * import { Effect, pipe } from "effect"
@@ -3095,7 +3095,7 @@ export declare const map: {
      * effect is not modified. Instead, a new effect is returned with the updated
      * value.
      *
-     * **Example** (Adding a Service Charge)
+     * **Example** (Adding a service charge)
      *
      * ```ts
      * import { Effect, pipe } from "effect"
@@ -3143,7 +3143,7 @@ export declare const map: {
      * effect is not modified. Instead, a new effect is returned with the updated
      * value.
      *
-     * **Example** (Adding a Service Charge)
+     * **Example** (Adding a service charge)
      *
      * ```ts
      * import { Effect, pipe } from "effect"
@@ -3176,7 +3176,7 @@ export declare const map: {
  * `as` allows you to ignore the original value inside an effect and
  * replace it with a new constant value.
  *
- * **Example** (Replacing a Value)
+ * **Example** (Replacing a success value)
  *
  * ```ts
  * import { Effect, pipe } from "effect"
@@ -3198,7 +3198,7 @@ export declare const as: {
      * `as` allows you to ignore the original value inside an effect and
      * replace it with a new constant value.
      *
-     * **Example** (Replacing a Value)
+     * **Example** (Replacing a success value)
      *
      * ```ts
      * import { Effect, pipe } from "effect"
@@ -3220,7 +3220,7 @@ export declare const as: {
      * `as` allows you to ignore the original value inside an effect and
      * replace it with a new constant value.
      *
-     * **Example** (Replacing a Value)
+     * **Example** (Replacing a success value)
      *
      * ```ts
      * import { Effect, pipe } from "effect"
@@ -3242,7 +3242,7 @@ export declare const as: {
  * in an `Option` value. If the original `Effect` value fails, the returned
  * `Effect` value will also fail.
  *
- * **Example** (Usage)
+ * **Example** (Wrapping success in Option.some)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3263,7 +3263,7 @@ export declare const asSome: <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A
  * succeed. If the original `Effect` value fails, the returned `Effect` value
  * will fail with the same error.
  *
- * **Example** (Usage)
+ * **Example** (Discarding success values)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3287,7 +3287,7 @@ export declare const asVoid: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E,
  * be helpful in scenarios where you want to handle a success as a failure or
  * treat an error as a valid result.
  *
- * **Example** (Usage)
+ * **Example** (Swapping success and failure channels)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3319,7 +3319,7 @@ export declare const flip: <A, E, R>(self: Effect<A, E, R>) => Effect<E, A, R>;
  * @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)
+ * **Example** (Combining two effects sequentially)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3346,7 +3346,7 @@ export declare const flip: <A, E, R>(self: Effect<A, E, R>) => Effect<E, A, R>;
  * // [ 1, 'hello' ]
  * ```
  *
- * **Example** (Combining Two Effects Concurrently)
+ * **Example** (Combining two effects concurrently)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3388,7 +3388,7 @@ export declare const zip: {
      * @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)
+     * **Example** (Combining two effects sequentially)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3415,7 +3415,7 @@ export declare const zip: {
      * // [ 1, 'hello' ]
      * ```
      *
-     * **Example** (Combining Two Effects Concurrently)
+     * **Example** (Combining two effects concurrently)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3459,7 +3459,7 @@ export declare const zip: {
      * @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)
+     * **Example** (Combining two effects sequentially)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3486,7 +3486,7 @@ export declare const zip: {
      * // [ 1, 'hello' ]
      * ```
      *
-     * **Example** (Combining Two Effects Concurrently)
+     * **Example** (Combining two effects concurrently)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3532,7 +3532,7 @@ export declare const zip: {
  * By default, the effects are run sequentially. To execute them concurrently,
  * use the `{ concurrent: true }` option.
  *
- * **Example** (Combining Effects with a Custom Function)
+ * **Example** (Combining two success values with a function)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3579,7 +3579,7 @@ export declare const zipWith: {
      * By default, the effects are run sequentially. To execute them concurrently,
      * use the `{ concurrent: true }` option.
      *
-     * **Example** (Combining Effects with a Custom Function)
+     * **Example** (Combining two success values with a function)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3628,7 +3628,7 @@ export declare const zipWith: {
      * By default, the effects are run sequentially. To execute them concurrently,
      * use the `{ concurrent: true }` option.
      *
-     * **Example** (Combining Effects with a Custom Function)
+     * **Example** (Combining two success values with a function)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3701,7 +3701,7 @@ catch_ as catch };
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
  *
- * **Example** (Usage)
+ * **Example** (Handling a tagged error)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -3743,7 +3743,7 @@ export declare const catchTag: {
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
      *
-     * **Example** (Usage)
+     * **Example** (Handling a tagged error)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3785,7 +3785,7 @@ export declare const catchTag: {
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
      *
-     * **Example** (Usage)
+     * **Example** (Handling a tagged error)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -3829,7 +3829,7 @@ export declare const catchTag: {
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
  *
- * **Example** (Usage)
+ * **Example** (Handling multiple tagged errors)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -3873,7 +3873,7 @@ export declare const catchTags: {
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
      *
-     * **Example** (Usage)
+     * **Example** (Handling multiple tagged errors)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -3937,7 +3937,7 @@ export declare const catchTags: {
      * The error type must have a readonly `_tag` field to use `catchTag`. This
      * field is used to identify and match errors.
      *
-     * **Example** (Usage)
+     * **Example** (Handling multiple tagged errors)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -3993,7 +3993,7 @@ export declare const catchTags: {
  * Use this to handle nested error causes without removing the parent error
  * from the error channel. The handler receives the unwrapped reason.
  *
- * **Example** (Usage)
+ * **Example** (Handling an error reason)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -4030,7 +4030,7 @@ export declare const catchReason: {
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
-     * **Example** (Usage)
+     * **Example** (Handling an error reason)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4067,7 +4067,7 @@ export declare const catchReason: {
      * Use this to handle nested error causes without removing the parent error
      * from the error channel. The handler receives the unwrapped reason.
      *
-     * **Example** (Usage)
+     * **Example** (Handling an error reason)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4102,7 +4102,7 @@ export declare const catchReason: {
 /**
  * Catches multiple reasons within a tagged error using an object of handlers.
  *
- * **Example** (Usage)
+ * **Example** (Handling multiple error reasons)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -4138,7 +4138,7 @@ export declare const catchReasons: {
     /**
      * Catches multiple reasons within a tagged error using an object of handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Handling multiple error reasons)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4182,7 +4182,7 @@ export declare const catchReasons: {
     /**
      * Catches multiple reasons within a tagged error using an object of handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Handling multiple error reasons)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4239,7 +4239,7 @@ export type TagsWithReason<E> = {
  * Promotes nested reason errors into the Effect error channel, replacing
  * the parent error.
  *
- * **Example** (Usage)
+ * **Example** (Extracting the reason from a tagged error)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -4271,7 +4271,7 @@ export declare const unwrapReason: {
      * Promotes nested reason errors into the Effect error channel, replacing
      * the parent error.
      *
-     * **Example** (Usage)
+     * **Example** (Extracting the reason from a tagged error)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4303,7 +4303,7 @@ export declare const unwrapReason: {
      * Promotes nested reason errors into the Effect error channel, replacing
      * the parent error.
      *
-     * **Example** (Usage)
+     * **Example** (Extracting the reason from a tagged error)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -4349,7 +4349,7 @@ export declare const unwrapReason: {
  * they often indicate serious issues. However, in some cases, such as
  * dynamically loaded plugins, controlled recovery might be needed.
  *
- * **Example** (Usage)
+ * **Example** (Recovering from full failure causes)
  *
  * ```ts
  * import { Cause, Console, Effect } from "effect"
@@ -4389,7 +4389,7 @@ export declare const catchCause: {
      * they often indicate serious issues. However, in some cases, such as
      * dynamically loaded plugins, controlled recovery might be needed.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from full failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -4429,7 +4429,7 @@ export declare const catchCause: {
      * they often indicate serious issues. However, in some cases, such as
      * dynamically loaded plugins, controlled recovery might be needed.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from full failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -4472,7 +4472,7 @@ export declare const catchCause: {
  * they often indicate serious issues. In some cases, such as dynamically loaded
  * plugins, controlled recovery may be needed.
  *
- * **Example** (Usage)
+ * **Example** (Recovering from defects)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -4513,7 +4513,7 @@ export declare const catchDefect: {
      * they often indicate serious issues. In some cases, such as dynamically loaded
      * plugins, controlled recovery may be needed.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from defects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -4554,7 +4554,7 @@ export declare const catchDefect: {
      * they often indicate serious issues. In some cases, such as dynamically loaded
      * plugins, controlled recovery may be needed.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from defects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -4587,7 +4587,7 @@ export declare const catchDefect: {
  * matching. Non-matching errors re-fail with the original cause. Defects and
  * interrupts are not caught.
  *
- * **Example** (Usage)
+ * **Example** (Recovering when a predicate matches)
  *
  * ```ts
  * import { Data, Effect, Filter } from "effect"
@@ -4627,7 +4627,7 @@ export declare const catchIf: {
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering when a predicate matches)
      *
      * ```ts
      * import { Data, Effect, Filter } from "effect"
@@ -4667,7 +4667,7 @@ export declare const catchIf: {
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering when a predicate matches)
      *
      * ```ts
      * import { Data, Effect, Filter } from "effect"
@@ -4707,7 +4707,7 @@ export declare const catchIf: {
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering when a predicate matches)
      *
      * ```ts
      * import { Data, Effect, Filter } from "effect"
@@ -4747,7 +4747,7 @@ export declare const catchIf: {
      * matching. Non-matching errors re-fail with the original cause. Defects and
      * interrupts are not caught.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering when a predicate matches)
      *
      * ```ts
      * import { Data, Effect, Filter } from "effect"
@@ -4806,7 +4806,7 @@ export declare const catchFilter: {
  * Success values become `Option.some`, `NoSuchElementError` becomes
  * `Option.none`, and all other errors are preserved.
  *
- * **Example** (Usage)
+ * **Example** (Recovering from missing Option values)
  *
  * ```ts
  * import { Effect, Option } from "effect"
@@ -4829,7 +4829,7 @@ export declare const catchNoSuchElement: <A, E, R>(self: Effect<A, E, R>) => Eff
  * that match a specific predicate. This is useful when you want to handle
  * only certain types of errors while letting others propagate.
  *
- * **Example** (Usage)
+ * **Example** (Recovering from selected causes)
  *
  * ```ts
  * import { Cause, Console, Effect } from "effect"
@@ -4863,7 +4863,7 @@ export declare const catchCauseIf: {
      * that match a specific predicate. This is useful when you want to handle
      * only certain types of errors while letting others propagate.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from selected causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -4897,7 +4897,7 @@ export declare const catchCauseIf: {
      * that match a specific predicate. This is useful when you want to handle
      * only certain types of errors while letting others propagate.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering from selected causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -4960,7 +4960,7 @@ export declare const catchCauseFilter: {
  * @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** (Usage)
+ * **Example** (Transforming the error channel)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -4996,7 +4996,7 @@ export declare const mapError: {
      * @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** (Usage)
+     * **Example** (Transforming the error channel)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -5032,7 +5032,7 @@ export declare const mapError: {
      * @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** (Usage)
+     * **Example** (Transforming the error channel)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -5066,7 +5066,7 @@ export declare const mapError: {
  * the error and the success values without altering the overall success or
  * failure status of the effect.
  *
- * **Example** (Usage)
+ * **Example** (Transforming success and failure channels)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -5102,7 +5102,7 @@ export declare const mapBoth: {
      * the error and the success values without altering the overall success or
      * failure status of the effect.
      *
-     * **Example** (Usage)
+     * **Example** (Transforming success and failure channels)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -5141,7 +5141,7 @@ export declare const mapBoth: {
      * the error and the success values without altering the overall success or
      * failure status of the effect.
      *
-     * **Example** (Usage)
+     * **Example** (Transforming success and failure channels)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -5182,7 +5182,7 @@ export declare const mapBoth: {
  *
  * @see {@link mapError} to transform the error before converting it into a defect with {@link orDie}.
  *
- * **Example** (Propagating an Error as a Defect)
+ * **Example** (Converting typed failures into defects)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -5218,7 +5218,7 @@ export declare const orDie: <A, E, R>(self: Effect<A, E, R>) => Effect<A, never,
  * operation passed to `tapError` fails, that error is also represented in the
  * returned effect's error channel.
  *
- * **Example** (Usage)
+ * **Example** (Running effects on failure)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -5251,7 +5251,7 @@ export declare const tapError: {
      * operation passed to `tapError` fails, that error is also represented in the
      * returned effect's error channel.
      *
-     * **Example** (Usage)
+     * **Example** (Running effects on failure)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -5284,7 +5284,7 @@ export declare const tapError: {
      * operation passed to `tapError` fails, that error is also represented in the
      * returned effect's error channel.
      *
-     * **Example** (Usage)
+     * **Example** (Running effects on failure)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -5315,7 +5315,7 @@ export declare const tapError: {
  * 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.
  *
- * **Example** (Usage)
+ * **Example** (Running effects for tagged failures)
  *
  * ```ts
  * import { Console, Data, Effect } from "effect"
@@ -5351,7 +5351,7 @@ export declare const tapErrorTag: {
      * 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.
      *
-     * **Example** (Usage)
+     * **Example** (Running effects for tagged failures)
      *
      * ```ts
      * import { Console, Data, Effect } from "effect"
@@ -5387,7 +5387,7 @@ export declare const tapErrorTag: {
      * 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.
      *
-     * **Example** (Usage)
+     * **Example** (Running effects for tagged failures)
      *
      * ```ts
      * import { Console, Data, Effect } from "effect"
@@ -5427,7 +5427,7 @@ export declare const tapErrorTag: {
  * the operation succeeds, the original cause is preserved. If the operation
  * fails, its error is also represented in the returned effect.
  *
- * **Example** (Usage)
+ * **Example** (Observing full failure causes)
  *
  * ```ts
  * import { Cause, Console, Effect } from "effect"
@@ -5458,7 +5458,7 @@ export declare const tapCause: {
      * the operation succeeds, the original cause is preserved. If the operation
      * fails, its error is also represented in the returned effect.
      *
-     * **Example** (Usage)
+     * **Example** (Observing full failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -5489,7 +5489,7 @@ export declare const tapCause: {
      * the operation succeeds, the original cause is preserved. If the operation
      * fails, its error is also represented in the returned effect.
      *
-     * **Example** (Usage)
+     * **Example** (Observing full failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -5518,7 +5518,7 @@ export declare const tapCause: {
  * the cause matches a specific predicate. This is useful for conditional logging,
  * monitoring, or other side effects based on the type of failure.
  *
- * **Example** (Usage)
+ * **Example** (Observing selected failure causes)
  *
  * ```ts
  * import { Cause, Console, Effect } from "effect"
@@ -5548,7 +5548,7 @@ export declare const tapCauseIf: {
      * the cause matches a specific predicate. This is useful for conditional logging,
      * monitoring, or other side effects based on the type of failure.
      *
-     * **Example** (Usage)
+     * **Example** (Observing selected failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -5578,7 +5578,7 @@ export declare const tapCauseIf: {
      * the cause matches a specific predicate. This is useful for conditional logging,
      * monitoring, or other side effects based on the type of failure.
      *
-     * **Example** (Usage)
+     * **Example** (Observing selected failure causes)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -5634,7 +5634,7 @@ export declare const tapCauseFilter: {
  * operation succeeds, the original defect is preserved; if the operation fails,
  * its error is also represented in the returned effect.
  *
- * **Example** (Usage)
+ * **Example** (Observing defects)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -5682,7 +5682,7 @@ export declare const tapDefect: {
      * operation succeeds, the original defect is preserved; if the operation fails,
      * its error is also represented in the returned effect.
      *
-     * **Example** (Usage)
+     * **Example** (Observing defects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -5730,7 +5730,7 @@ export declare const tapDefect: {
      * operation succeeds, the original defect is preserved; if the operation fails,
      * its error is also represented in the returned effect.
      *
-     * **Example** (Usage)
+     * **Example** (Observing defects)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -5774,7 +5774,7 @@ export declare const tapDefect: {
  *
  * Yields between attempts so other fibers can run.
  *
- * **Example** (Usage)
+ * **Example** (Retrying until success)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -5867,7 +5867,7 @@ export declare namespace Retry {
  * Use `retry` when typed failures may be transient, such as network issues or
  * temporary resource unavailability.
  *
- * **Example** (Usage)
+ * **Example** (Retrying with a schedule)
  *
  * ```ts
  * import { Data, Effect, Schedule } from "effect"
@@ -5915,7 +5915,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -5963,7 +5963,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -6011,7 +6011,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -6059,7 +6059,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -6107,7 +6107,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -6155,7 +6155,7 @@ export declare const retry: {
      * Use `retry` when typed failures may be transient, such as network issues or
      * temporary resource unavailability.
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with a schedule)
      *
      * ```ts
      * import { Data, Effect, Schedule } from "effect"
@@ -6205,7 +6205,7 @@ export declare const retry: {
  *
  * @see {@link retry} for a version that does not run a fallback effect.
  *
- * **Example** (Usage)
+ * **Example** (Falling back after retries are exhausted)
  *
  * ```ts
  * import { Console, Data, Effect, Schedule } from "effect"
@@ -6263,7 +6263,7 @@ export declare const retryOrElse: {
      *
      * @see {@link retry} for a version that does not run a fallback effect.
      *
-     * **Example** (Usage)
+     * **Example** (Falling back after retries are exhausted)
      *
      * ```ts
      * import { Console, Data, Effect, Schedule } from "effect"
@@ -6321,7 +6321,7 @@ export declare const retryOrElse: {
      *
      * @see {@link retry} for a version that does not run a fallback effect.
      *
-     * **Example** (Usage)
+     * **Example** (Falling back after retries are exhausted)
      *
      * ```ts
      * import { Console, Data, Effect, Schedule } from "effect"
@@ -6371,7 +6371,7 @@ export declare const retryOrElse: {
  * failures, defects, and interruptions. Use `unsandbox` to restore the original
  * typed error channel after cause-level handling.
  *
- * **Example** (Usage)
+ * **Example** (Exposing failures as causes)
  *
  * ```ts
  * import { Cause, Effect } from "effect"
@@ -6406,7 +6406,7 @@ export declare const sandbox: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Caus
  * Use the `log` option to emit the full {@link Cause} when the effect fails,
  * and `message` to prepend a custom log message.
  *
- * **Example** (Using Effect.ignore to Discard Values)
+ * **Example** (Discarding success and failure values)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6450,7 +6450,7 @@ export declare const ignore: <Arg extends Effect<any, any, any> | {
  * Use the `log` option to emit the full {@link Cause} when the effect fails,
  * and `message` to prepend a custom log message.
  *
- * **Example** (Usage)
+ * **Example** (Ignoring failures and logging causes)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6482,7 +6482,7 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
  * and retry timing is derived per step (the first attempt uses the remaining
  * attempts schedule; later retries apply the step schedule at least once).
  *
- * **Example** (Usage)
+ * **Example** (Retrying with an execution plan)
  *
  * ```ts
  * import { Context, Effect, ExecutionPlan, Layer } from "effect"
@@ -6517,7 +6517,7 @@ export declare const withExecutionPlan: {
      * and retry timing is derived per step (the first attempt uses the remaining
      * attempts schedule; later retries apply the step schedule at least once).
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with an execution plan)
      *
      * ```ts
      * import { Context, Effect, ExecutionPlan, Layer } from "effect"
@@ -6557,7 +6557,7 @@ export declare const withExecutionPlan: {
      * and retry timing is derived per step (the first attempt uses the remaining
      * attempts schedule; later retries apply the step schedule at least once).
      *
-     * **Example** (Usage)
+     * **Example** (Retrying with an execution plan)
      *
      * ```ts
      * import { Context, Effect, ExecutionPlan, Layer } from "effect"
@@ -6617,7 +6617,7 @@ export declare const withErrorReporting: <Arg extends Effect<any, any, any> | {
  *
  * Defects and interruptions are not recovered by this operator.
  *
- * **Example** (Usage)
+ * **Example** (Replacing failures with a value)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6654,7 +6654,7 @@ export declare const orElseSucceed: {
      *
      * Defects and interruptions are not recovered by this operator.
      *
-     * **Example** (Usage)
+     * **Example** (Replacing failures with a value)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -6691,7 +6691,7 @@ export declare const orElseSucceed: {
      *
      * Defects and interruptions are not recovered by this operator.
      *
-     * **Example** (Usage)
+     * **Example** (Replacing failures with a value)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -6738,7 +6738,7 @@ export declare const orElseSucceed: {
  * attempting multiple APIs, reading configuration from several sources, or
  * trying alternative resource locations in order.
  *
- * **Example** (Usage)
+ * **Example** (Trying alternatives until one succeeds)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6775,7 +6775,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.
  *
- * **Example** (Usage)
+ * **Example** (Failing when work takes too long)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6821,7 +6821,7 @@ export declare const timeout: {
      *
      * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Failing when work takes too long)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -6867,7 +6867,7 @@ export declare const timeout: {
      *
      * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Failing when work takes too long)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -6916,7 +6916,7 @@ export declare const timeout: {
  * @see {@link timeout} for a version that raises a `TimeoutException`.
  * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
  *
- * **Example** (Usage)
+ * **Example** (Returning None on timeout)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -6962,7 +6962,7 @@ export declare const timeoutOption: {
      * @see {@link timeout} for a version that raises a `TimeoutException`.
      * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Returning None on timeout)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7008,7 +7008,7 @@ export declare const timeoutOption: {
      * @see {@link timeout} for a version that raises a `TimeoutException`.
      * @see {@link timeoutOrElse} for a version that allows specifying both success and timeout handlers.
      *
-     * **Example** (Usage)
+     * **Example** (Returning None on timeout)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7047,7 +7047,7 @@ export declare const timeoutOption: {
  * 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.
  *
- * **Example** (Usage)
+ * **Example** (Falling back on timeout)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -7085,7 +7085,7 @@ export declare const timeoutOrElse: {
      * 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.
      *
-     * **Example** (Usage)
+     * **Example** (Falling back on timeout)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -7126,7 +7126,7 @@ export declare const timeoutOrElse: {
      * 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.
      *
-     * **Example** (Usage)
+     * **Example** (Falling back on timeout)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -7166,7 +7166,7 @@ export declare const timeoutOrElse: {
  * Returns an effect that is delayed from this effect by the specified
  * `Duration`.
  *
- * **Example** (Usage)
+ * **Example** (Delaying an effect)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -7188,7 +7188,7 @@ export declare const delay: {
      * Returns an effect that is delayed from this effect by the specified
      * `Duration`.
      *
-     * **Example** (Usage)
+     * **Example** (Delaying an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -7210,7 +7210,7 @@ export declare const delay: {
      * Returns an effect that is delayed from this effect by the specified
      * `Duration`.
      *
-     * **Example** (Usage)
+     * **Example** (Delaying an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -7233,7 +7233,7 @@ export declare const delay: {
  * Returns an effect that suspends the current fiber for the specified duration
  * without blocking a JavaScript thread.
  *
- * **Example** (Usage)
+ * **Example** (Pausing without blocking)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -7259,7 +7259,7 @@ export declare const sleep: (duration: Duration.Input) => Effect<void>;
  * The original success, failure, or interruption is preserved; only the success
  * value is paired with the duration.
  *
- * **Example** (Usage)
+ * **Example** (Measuring execution time)
  *
  * ```ts
  * import { Console, Duration, Effect } from "effect"
@@ -7291,7 +7291,7 @@ export declare const timed: <A, E, R>(self: Effect<A, E, R>) => Effect<[duration
  *
  * @see {@link race} for a version that handles only two effects.
  *
- * **Example** (Usage)
+ * **Example** (Racing many effects)
  *
  * ```ts
  * import { Duration, Effect } from "effect"
@@ -7327,7 +7327,7 @@ export declare const raceAll: <Eff extends Effect<any, any, any>>(all: Iterable<
  * `raceAll` when early failures should be ignored until a success occurs or
  * all effects fail.
  *
- * **Example** (Usage)
+ * **Example** (Taking the first settled result)
  *
  * ```ts
  * import { Duration, Effect } from "effect"
@@ -7359,7 +7359,7 @@ export declare const raceAllFirst: <Eff extends Effect<any, any, any>>(all: Iter
  * If one effect succeeds, the other is interrupted and `onWinner` can observe the
  * winning fiber. If both fail, the race fails.
  *
- * **Example** (Usage)
+ * **Example** (Racing two effects)
  *
  * ```ts
  * import { Console, Duration, Effect } from "effect"
@@ -7386,7 +7386,7 @@ export declare const race: {
      * If one effect succeeds, the other is interrupted and `onWinner` can observe the
      * winning fiber. If both fail, the race fails.
      *
-     * **Example** (Usage)
+     * **Example** (Racing two effects)
      *
      * ```ts
      * import { Console, Duration, Effect } from "effect"
@@ -7419,7 +7419,7 @@ export declare const race: {
      * If one effect succeeds, the other is interrupted and `onWinner` can observe the
      * winning fiber. If both fail, the race fails.
      *
-     * **Example** (Usage)
+     * **Example** (Racing two effects)
      *
      * ```ts
      * import { Console, Duration, Effect } from "effect"
@@ -7453,7 +7453,7 @@ export declare const race: {
  *
  * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
  *
- * **Example** (Usage)
+ * **Example** (Observing the winning fiber)
  *
  * ```ts
  * import { Console, Duration, Effect } from "effect"
@@ -7483,7 +7483,7 @@ export declare const raceFirst: {
      *
      * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
      *
-     * **Example** (Usage)
+     * **Example** (Observing the winning fiber)
      *
      * ```ts
      * import { Console, Duration, Effect } from "effect"
@@ -7519,7 +7519,7 @@ export declare const raceFirst: {
      *
      * The losing effect is interrupted, and `onWinner` can observe the winning fiber.
      *
-     * **Example** (Usage)
+     * **Example** (Observing the winning fiber)
      *
      * ```ts
      * import { Console, Duration, Effect } from "effect"
@@ -7554,7 +7554,7 @@ export declare const raceFirst: {
  * Filters elements of an iterable using a predicate, refinement, or effectful
  * predicate.
  *
- * **Example** (Usage)
+ * **Example** (Filtering success values)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -7576,7 +7576,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7598,7 +7598,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7620,7 +7620,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7644,7 +7644,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7666,7 +7666,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7688,7 +7688,7 @@ export declare const filter: {
      * Filters elements of an iterable using a predicate, refinement, or effectful
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering success values)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7767,7 +7767,7 @@ export declare const filterMapEffect: {
  * `orElse` effect can produce an alternative value or perform additional
  * computations.
  *
- * **Example** (Usage)
+ * **Example** (Filtering with a fallback effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -7799,7 +7799,7 @@ export declare const filterOrElse: {
      * `orElse` effect can produce an alternative value or perform additional
      * computations.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a fallback effect)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7831,7 +7831,7 @@ export declare const filterOrElse: {
      * `orElse` effect can produce an alternative value or perform additional
      * computations.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a fallback effect)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7863,7 +7863,7 @@ export declare const filterOrElse: {
      * `orElse` effect can produce an alternative value or perform additional
      * computations.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a fallback effect)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7895,7 +7895,7 @@ export declare const filterOrElse: {
      * `orElse` effect can produce an alternative value or perform additional
      * computations.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a fallback effect)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -7949,7 +7949,7 @@ export declare const filterMapOrElse: {
  * predicate evaluates to `false`, the effect fails with either a custom
  * error (if `orFailWith` is provided) or a `NoSuchElementError`.
  *
- * **Example** (Usage)
+ * **Example** (Filtering with a custom failure)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -7980,7 +7980,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8011,7 +8011,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8042,7 +8042,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8073,7 +8073,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8104,7 +8104,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8135,7 +8135,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8166,7 +8166,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8197,7 +8197,7 @@ export declare const filterOrFail: {
      * predicate evaluates to `false`, the effect fails with either a custom
      * error (if `orFailWith` is provided) or a `NoSuchElementError`.
      *
-     * **Example** (Usage)
+     * **Example** (Filtering with a custom failure)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8272,7 +8272,7 @@ export declare const filterMapOrFail: {
  * Use this when an effectful check decides whether to run another effect while
  * representing the skipped case explicitly.
  *
- * **Example** (Usage)
+ * **Example** (Conditionally running an effect)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -8311,7 +8311,7 @@ export declare const when: {
      * Use this when an effectful check decides whether to run another effect while
      * representing the skipped case explicitly.
      *
-     * **Example** (Usage)
+     * **Example** (Conditionally running an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -8350,7 +8350,7 @@ export declare const when: {
      * Use this when an effectful check decides whether to run another effect while
      * representing the skipped case explicitly.
      *
-     * **Example** (Usage)
+     * **Example** (Conditionally running an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -8392,7 +8392,7 @@ export declare const when: {
  *
  * @see {@link matchEffect} if you need to perform side effects in the handlers.
  *
- * **Example** (Handling Both Success and Failure Cases)
+ * **Example** (Matching success and failure values)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -8446,7 +8446,7 @@ export declare const match: {
      *
      * @see {@link matchEffect} if you need to perform side effects in the handlers.
      *
-     * **Example** (Handling Both Success and Failure Cases)
+     * **Example** (Matching success and failure values)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -8503,7 +8503,7 @@ export declare const match: {
      *
      * @see {@link matchEffect} if you need to perform side effects in the handlers.
      *
-     * **Example** (Handling Both Success and Failure Cases)
+     * **Example** (Matching success and failure values)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -8560,7 +8560,7 @@ export declare const match: {
  * optimal performance for resolved effects. This is particularly useful in
  * scenarios where you frequently work with already computed values.
  *
- * **Example** (Usage)
+ * **Example** (Pattern matching eagerly when possible)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -8598,7 +8598,7 @@ export declare const matchEager: {
      * optimal performance for resolved effects. This is particularly useful in
      * scenarios where you frequently work with already computed values.
      *
-     * **Example** (Usage)
+     * **Example** (Pattern matching eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8639,7 +8639,7 @@ export declare const matchEager: {
      * optimal performance for resolved effects. This is particularly useful in
      * scenarios where you frequently work with already computed values.
      *
-     * **Example** (Usage)
+     * **Example** (Pattern matching eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8678,7 +8678,7 @@ export declare const matchEager: {
  * regular failures, defects, or interruptions. You can provide specific
  * handling logic for each failure type based on the cause.
  *
- * **Example** (Usage)
+ * **Example** (Matching on success or failure causes)
  *
  * ```ts
  * import { Cause, Effect } from "effect"
@@ -8716,7 +8716,7 @@ export declare const matchCause: {
      * regular failures, defects, or interruptions. You can provide specific
      * handling logic for each failure type based on the cause.
      *
-     * **Example** (Usage)
+     * **Example** (Matching on success or failure causes)
      *
      * ```ts
      * import { Cause, Effect } from "effect"
@@ -8757,7 +8757,7 @@ export declare const matchCause: {
      * regular failures, defects, or interruptions. You can provide specific
      * handling logic for each failure type based on the cause.
      *
-     * **Example** (Usage)
+     * **Example** (Matching on success or failure causes)
      *
      * ```ts
      * import { Cause, Effect } from "effect"
@@ -8800,7 +8800,7 @@ export declare const matchCause: {
  * and you want to avoid the overhead of the effect pipeline. For pending effects,
  * it automatically falls back to the regular `matchCause` behavior.
  *
- * **Example** (Usage)
+ * **Example** (Eagerly matching already completed effects)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -8830,7 +8830,7 @@ export declare const matchCauseEager: {
      * and you want to avoid the overhead of the effect pipeline. For pending effects,
      * it automatically falls back to the regular `matchCause` behavior.
      *
-     * **Example** (Usage)
+     * **Example** (Eagerly matching already completed effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8863,7 +8863,7 @@ export declare const matchCauseEager: {
      * and you want to avoid the overhead of the effect pipeline. For pending effects,
      * it automatically falls back to the regular `matchCause` behavior.
      *
-     * **Example** (Usage)
+     * **Example** (Eagerly matching already completed effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -8931,7 +8931,7 @@ export declare const matchCauseEffectEager: {
  * you to respond accordingly while performing side effects (like logging or
  * other operations).
  *
- * **Example** (Usage)
+ * **Example** (Effectfully matching on causes)
  *
  * ```ts
  * import { Cause, Console, Data, Effect, Result } from "effect"
@@ -8986,7 +8986,7 @@ export declare const matchCauseEffect: {
      * you to respond accordingly while performing side effects (like logging or
      * other operations).
      *
-     * **Example** (Usage)
+     * **Example** (Effectfully matching on causes)
      *
      * ```ts
      * import { Cause, Console, Data, Effect, Result } from "effect"
@@ -9044,7 +9044,7 @@ export declare const matchCauseEffect: {
      * you to respond accordingly while performing side effects (like logging or
      * other operations).
      *
-     * **Example** (Usage)
+     * **Example** (Effectfully matching on causes)
      *
      * ```ts
      * import { Cause, Console, Data, Effect, Result } from "effect"
@@ -9107,7 +9107,7 @@ export declare const matchCauseEffect: {
  * @see {@link match} if you don't need side effects and only want to handle the
  * result or failure.
  *
- * **Example** (Handling Both Success and Failure Cases with Side Effects)
+ * **Example** (Matching success and failure with effectful handlers)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -9168,7 +9168,7 @@ export declare const matchEffect: {
      * @see {@link match} if you don't need side effects and only want to handle the
      * result or failure.
      *
-     * **Example** (Handling Both Success and Failure Cases with Side Effects)
+     * **Example** (Matching success and failure with effectful handlers)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -9232,7 +9232,7 @@ export declare const matchEffect: {
      * @see {@link match} if you don't need side effects and only want to handle the
      * result or failure.
      *
-     * **Example** (Handling Both Success and Failure Cases with Side Effects)
+     * **Example** (Matching success and failure with effectful handlers)
      *
      * ```ts
      * import { Data, Effect } from "effect"
@@ -9339,7 +9339,7 @@ export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
  * in the effect's environment. This can be useful for debugging, introspection,
  * or when you need to pass the entire context to another function.
  *
- * **Example** (Usage)
+ * **Example** (Reading the full context)
  *
  * ```ts
  * import { Console, Context, Effect, Option } from "effect"
@@ -9379,7 +9379,7 @@ export declare const context: <R = never>() => Effect<Context.Context<R>, never,
  * computations based on all available services. This is useful when you need
  * to conditionally execute logic based on what services are available.
  *
- * **Example** (Usage)
+ * **Example** (Deriving values from the context)
  *
  * ```ts
  * import { Console, Context, Effect, Option } from "effect"
@@ -9423,7 +9423,7 @@ export declare const contextWith: <R, A, E, R2>(f: (context: Context.Context<R>)
  * to build the layer every time; by default, layers are shared between provide
  * calls.
  *
- * **Example** (Usage)
+ * **Example** (Providing dependencies with a layer)
  *
  * ```ts
  * import { Context, Effect, Layer } from "effect"
@@ -9458,7 +9458,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9495,7 +9495,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9532,7 +9532,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9567,7 +9567,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9604,7 +9604,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9641,7 +9641,7 @@ export declare const provide: {
      * to build the layer every time; by default, layers are shared between provide
      * calls.
      *
-     * **Example** (Usage)
+     * **Example** (Providing dependencies with a layer)
      *
      * ```ts
      * import { Context, Effect, Layer } from "effect"
@@ -9681,7 +9681,7 @@ export declare const provide: {
  * that contains all the required services. It removes the provided services
  * from the effect's requirements, making them available to the effect.
  *
- * **Example** (Usage)
+ * **Example** (Providing a complete context)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -9722,7 +9722,7 @@ export declare const provideContext: {
      * that contains all the required services. It removes the provided services
      * from the effect's requirements, making them available to the effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a complete context)
      *
      * ```ts
      * import { Context, Effect } from "effect"
@@ -9763,7 +9763,7 @@ export declare const provideContext: {
      * that contains all the required services. It removes the provided services
      * from the effect's requirements, making them available to the effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a complete context)
      *
      * ```ts
      * import { Context, Effect } from "effect"
@@ -9799,7 +9799,7 @@ export declare const provideContext: {
 /**
  * Accesses a service from the context.
  *
- * **Example** (Usage)
+ * **Example** (Accessing a required service)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -9830,7 +9830,7 @@ export declare const service: <I, S>(service: Context.Key<I, S>) => Effect<S, ne
  * available, it returns `None`. Unlike `service`, this function does not
  * require the service to be present in the environment.
  *
- * **Example** (Usage)
+ * **Example** (Accessing an optional service)
  *
  * ```ts
  * import { Context, Effect, Option } from "effect"
@@ -9864,7 +9864,7 @@ export declare const serviceOption: <I, S>(key: Context.Key<I, S>) => Effect<Opt
  * This function allows you to transform the context required by an effect,
  * providing part of the context and leaving the rest to be fulfilled later.
  *
- * **Example** (Usage)
+ * **Example** (Updating the context before running)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -9906,7 +9906,7 @@ export declare const updateContext: {
      * This function allows you to transform the context required by an effect,
      * providing part of the context and leaving the rest to be fulfilled later.
      *
-     * **Example** (Usage)
+     * **Example** (Updating the context before running)
      *
      * ```ts
      * import { Context, Effect } from "effect"
@@ -9948,7 +9948,7 @@ export declare const updateContext: {
      * This function allows you to transform the context required by an effect,
      * providing part of the context and leaving the rest to be fulfilled later.
      *
-     * **Example** (Usage)
+     * **Example** (Updating the context before running)
      *
      * ```ts
      * import { Context, Effect } from "effect"
@@ -9990,7 +9990,7 @@ export declare const updateContext: {
  * The service must be available in the effect's context; `updateService`
  * replaces it for the wrapped effect with the value returned by the updater.
  *
- * **Example** (Usage)
+ * **Example** (Replacing a service for one effect)
  *
  * ```ts
  * import { Console, Context, Effect } from "effect"
@@ -10024,7 +10024,7 @@ export declare const updateService: {
      * The service must be available in the effect's context; `updateService`
      * replaces it for the wrapped effect with the value returned by the updater.
      *
-     * **Example** (Usage)
+     * **Example** (Replacing a service for one effect)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10058,7 +10058,7 @@ export declare const updateService: {
      * The service must be available in the effect's context; `updateService`
      * replaces it for the wrapped effect with the value returned by the updater.
      *
-     * **Example** (Usage)
+     * **Example** (Replacing a service for one effect)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10098,7 +10098,7 @@ export declare const updateService: {
  *
  * @see {@link provide} for providing multiple layers to an effect.
  *
- * **Example** (Usage)
+ * **Example** (Providing a service value)
  *
  * ```ts
  * import { Console, Context, Effect } from "effect"
@@ -10145,7 +10145,7 @@ export declare const provideService: {
      *
      * @see {@link provide} for providing multiple layers to an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a service value)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10192,7 +10192,7 @@ export declare const provideService: {
          *
          * @see {@link provide} for providing multiple layers to an effect.
          *
-         * **Example** (Usage)
+         * **Example** (Providing a service value)
          *
          * ```ts
          * import { Console, Context, Effect } from "effect"
@@ -10239,7 +10239,7 @@ export declare const provideService: {
          *
          * @see {@link provide} for providing multiple layers to an effect.
          *
-         * **Example** (Usage)
+         * **Example** (Providing a service value)
          *
          * ```ts
          * import { Console, Context, Effect } from "effect"
@@ -10287,7 +10287,7 @@ export declare const provideService: {
      *
      * @see {@link provide} for providing multiple layers to an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a service value)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10334,7 +10334,7 @@ export declare const provideService: {
      *
      * @see {@link provide} for providing multiple layers to an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a service value)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10380,7 +10380,7 @@ export declare const provideService: {
  * and leaves any other requirements to be provided later. Acquisition failures
  * are included in the returned effect's error channel.
  *
- * **Example** (Usage)
+ * **Example** (Providing a service with an effect)
  *
  * ```ts
  * import { Console, Context, Effect } from "effect"
@@ -10434,7 +10434,7 @@ export declare const provideServiceEffect: {
      * and leaves any other requirements to be provided later. Acquisition failures
      * are included in the returned effect's error channel.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a service with an effect)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10488,7 +10488,7 @@ export declare const provideServiceEffect: {
      * and leaves any other requirements to be provided later. Acquisition failures
      * are included in the returned effect's error channel.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a service with an effect)
      *
      * ```ts
      * import { Console, Context, Effect } from "effect"
@@ -10536,7 +10536,7 @@ export declare const provideServiceEffect: {
 /**
  * Sets the concurrency level for parallel operations within an effect.
  *
- * **Example** (Usage)
+ * **Example** (Setting local concurrency)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -10569,7 +10569,7 @@ export declare const withConcurrency: {
     /**
      * Sets the concurrency level for parallel operations within an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Setting local concurrency)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -10602,7 +10602,7 @@ export declare const withConcurrency: {
     /**
      * Sets the concurrency level for parallel operations within an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Setting local concurrency)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -10636,7 +10636,7 @@ export declare const withConcurrency: {
 /**
  * Returns the current scope for resource management.
  *
- * **Example** (Usage)
+ * **Example** (Accessing the current scope)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -10671,7 +10671,7 @@ export declare const scope: Effect<Scope, never, Scope>;
  * ensuring that their finalizers are run as soon as this workflow completes
  * execution, whether by success, failure, or interruption.
  *
- * **Example** (Usage)
+ * **Example** (Running a scoped acquisition)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -10702,7 +10702,7 @@ export declare const scoped: <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Ex
 /**
  * Creates a scoped effect by providing access to the scope.
  *
- * **Example** (Usage)
+ * **Example** (Working with an explicit scope)
  *
  * ```ts
  * import { Console, Effect, Scope } from "effect"
@@ -10752,7 +10752,7 @@ export declare const scopedWith: <A, E, R>(f: (scope: Scope) => Effect<A, E, R>)
  * By default, acquisition is protected by an uninterruptible region. Pass
  * `{ interruptible: true }` to allow the acquisition effect to be interrupted.
  *
- * **Example** (Usage)
+ * **Example** (Acquiring and releasing a resource)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -10811,7 +10811,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)
  *
- * **Example** (Usage)
+ * **Example** (Acquiring a disposable resource)
  *
  * ```ts
  * import sqlite from "node:sqlite";
@@ -10858,7 +10858,7 @@ export declare const acquireDisposable: <A extends AsyncDisposable | Disposable,
  * is not desired, errors produced by the `release` `Effect` value can be caught
  * and ignored.
  *
- * **Example** (Usage)
+ * **Example** (Using a resource with cleanup)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -10917,7 +10917,7 @@ export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acqu
  * whether the effect succeeds or fails. They're commonly used for resource
  * cleanup, logging, or other side effects that should always occur.
  *
- * **Example** (Usage)
+ * **Example** (Registering scope finalizers)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -10962,7 +10962,7 @@ export declare const addFinalizer: <R>(finalizer: (exit: Exit.Exit<unknown, unkn
  * should generally not be used for releasing resources. For higher-level
  * logic built on `ensuring`, see the `acquireRelease` family of methods.
  *
- * **Example** (Usage)
+ * **Example** (Always running cleanup)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -11003,7 +11003,7 @@ export declare const ensuring: {
      * should generally not be used for releasing resources. For higher-level
      * logic built on `ensuring`, see the `acquireRelease` family of methods.
      *
-     * **Example** (Usage)
+     * **Example** (Always running cleanup)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11044,7 +11044,7 @@ export declare const ensuring: {
      * should generally not be used for releasing resources. For higher-level
      * logic built on `ensuring`, see the `acquireRelease` family of methods.
      *
-     * **Example** (Usage)
+     * **Example** (Always running cleanup)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11079,7 +11079,7 @@ export declare const ensuring: {
  * Runs the specified effect if this effect fails, providing the error to the
  * effect if it exists. The provided effect will not be interrupted.
  *
- * **Example** (Usage)
+ * **Example** (Running cleanup on failure)
  *
  * ```ts
  * import { Cause, Console, Data, Effect } from "effect"
@@ -11107,7 +11107,7 @@ export declare const onError: {
      * Runs the specified effect if this effect fails, providing the error to the
      * effect if it exists. The provided effect will not be interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup on failure)
      *
      * ```ts
      * import { Cause, Console, Data, Effect } from "effect"
@@ -11135,7 +11135,7 @@ export declare const onError: {
      * Runs the specified effect if this effect fails, providing the error to the
      * effect if it exists. The provided effect will not be interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup on failure)
      *
      * ```ts
      * import { Cause, Console, Data, Effect } from "effect"
@@ -11164,7 +11164,7 @@ export declare const onError: {
  * Runs the finalizer only when this effect fails and the `Cause` matches the
  * provided predicate.
  *
- * **Example** (Usage)
+ * **Example** (Running cleanup for selected failures)
  *
  * ```ts
  * import { Cause, Console, Effect } from "effect"
@@ -11189,7 +11189,7 @@ export declare const onErrorIf: {
      * Runs the finalizer only when this effect fails and the `Cause` matches the
      * provided predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup for selected failures)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -11214,7 +11214,7 @@ export declare const onErrorIf: {
      * Runs the finalizer only when this effect fails and the `Cause` matches the
      * provided predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup for selected failures)
      *
      * ```ts
      * import { Cause, Console, Effect } from "effect"
@@ -11275,7 +11275,7 @@ export declare const onExitPrimitive: <A, E, R, XE = never, XR = never>(self: Ef
  * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
  * or is interrupted.
  *
- * **Example** (Usage)
+ * **Example** (Observing every exit)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -11303,7 +11303,7 @@ export declare const onExit: {
      * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
      * or is interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Observing every exit)
      *
      * ```ts
      * import { Console, Effect, Exit } from "effect"
@@ -11331,7 +11331,7 @@ export declare const onExit: {
      * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
      * or is interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Observing every exit)
      *
      * ```ts
      * import { Console, Effect, Exit } from "effect"
@@ -11360,7 +11360,7 @@ export declare const onExit: {
  * Runs the cleanup effect only when the `Exit` satisfies the provided
  * predicate.
  *
- * **Example** (Usage)
+ * **Example** (Observing selected exits)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -11383,7 +11383,7 @@ export declare const onExitIf: {
      * Runs the cleanup effect only when the `Exit` satisfies the provided
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Observing selected exits)
      *
      * ```ts
      * import { Console, Effect, Exit } from "effect"
@@ -11406,7 +11406,7 @@ export declare const onExitIf: {
      * Runs the cleanup effect only when the `Exit` satisfies the provided
      * predicate.
      *
-     * **Example** (Usage)
+     * **Example** (Observing selected exits)
      *
      * ```ts
      * import { Console, Effect, Exit } from "effect"
@@ -11471,7 +11471,7 @@ export declare const onExitFilter: {
  * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
  * additional effect for manually invalidating the cached value.
  *
- * **Example** (Usage)
+ * **Example** (Memoizing an effect until invalidated)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -11545,7 +11545,7 @@ export declare const cached: <A, E, R>(self: Effect<A, E, R>) => Effect<Effect<A
  * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
  * additional effect for manually invalidating the cached value.
  *
- * **Example** (Usage)
+ * **Example** (Memoizing an effect with TTL)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -11613,7 +11613,7 @@ export declare const cachedWithTTL: {
      * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
      * additional effect for manually invalidating the cached value.
      *
-     * **Example** (Usage)
+     * **Example** (Memoizing an effect with TTL)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11681,7 +11681,7 @@ export declare const cachedWithTTL: {
      * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
      * additional effect for manually invalidating the cached value.
      *
-     * **Example** (Usage)
+     * **Example** (Memoizing an effect with TTL)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11750,7 +11750,7 @@ export declare const cachedWithTTL: {
  * @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** (Usage)
+ * **Example** (Memoizing with TTL and invalidation)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -11821,7 +11821,7 @@ export declare const cachedInvalidateWithTTL: {
      * @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** (Usage)
+     * **Example** (Memoizing with TTL and invalidation)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11892,7 +11892,7 @@ export declare const cachedInvalidateWithTTL: {
      * @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** (Usage)
+     * **Example** (Memoizing with TTL and invalidation)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -11935,7 +11935,7 @@ export declare const cachedInvalidateWithTTL: {
 /**
  * Returns an effect that is immediately interrupted.
  *
- * **Example** (Usage)
+ * **Example** (Creating an interrupted effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -11956,7 +11956,7 @@ export declare const interrupt: Effect<never>;
 /**
  * Returns a new effect that allows the effect to be interruptible.
  *
- * **Example** (Usage)
+ * **Example** (Allowing interruption)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -11977,7 +11977,7 @@ export declare const interruptible: <A, E, R>(self: Effect<A, E, R>) => Effect<A
 /**
  * Runs the specified finalizer effect if this effect is interrupted.
  *
- * **Example** (Usage)
+ * **Example** (Running cleanup on interruption)
  *
  * ```ts
  * import { Console, Effect, Fiber } from "effect"
@@ -12002,7 +12002,7 @@ export declare const onInterrupt: {
     /**
      * Runs the specified finalizer effect if this effect is interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup on interruption)
      *
      * ```ts
      * import { Console, Effect, Fiber } from "effect"
@@ -12027,7 +12027,7 @@ export declare const onInterrupt: {
     /**
      * Runs the specified finalizer effect if this effect is interrupted.
      *
-     * **Example** (Usage)
+     * **Example** (Running cleanup on interruption)
      *
      * ```ts
      * import { Console, Effect, Fiber } from "effect"
@@ -12053,7 +12053,7 @@ export declare const onInterrupt: {
 /**
  * Returns a new effect that disables interruption for the given effect.
  *
- * **Example** (Usage)
+ * **Example** (Preventing interruption)
  *
  * ```ts
  * import { Console, Effect, Fiber } from "effect"
@@ -12079,7 +12079,7 @@ export declare const uninterruptible: <A, E, R>(self: Effect<A, E, R>) => Effect
  * Disables interruption and provides a restore function to restore the
  * interruptible state within the effect.
  *
- * **Example** (Usage)
+ * **Example** (Restoring interruption in protected regions)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -12111,7 +12111,7 @@ export declare const uninterruptibleMask: <A, E, R>(f: (restore: <AX, EX, RX>(ef
  * `restore` function. This function can be used to restore the interruptibility
  * of any specific region of code.
  *
- * **Example** (Usage)
+ * **Example** (Controlling interruptibility locally)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -12190,7 +12190,7 @@ export declare namespace Repeat {
 /**
  * Repeats this effect forever (until the first error).
  *
- * **Example** (Usage)
+ * **Example** (Repeating forever)
  *
  * ```ts
  * import { Console, Effect, Fiber } from "effect"
@@ -12246,7 +12246,7 @@ export declare const forever: <Arg extends Effect<any, any, any> | {
  * delays, limiting recursions, or dynamically adjusting based on the outcome of
  * each execution.
  *
- * **Example** (Usage)
+ * **Example** (Repeating successful effects with a schedule)
  *
  * ```ts
  * // Success Example
@@ -12259,7 +12259,7 @@ export declare const forever: <Arg extends Effect<any, any, any> | {
  * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Stopping repetition on failure)
  *
  * ```ts
  * // Failure Example
@@ -12311,7 +12311,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12324,7 +12324,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12376,7 +12376,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12389,7 +12389,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12441,7 +12441,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12454,7 +12454,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12506,7 +12506,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12519,7 +12519,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12571,7 +12571,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12584,7 +12584,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12636,7 +12636,7 @@ export declare const repeat: {
      * delays, limiting recursions, or dynamically adjusting based on the outcome of
      * each execution.
      *
-     * **Example** (Usage)
+     * **Example** (Repeating successful effects with a schedule)
      *
      * ```ts
      * // Success Example
@@ -12649,7 +12649,7 @@ export declare const repeat: {
      * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Stopping repetition on failure)
      *
      * ```ts
      * // Failure Example
@@ -12691,7 +12691,7 @@ export declare const repeat: {
  * otherwise it receives `None`. If the schedule completes normally, the
  * returned effect succeeds with the schedule's output.
  *
- * **Example** (Usage)
+ * **Example** (Recovering after repetition stops)
  *
  * ```ts
  * import { Console, Effect, Option, Schedule } from "effect"
@@ -12734,7 +12734,7 @@ export declare const repeatOrElse: {
      * otherwise it receives `None`. If the schedule completes normally, the
      * returned effect succeeds with the schedule's output.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering after repetition stops)
      *
      * ```ts
      * import { Console, Effect, Option, Schedule } from "effect"
@@ -12777,7 +12777,7 @@ export declare const repeatOrElse: {
      * otherwise it receives `None`. If the schedule completes normally, the
      * returned effect succeeds with the schedule's output.
      *
-     * **Example** (Usage)
+     * **Example** (Recovering after repetition stops)
      *
      * ```ts
      * import { Console, Effect, Option, Schedule } from "effect"
@@ -12843,7 +12843,7 @@ export declare const replicate: {
  *
  * Use `concurrency` to control parallelism and `discard: true` to ignore results.
  *
- * **Example** (Usage)
+ * **Example** (Replicating an effect)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -12863,7 +12863,7 @@ export declare const replicateEffect: {
      *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
-     * **Example** (Usage)
+     * **Example** (Replicating an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -12886,7 +12886,7 @@ export declare const replicateEffect: {
      *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
-     * **Example** (Usage)
+     * **Example** (Replicating an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -12909,7 +12909,7 @@ export declare const replicateEffect: {
      *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
-     * **Example** (Usage)
+     * **Example** (Replicating an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -12932,7 +12932,7 @@ export declare const replicateEffect: {
      *
      * Use `concurrency` to control parallelism and `discard: true` to ignore results.
      *
-     * **Example** (Usage)
+     * **Example** (Replicating an effect)
      *
      * ```ts
      * import { Console, Effect } from "effect"
@@ -12963,7 +12963,7 @@ export declare const replicateEffect: {
  * fails, and otherwise succeeds with the schedule output when the schedule
  * completes.
  *
- * **Example** (Usage)
+ * **Example** (Scheduling repeated execution)
  *
  * ```ts
  * import { Console, Effect, Schedule } from "effect"
@@ -13006,7 +13006,7 @@ export declare const schedule: {
      * fails, and otherwise succeeds with the schedule output when the schedule
      * completes.
      *
-     * **Example** (Usage)
+     * **Example** (Scheduling repeated execution)
      *
      * ```ts
      * import { Console, Effect, Schedule } from "effect"
@@ -13049,7 +13049,7 @@ export declare const schedule: {
      * fails, and otherwise succeeds with the schedule output when the schedule
      * completes.
      *
-     * **Example** (Usage)
+     * **Example** (Scheduling repeated execution)
      *
      * ```ts
      * import { Console, Effect, Schedule } from "effect"
@@ -13093,7 +13093,7 @@ export declare const schedule: {
  * succeeds with the schedule output when the schedule completes and fails if
  * the effect or schedule fails.
  *
- * **Example** (Usage)
+ * **Example** (Scheduling from an initial value)
  *
  * ```ts
  * import { Console, Effect, Schedule } from "effect"
@@ -13131,7 +13131,7 @@ export declare const scheduleFrom: {
      * succeeds with the schedule output when the schedule completes and fails if
      * the effect or schedule fails.
      *
-     * **Example** (Usage)
+     * **Example** (Scheduling from an initial value)
      *
      * ```ts
      * import { Console, Effect, Schedule } from "effect"
@@ -13169,7 +13169,7 @@ export declare const scheduleFrom: {
      * succeeds with the schedule output when the schedule completes and fails if
      * the effect or schedule fails.
      *
-     * **Example** (Usage)
+     * **Example** (Scheduling from an initial value)
      *
      * ```ts
      * import { Console, Effect, Schedule } from "effect"
@@ -13199,7 +13199,7 @@ export declare const scheduleFrom: {
 /**
  * Returns the current tracer from the context.
  *
- * **Example** (Usage)
+ * **Example** (Accessing the current tracer)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13218,7 +13218,7 @@ export declare const tracer: Effect<Tracer>;
 /**
  * Provides a tracer to an effect.
  *
- * **Example** (Usage)
+ * **Example** (Providing a tracer)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13239,7 +13239,7 @@ export declare const withTracer: {
     /**
      * Provides a tracer to an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a tracer)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13260,7 +13260,7 @@ export declare const withTracer: {
     /**
      * Provides a tracer to an effect.
      *
-     * **Example** (Usage)
+     * **Example** (Providing a tracer)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13287,7 +13287,7 @@ export declare const withTracer: {
  * When `enabled` is `false`, spans created inside the effect are not registered
  * with the current tracer and do not propagate as normal trace parents.
  *
- * **Example** (Usage)
+ * **Example** (Enabling or disabling tracing)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13311,7 +13311,7 @@ export declare const withTracerEnabled: {
      * When `enabled` is `false`, spans created inside the effect are not registered
      * with the current tracer and do not propagate as normal trace parents.
      *
-     * **Example** (Usage)
+     * **Example** (Enabling or disabling tracing)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13335,7 +13335,7 @@ export declare const withTracerEnabled: {
      * When `enabled` is `false`, spans created inside the effect are not registered
      * with the current tracer and do not propagate as normal trace parents.
      *
-     * **Example** (Usage)
+     * **Example** (Enabling or disabling tracing)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13355,7 +13355,7 @@ export declare const withTracerEnabled: {
 /**
  * Enables or disables tracer timing for the given Effect.
  *
- * **Example** (Usage)
+ * **Example** (Enabling or disabling tracing timing)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13374,7 +13374,7 @@ export declare const withTracerTiming: {
     /**
      * Enables or disables tracer timing for the given Effect.
      *
-     * **Example** (Usage)
+     * **Example** (Enabling or disabling tracing timing)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13393,7 +13393,7 @@ export declare const withTracerTiming: {
     /**
      * Enables or disables tracer timing for the given Effect.
      *
-     * **Example** (Usage)
+     * **Example** (Enabling or disabling tracing timing)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13413,7 +13413,7 @@ export declare const withTracerTiming: {
 /**
  * Adds an annotation to each span in this effect.
  *
- * **Example** (Usage)
+ * **Example** (Annotating all spans)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13441,7 +13441,7 @@ export declare const annotateSpans: {
     /**
      * Adds an annotation to each span in this effect.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating all spans)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13469,7 +13469,7 @@ export declare const annotateSpans: {
     /**
      * Adds an annotation to each span in this effect.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating all spans)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13497,7 +13497,7 @@ export declare const annotateSpans: {
     /**
      * Adds an annotation to each span in this effect.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating all spans)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13525,7 +13525,7 @@ export declare const annotateSpans: {
     /**
      * Adds an annotation to each span in this effect.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating all spans)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13554,7 +13554,7 @@ export declare const annotateSpans: {
 /**
  * Adds an annotation to the current span if available.
  *
- * **Example** (Usage)
+ * **Example** (Annotating the current span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13579,7 +13579,7 @@ export declare const annotateCurrentSpan: {
     /**
      * Adds an annotation to the current span if available.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating the current span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13604,7 +13604,7 @@ export declare const annotateCurrentSpan: {
     /**
      * Adds an annotation to the current span if available.
      *
-     * **Example** (Usage)
+     * **Example** (Annotating the current span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13635,7 +13635,7 @@ export declare const annotateCurrentSpan: {
  * The effect fails with `NoSuchElementError` when there is no active local
  * `Span`.
  *
- * **Example** (Usage)
+ * **Example** (Reading the current span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13662,7 +13662,7 @@ export declare const currentSpan: Effect<Span, Cause.NoSuchElementError>;
  * present, and fails with `NoSuchElementError` when no parent span is
  * available.
  *
- * **Example** (Usage)
+ * **Example** (Reading the parent span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13693,7 +13693,7 @@ export declare const currentParentSpan: Effect<AnySpan, Cause.NoSuchElementError
  * These annotations are applied to spans created inside the context, such as
  * spans created by `withSpan`, `useSpan`, or `makeSpan`.
  *
- * **Example** (Usage)
+ * **Example** (Providing span annotations)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13726,7 +13726,7 @@ export declare const spanAnnotations: Effect<Readonly<Record<string, unknown>>>;
  * These links are attached to spans created inside the context. Span links
  * connect related spans without making one span the parent of another.
  *
- * **Example** (Usage)
+ * **Example** (Providing span links)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13750,7 +13750,7 @@ export declare const spanLinks: Effect<ReadonlyArray<SpanLink>>;
  * parent-child relationship. For example, you might want to link spans from
  * parallel operations or connect spans across different traces.
  *
- * **Example** (Usage)
+ * **Example** (Linking one span to another span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13773,7 +13773,7 @@ export declare const spanLinks: Effect<ReadonlyArray<SpanLink>>;
  * })
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Linking multiple spans at once)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13803,7 +13803,7 @@ export declare const linkSpans: {
      * parent-child relationship. For example, you might want to link spans from
      * parallel operations or connect spans across different traces.
      *
-     * **Example** (Usage)
+     * **Example** (Linking one span to another span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13826,7 +13826,7 @@ export declare const linkSpans: {
      * })
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Linking multiple spans at once)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13856,7 +13856,7 @@ export declare const linkSpans: {
      * parent-child relationship. For example, you might want to link spans from
      * parallel operations or connect spans across different traces.
      *
-     * **Example** (Usage)
+     * **Example** (Linking one span to another span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13879,7 +13879,7 @@ export declare const linkSpans: {
      * })
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Linking multiple spans at once)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -13912,7 +13912,7 @@ export declare const linkSpans: {
  * automatically. Use `withSpan`, `useSpan`, or `makeSpanScoped` when the span
  * should be installed as context or closed automatically.
  *
- * **Example** (Usage)
+ * **Example** (Creating a span manually)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13935,7 +13935,7 @@ export declare const makeSpan: (name: string, options?: SpanOptionsNoTrace) => E
  * The span is not added to the current span stack, so no child spans will be
  * created for it.
  *
- * **Example** (Usage)
+ * **Example** (Creating a scoped standalone span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13961,7 +13961,7 @@ export declare const makeSpanScoped: (name: string, options?: SpanOptionsNoTrace
  * The span is not added to the current span stack, so no child spans will be
  * created for it.
  *
- * **Example** (Usage)
+ * **Example** (Running an effect with a standalone span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -13987,7 +13987,7 @@ export declare const useSpan: {
      * The span is not added to the current span stack, so no child spans will be
      * created for it.
      *
-     * **Example** (Usage)
+     * **Example** (Running an effect with a standalone span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14013,7 +14013,7 @@ export declare const useSpan: {
      * The span is not added to the current span stack, so no child spans will be
      * created for it.
      *
-     * **Example** (Usage)
+     * **Example** (Running an effect with a standalone span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14036,7 +14036,7 @@ export declare const useSpan: {
 /**
  * Wraps the effect with a new span for tracing.
  *
- * **Example** (Usage)
+ * **Example** (Wrapping an effect in a child span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14058,7 +14058,7 @@ export declare const withSpan: {
     /**
      * Wraps the effect with a new span for tracing.
      *
-     * **Example** (Usage)
+     * **Example** (Wrapping an effect in a child span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14080,7 +14080,7 @@ export declare const withSpan: {
     /**
      * Wraps the effect with a new span for tracing.
      *
-     * **Example** (Usage)
+     * **Example** (Wrapping an effect in a child span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14105,7 +14105,7 @@ export declare const withSpan: {
  *
  * The span is ended when the Scope is finalized.
  *
- * **Example** (Usage)
+ * **Example** (Creating a scoped child span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14128,7 +14128,7 @@ export declare const withSpanScoped: {
      *
      * The span is ended when the Scope is finalized.
      *
-     * **Example** (Usage)
+     * **Example** (Creating a scoped child span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14151,7 +14151,7 @@ export declare const withSpanScoped: {
      *
      * The span is ended when the Scope is finalized.
      *
-     * **Example** (Usage)
+     * **Example** (Creating a scoped child span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14173,7 +14173,7 @@ export declare const withSpanScoped: {
 /**
  * Adds the provided span to the current span stack.
  *
- * **Example** (Usage)
+ * **Example** (Setting a parent span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14193,7 +14193,7 @@ export declare const withParentSpan: {
     /**
      * Adds the provided span to the current span stack.
      *
-     * **Example** (Usage)
+     * **Example** (Setting a parent span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14213,7 +14213,7 @@ export declare const withParentSpan: {
     /**
      * Adds the provided span to the current span stack.
      *
-     * **Example** (Usage)
+     * **Example** (Setting a parent span)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14237,7 +14237,7 @@ export declare const withParentSpan: {
  * @category Requests & Batching
  * @since 2.0.0
  *
- * **Example** (Usage)
+ * **Example** (Executing a request through a resolver)
  *
  * ```ts
  * import { Console, Effect, Exit, Request, RequestResolver } from "effect"
@@ -14269,7 +14269,7 @@ export declare const request: {
      * @category Requests & Batching
      * @since 2.0.0
      *
-     * **Example** (Usage)
+     * **Example** (Executing a request through a resolver)
      *
      * ```ts
      * import { Console, Effect, Exit, Request, RequestResolver } from "effect"
@@ -14301,7 +14301,7 @@ export declare const request: {
      * @category Requests & Batching
      * @since 2.0.0
      *
-     * **Example** (Usage)
+     * **Example** (Executing a request through a resolver)
      *
      * ```ts
      * import { Console, Effect, Exit, Request, RequestResolver } from "effect"
@@ -14363,7 +14363,7 @@ export declare const requestUnsafe: <A extends Request.Any>(self: A, options: {
  * fibers leak. This behavior is called "auto supervision", and if this
  * behavior is not desired, you may use the `forkDetach` or `forkIn` methods.
  *
- * **Example** (Usage)
+ * **Example** (Forking a child fiber)
  *
  * ```ts
  * import { Effect, Fiber } from "effect"
@@ -14403,7 +14403,7 @@ export declare const forkChild: <Arg extends Effect<any, any, any> | {
  * Forks the effect in the specified scope. The fiber will be interrupted
  * when the scope is closed.
  *
- * **Example** (Usage)
+ * **Example** (Forking into a supplied scope)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14432,7 +14432,7 @@ export declare const forkIn: {
      * Forks the effect in the specified scope. The fiber will be interrupted
      * when the scope is closed.
      *
-     * **Example** (Usage)
+     * **Example** (Forking into a supplied scope)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14464,7 +14464,7 @@ export declare const forkIn: {
      * Forks the effect in the specified scope. The fiber will be interrupted
      * when the scope is closed.
      *
-     * **Example** (Usage)
+     * **Example** (Forking into a supplied scope)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -14496,7 +14496,7 @@ export declare const forkIn: {
 /**
  * Forks the fiber in a `Scope`, interrupting it when the scope is closed.
  *
- * **Example** (Usage)
+ * **Example** (Forking into the current scope)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14541,7 +14541,7 @@ export declare const forkScoped: <Arg extends Effect<any, any, any> | {
  * new fiber is attached to the global scope, when the fiber executing the
  * returned effect terminates, the forked fiber will continue running.
  *
- * **Example** (Usage)
+ * **Example** (Forking a detached fiber)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14590,7 +14590,7 @@ export declare const awaitAllChildren: <A, E, R>(self: Effect<A, E, R>) => Effec
 /**
  * Access the fiber currently executing the effect.
  *
- * **Example** (Usage)
+ * **Example** (Accessing the current fiber)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -14608,7 +14608,7 @@ export declare const fiber: Effect<Fiber<unknown, unknown>>;
 /**
  * Access the current fiber id executing the effect.
  *
- * **Example** (Usage)
+ * **Example** (Accessing the current fiber id)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14654,7 +14654,7 @@ export interface RunOptions {
  * Unless you specifically need a `Promise` or synchronous operation,
  * `runFork` is a good default choice.
  *
- * **Example** (Running an Effect in the Background)
+ * **Example** (Running an effect in the background)
  *
  * ```ts
  * import { Console, Effect, Fiber, Schedule } from "effect"
@@ -14682,7 +14682,7 @@ export declare const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunO
 /**
  * Runs an effect in the background with the provided services.
  *
- * **Example** (Usage)
+ * **Example** (Running with services in the background)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -14715,7 +14715,7 @@ export declare const runForkWith: <R>(context: Context.Context<R>) => <A, E>(eff
  *
  * The returned interruptor calls `fiber.interruptUnsafe`, optionally with an interruptor id.
  *
- * **Example** (Usage)
+ * **Example** (Running with services and a callback)
  *
  * ```ts
  * import { Console, Context, Effect, Exit } from "effect"
@@ -14761,7 +14761,7 @@ export declare const runCallbackWith: <R>(context: Context.Context<R>) => <A, E>
  * The interruptor calls `fiber.interruptUnsafe` with the optional interruptor
  * id.
  *
- * **Example** (Usage)
+ * **Example** (Running with a callback)
  *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
@@ -14809,7 +14809,7 @@ export declare const runCallback: <A, E>(effect: Effect<A, E, never>, options?:
  *
  * @see {@link runPromiseExit} for a version that returns an `Exit` type instead of rejecting.
  *
- * **Example** (Running a Successful Effect as a Promise)
+ * **Example** (Running a successful effect as a Promise)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14818,7 +14818,7 @@ export declare const runCallback: <A, E>(effect: Effect<A, E, never>, options?:
  * // Output: 1
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Running effects as promises)
  *
  * ```ts
  * //Example: Handling a Failing Effect as a Rejected Promise
@@ -14836,7 +14836,7 @@ export declare const runPromise: <A, E>(effect: Effect<A, E>, options?: RunOptio
 /**
  * Executes an effect as a Promise with the provided services.
  *
- * **Example** (Usage)
+ * **Example** (Running with services as a promise)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -14879,7 +14879,7 @@ export declare const runPromiseWith: <R>(context: Context.Context<R>) => <A, E>(
  * - If it fails, the failure information is provided as a `Failure` containing
  *   a `Cause` type.
  *
- * **Example** (Handling Results as Exit)
+ * **Example** (Observing promise results as Exit)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14914,7 +14914,7 @@ export declare const runPromiseExit: <A, E>(effect: Effect<A, E>, options?: RunO
 /**
  * Runs an effect and returns a Promise of Exit with provided services.
  *
- * **Example** (Usage)
+ * **Example** (Running with services as an Exit promise)
  *
  * ```ts
  * import { Context, Effect, Exit } from "effect"
@@ -14961,7 +14961,7 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
  * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
  * throwing an error.
  *
- * **Example** (Synchronous Logging)
+ * **Example** (Running a synchronous effect)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -14978,7 +14978,7 @@ export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A,
  * // Output: 1
  * ```
  *
- * **Example** (Incorrect Usage with Failing or Async Effects)
+ * **Example** (Throwing for failed or async effects)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15009,7 +15009,7 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
 /**
  * Executes an effect synchronously with provided services.
  *
- * **Example** (Usage)
+ * **Example** (Running synchronously with services)
  *
  * ```ts
  * import { Context, Effect } from "effect"
@@ -15057,7 +15057,7 @@ export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(eff
  * return an `Failure` with a `Die` cause, indicating that the effect cannot be
  * resolved synchronously.
  *
- * **Example** (Handling Results as Exit)
+ * **Example** (Observing synchronous results as Exit)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15083,7 +15083,7 @@ export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(eff
  * // }
  * ```
  *
- * **Example** (Asynchronous Operation Resulting in Die)
+ * **Example** (Capturing async work as a Die cause)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15112,7 +15112,7 @@ 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.
  *
- * **Example** (Usage)
+ * **Example** (Running synchronously with services as Exit)
  *
  * ```ts
  * import { Context, Effect, Exit } from "effect"
@@ -15753,7 +15753,7 @@ export declare namespace fn {
  *
  * `Effect.fnUntraced` also acts as a `pipe` function, so you can append transforms after the body.
  *
- * **Example** (Usage)
+ * **Example** (Defining untraced effect functions)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -15775,7 +15775,7 @@ export declare const fnUntraced: fn.Untraced;
  *
  * Pipeable functions run after the body and can transform the resulting Effect.
  *
- * **Example** (Usage)
+ * **Example** (Defining traced effect functions)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -15805,7 +15805,7 @@ export declare const fn: fn.Traced & {
  * Retrieves the `Clock` service from the context and provides it to the
  * specified effectful function.
  *
- * **Example** (Usage)
+ * **Example** (Accessing the Clock service)
  *
  * ```ts
  * import { Console, Effect } from "effect"
@@ -15832,7 +15832,7 @@ export declare const clockWith: <A, E, R>(f: (clock: Clock) => Effect<A, E, R>)
  * If no level is provided, the logger uses the fiber's current log level and
  * extracts any `Cause` values from the message list.
  *
- * **Example** (Usage)
+ * **Example** (Logging at a dynamic level)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15851,7 +15851,7 @@ export declare const logWithLevel: (level?: Severity) => (...message: ReadonlyAr
 /**
  * Logs one or more messages using the default log level.
  *
- * **Example** (Usage)
+ * **Example** (Logging at the default level)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15879,7 +15879,7 @@ export declare const log: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages at the FATAL level.
  *
- * **Example** (Usage)
+ * **Example** (Logging fatal messages)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15908,7 +15908,7 @@ export declare const logFatal: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages at the WARNING level.
  *
- * **Example** (Usage)
+ * **Example** (Logging warnings)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15938,7 +15938,7 @@ export declare const logWarning: (...message: ReadonlyArray<any>) => Effect<void
 /**
  * Logs one or more messages at the ERROR level.
  *
- * **Example** (Usage)
+ * **Example** (Logging errors)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15971,7 +15971,7 @@ export declare const logError: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages at the INFO level.
  *
- * **Example** (Usage)
+ * **Example** (Logging information)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -15999,7 +15999,7 @@ export declare const logInfo: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages at the DEBUG level.
  *
- * **Example** (Usage)
+ * **Example** (Logging debug messages)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -16028,7 +16028,7 @@ export declare const logDebug: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Logs one or more messages at the TRACE level.
  *
- * **Example** (Usage)
+ * **Example** (Logging trace messages)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -16060,7 +16060,7 @@ export declare const logTrace: (...message: ReadonlyArray<any>) => Effect<void>;
 /**
  * Adds a logger to the set of loggers which will output logs for this effect.
  *
- * **Example** (Usage)
+ * **Example** (Adding a logger to an effect)
  *
  * ```ts
  * import { Effect, Logger } from "effect"
@@ -16089,7 +16089,7 @@ export declare const withLogger: (<Output>(logger: Logger<unknown, Output>) => <
 /**
  * Adds an annotation to each log line in this effect.
  *
- * **Example** (Usage)
+ * **Example** (Adding log annotations)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -16130,7 +16130,7 @@ export declare const annotateLogs: {
  * `annotateLogsScoped` updates annotations for the entire current `Scope` and
  * restores the previous annotations when the scope closes.
  *
- * **Example** (Usage)
+ * **Example** (Adding scoped log annotations)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -16157,7 +16157,7 @@ export declare const annotateLogsScoped: {
      * `annotateLogsScoped` updates annotations for the entire current `Scope` and
      * restores the previous annotations when the scope closes.
      *
-     * **Example** (Usage)
+     * **Example** (Adding scoped log annotations)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -16184,7 +16184,7 @@ export declare const annotateLogsScoped: {
      * `annotateLogsScoped` updates annotations for the entire current `Scope` and
      * restores the previous annotations when the scope closes.
      *
-     * **Example** (Usage)
+     * **Example** (Adding scoped log annotations)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -16208,7 +16208,7 @@ export declare const annotateLogsScoped: {
 /**
  * Adds a span to each log line in this effect.
  *
- * **Example** (Usage)
+ * **Example** (Adding a log span)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -16243,7 +16243,7 @@ export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A
  * Also accepts an optional function which can be used to map the `Exit` value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
- * **Example** (Usage)
+ * **Example** (Incrementing a metric for each execution)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -16263,7 +16263,7 @@ export declare const withLogSpan: ((label: string) => <A, E, R>(effect: Effect<A
  * )
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Mapping exits before updating a metric)
  *
  * ```ts
  * import { Effect, Exit, Metric } from "effect"
@@ -16294,7 +16294,7 @@ export declare const track: {
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Incrementing a metric for each execution)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16314,7 +16314,7 @@ export declare const track: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping exits before updating a metric)
      *
      * ```ts
      * import { Effect, Exit, Metric } from "effect"
@@ -16345,7 +16345,7 @@ export declare const track: {
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Incrementing a metric for each execution)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16365,7 +16365,7 @@ export declare const track: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping exits before updating a metric)
      *
      * ```ts
      * import { Effect, Exit, Metric } from "effect"
@@ -16396,7 +16396,7 @@ export declare const track: {
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Incrementing a metric for each execution)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16416,7 +16416,7 @@ export declare const track: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping exits before updating a metric)
      *
      * ```ts
      * import { Effect, Exit, Metric } from "effect"
@@ -16447,7 +16447,7 @@ export declare const track: {
      * Also accepts an optional function which can be used to map the `Exit` value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Incrementing a metric for each execution)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16467,7 +16467,7 @@ export declare const track: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping exits before updating a metric)
      *
      * ```ts
      * import { Effect, Exit, Metric } from "effect"
@@ -16500,7 +16500,7 @@ export declare const track: {
  * Also accepts an optional function which can be used to map the success value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
- * **Example** (Usage)
+ * **Example** (Counting successful results)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -16519,7 +16519,7 @@ export declare const track: {
  * )
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Mapping successes before tracking)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -16548,7 +16548,7 @@ export declare const trackSuccesses: {
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting successful results)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16567,7 +16567,7 @@ export declare const trackSuccesses: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping successes before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16596,7 +16596,7 @@ export declare const trackSuccesses: {
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting successful results)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16615,7 +16615,7 @@ export declare const trackSuccesses: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping successes before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16644,7 +16644,7 @@ export declare const trackSuccesses: {
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting successful results)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16663,7 +16663,7 @@ export declare const trackSuccesses: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping successes before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16692,7 +16692,7 @@ export declare const trackSuccesses: {
      * Also accepts an optional function which can be used to map the success value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting successful results)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16711,7 +16711,7 @@ export declare const trackSuccesses: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping successes before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16741,7 +16741,7 @@ export declare const trackSuccesses: {
  * Also accepts an optional function which can be used to map the error value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
- * **Example** (Usage)
+ * **Example** (Counting expected failures)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -16760,7 +16760,7 @@ export declare const trackSuccesses: {
  * )
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Mapping errors before tracking)
  *
  * ```ts
  * import { Data, Effect, Metric } from "effect"
@@ -16791,7 +16791,7 @@ export declare const trackErrors: {
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting expected failures)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16810,7 +16810,7 @@ export declare const trackErrors: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors before tracking)
      *
      * ```ts
      * import { Data, Effect, Metric } from "effect"
@@ -16841,7 +16841,7 @@ export declare const trackErrors: {
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting expected failures)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16860,7 +16860,7 @@ export declare const trackErrors: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors before tracking)
      *
      * ```ts
      * import { Data, Effect, Metric } from "effect"
@@ -16891,7 +16891,7 @@ export declare const trackErrors: {
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting expected failures)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16910,7 +16910,7 @@ export declare const trackErrors: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors before tracking)
      *
      * ```ts
      * import { Data, Effect, Metric } from "effect"
@@ -16941,7 +16941,7 @@ export declare const trackErrors: {
      * Also accepts an optional function which can be used to map the error value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting expected failures)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -16960,7 +16960,7 @@ export declare const trackErrors: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors before tracking)
      *
      * ```ts
      * import { Data, Effect, Metric } from "effect"
@@ -16992,7 +16992,7 @@ export declare const trackErrors: {
  * Also accepts an optional function which can be used to map the defect value
  * of the `Effect` into a valid `Input` for the `Metric`.
  *
- * **Example** (Usage)
+ * **Example** (Counting defects)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -17011,7 +17011,7 @@ export declare const trackErrors: {
  * )
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Mapping defects before tracking)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -17043,7 +17043,7 @@ export declare const trackDefects: {
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting defects)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17062,7 +17062,7 @@ export declare const trackDefects: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping defects before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17094,7 +17094,7 @@ export declare const trackDefects: {
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting defects)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17113,7 +17113,7 @@ export declare const trackDefects: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping defects before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17145,7 +17145,7 @@ export declare const trackDefects: {
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting defects)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17164,7 +17164,7 @@ export declare const trackDefects: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping defects before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17196,7 +17196,7 @@ export declare const trackDefects: {
      * Also accepts an optional function which can be used to map the defect value
      * of the `Effect` into a valid `Input` for the `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Counting defects)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17215,7 +17215,7 @@ export declare const trackDefects: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping defects before tracking)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17249,7 +17249,7 @@ export declare const trackDefects: {
  * that the wrapped `Effect` took to complete into a valid `Input` for the
  * `Metric`.
  *
- * **Example** (Usage)
+ * **Example** (Recording execution duration)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
@@ -17266,7 +17266,7 @@ export declare const trackDefects: {
  * )
  * ```
  *
- * **Example** (Usage)
+ * **Example** (Mapping duration before tracking)
  *
  * ```ts
  * import { Duration, Effect, Metric } from "effect"
@@ -17296,7 +17296,7 @@ export declare const trackDuration: {
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Recording execution duration)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17313,7 +17313,7 @@ export declare const trackDuration: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping duration before tracking)
      *
      * ```ts
      * import { Duration, Effect, Metric } from "effect"
@@ -17343,7 +17343,7 @@ export declare const trackDuration: {
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Recording execution duration)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17360,7 +17360,7 @@ export declare const trackDuration: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping duration before tracking)
      *
      * ```ts
      * import { Duration, Effect, Metric } from "effect"
@@ -17390,7 +17390,7 @@ export declare const trackDuration: {
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Recording execution duration)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17407,7 +17407,7 @@ export declare const trackDuration: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping duration before tracking)
      *
      * ```ts
      * import { Duration, Effect, Metric } from "effect"
@@ -17437,7 +17437,7 @@ export declare const trackDuration: {
      * that the wrapped `Effect` took to complete into a valid `Input` for the
      * `Metric`.
      *
-     * **Example** (Usage)
+     * **Example** (Recording execution duration)
      *
      * ```ts
      * import { Effect, Metric } from "effect"
@@ -17454,7 +17454,7 @@ export declare const trackDuration: {
      * )
      * ```
      *
-     * **Example** (Usage)
+     * **Example** (Mapping duration before tracking)
      *
      * ```ts
      * import { Duration, Effect, Metric } from "effect"
@@ -17490,7 +17490,7 @@ declare const Transaction_base: Context.ServiceClass<Transaction, "effect/Effect
  * - a journal that stores any non committed change to TxRef values
  * - a retry flag to know if the transaction should be retried
  *
- * **Example** (Usage)
+ * **Example** (Building transactions)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -17526,7 +17526,7 @@ export declare class Transaction extends Transaction_base {
  * The outermost `tx` call creates the transaction boundary and commits or rolls back the full
  * composed transaction.
  *
- * **Example** (Usage)
+ * **Example** (Running a transaction)
  *
  * ```ts
  * import { Effect, TxRef } from "effect"
@@ -17560,7 +17560,7 @@ export declare const tx: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, Excl
  * @category Transactions
  * @since 4.0.0
  *
- * **Example** (Usage)
+ * **Example** (Retrying transactions)
  *
  * ```ts
  * import { Effect, TxRef } from "effect"
@@ -17823,7 +17823,7 @@ export declare namespace Effectify {
  * callback errors and `onSyncError` to turn synchronous throws into typed
  * failures; otherwise synchronous throws become defects.
  *
- * **Example** (Basic Usage)
+ * **Example** (Converting callbacks to effects)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -17839,7 +17839,7 @@ export declare namespace Effectify {
  * // Output: contents of package.json
  * ```
  *
- * **Example** (Custom Error Handling)
+ * **Example** (Mapping callback errors to typed failures)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -17872,7 +17872,7 @@ export declare const effectify: {
      * callback errors and `onSyncError` to turn synchronous throws into typed
      * failures; otherwise synchronous throws become defects.
      *
-     * **Example** (Basic Usage)
+     * **Example** (Converting callbacks to effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -17888,7 +17888,7 @@ export declare const effectify: {
      * // Output: contents of package.json
      * ```
      *
-     * **Example** (Custom Error Handling)
+     * **Example** (Mapping callback errors to typed failures)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -17921,7 +17921,7 @@ export declare const effectify: {
      * callback errors and `onSyncError` to turn synchronous throws into typed
      * failures; otherwise synchronous throws become defects.
      *
-     * **Example** (Basic Usage)
+     * **Example** (Converting callbacks to effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -17937,7 +17937,7 @@ export declare const effectify: {
      * // Output: contents of package.json
      * ```
      *
-     * **Example** (Custom Error Handling)
+     * **Example** (Mapping callback errors to typed failures)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -17970,7 +17970,7 @@ export declare const effectify: {
      * callback errors and `onSyncError` to turn synchronous throws into typed
      * failures; otherwise synchronous throws become defects.
      *
-     * **Example** (Basic Usage)
+     * **Example** (Converting callbacks to effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -17986,7 +17986,7 @@ export declare const effectify: {
      * // Output: contents of package.json
      * ```
      *
-     * **Example** (Custom Error Handling)
+     * **Example** (Mapping callback errors to typed failures)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18014,7 +18014,7 @@ export declare const effectify: {
  * This function provides compile-time type checking to ensure that the success
  * value of an effect conforms to a specific type constraint.
  *
- * **Example** (Usage)
+ * **Example** (Constraining the success type)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18041,7 +18041,7 @@ export declare const satisfiesSuccessType: <A>() => <A2 extends A, E, R>(effect:
  * This function provides compile-time type checking to ensure that the error
  * type of an effect conforms to a specific type constraint.
  *
- * **Example** (Usage)
+ * **Example** (Constraining the error type)
  *
  * ```ts
  * import { Data, Effect } from "effect"
@@ -18070,7 +18070,7 @@ export declare const satisfiesErrorType: <E>() => <A, E2 extends E, R>(effect: E
  * This function provides compile-time type checking to ensure that the
  * requirements (context) type of an effect conforms to a specific type constraint.
  *
- * **Example** (Usage)
+ * **Example** (Constraining the services type)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18107,7 +18107,7 @@ export declare const satisfiesServicesType: <R>() => <A, E, R2 extends R>(effect
  * - For **Failure effects**: Returns the failure as-is without applying the mapping
  * - For **Pending effects**: Falls back to the regular `map` behavior
  *
- * **Example** (Usage)
+ * **Example** (Mapping already completed effects)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18141,7 +18141,7 @@ export declare const mapEager: {
      * - For **Failure effects**: Returns the failure as-is without applying the mapping
      * - For **Pending effects**: Falls back to the regular `map` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping already completed effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18175,7 +18175,7 @@ export declare const mapEager: {
      * - For **Failure effects**: Returns the failure as-is without applying the mapping
      * - For **Pending effects**: Falls back to the regular `map` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping already completed effects)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18210,7 +18210,7 @@ export declare const mapEager: {
  * - For **Failure effects**: Applies the mapping function immediately to the error
  * - For **Pending effects**: Falls back to the regular `mapError` behavior
  *
- * **Example** (Usage)
+ * **Example** (Mapping errors eagerly when possible)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18247,7 +18247,7 @@ export declare const mapErrorEager: {
      * - For **Failure effects**: Applies the mapping function immediately to the error
      * - For **Pending effects**: Falls back to the regular `mapError` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18284,7 +18284,7 @@ export declare const mapErrorEager: {
      * - For **Failure effects**: Applies the mapping function immediately to the error
      * - For **Pending effects**: Falls back to the regular `mapError` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping errors eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18322,7 +18322,7 @@ export declare const mapErrorEager: {
  * - For **Failure effects**: Applies the `onFailure` function immediately to the error
  * - For **Pending effects**: Falls back to the regular `mapBoth` behavior
  *
- * **Example** (Usage)
+ * **Example** (Mapping both channels eagerly when possible)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18361,7 +18361,7 @@ export declare const mapBothEager: {
      * - For **Failure effects**: Applies the `onFailure` function immediately to the error
      * - For **Pending effects**: Falls back to the regular `mapBoth` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping both channels eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18403,7 +18403,7 @@ export declare const mapBothEager: {
      * - For **Failure effects**: Applies the `onFailure` function immediately to the error
      * - For **Pending effects**: Falls back to the regular `mapBoth` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Mapping both channels eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18446,7 +18446,7 @@ export declare const mapBothEager: {
  * - For **Failure effects**: Returns the failure as-is without applying the flatMap
  * - For **Pending effects**: Falls back to the regular `flatMap` behavior
  *
- * **Example** (Usage)
+ * **Example** (Flat mapping eagerly when possible)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18483,7 +18483,7 @@ export declare const flatMapEager: {
      * - For **Failure effects**: Returns the failure as-is without applying the flatMap
      * - For **Pending effects**: Falls back to the regular `flatMap` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Flat mapping eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18520,7 +18520,7 @@ export declare const flatMapEager: {
      * - For **Failure effects**: Returns the failure as-is without applying the flatMap
      * - For **Pending effects**: Falls back to the regular `flatMap` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Flat mapping eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18558,7 +18558,7 @@ export declare const flatMapEager: {
  * - For **Failure effects**: Applies the catch function immediately to the error
  * - For **Pending effects**: Falls back to the regular `catch` behavior
  *
- * **Example** (Usage)
+ * **Example** (Catching failures eagerly when possible)
  *
  * ```ts
  * import { Effect } from "effect"
@@ -18605,7 +18605,7 @@ export declare const catchEager: {
      * - For **Failure effects**: Applies the catch function immediately to the error
      * - For **Pending effects**: Falls back to the regular `catch` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Catching failures eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18652,7 +18652,7 @@ export declare const catchEager: {
      * - For **Failure effects**: Applies the catch function immediately to the error
      * - For **Pending effects**: Falls back to the regular `catch` behavior
      *
-     * **Example** (Usage)
+     * **Example** (Catching failures eagerly when possible)
      *
      * ```ts
      * import { Effect } from "effect"
@@ -18690,7 +18690,7 @@ export declare const catchEager: {
  * Executes generator functions eagerly when all yielded effects are synchronous,
  * stopping at the first async effect and deferring to normal execution.
  *
- * **Example** (Usage)
+ * **Example** (Defining eager untraced effect functions)
  *
  * ```ts
  * import { Effect } from "effect"