effect 3.13.9 → 3.13.11

package/dist/cjs/Effect.js

@@ -73,12 +73,8 @@ const isEffect = exports.isEffect = core.isEffect;
  * By caching the result, you can improve efficiency and reduce unnecessary
  * computations, especially in performance-critical applications.
  *
- * @see {@link cached} for a similar function that caches the result
- * indefinitely.
- * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
- * additional effect for manually invalidating the cached value.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -100,7 +96,7 @@ const isEffect = exports.isEffect = core.isEffect;
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // expensive task...
  * // result 1
@@ -109,6 +105,11 @@ const isEffect = exports.isEffect = core.isEffect;
  * // result 2
  * ```
  *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
+ *
  * @since 2.0.0
  * @category Caching
  */
@@ -140,12 +141,8 @@ const cachedWithTTL = exports.cachedWithTTL = circular.cached;
  * a certain period but still want to invalidate it if the underlying data
  * changes or if you want to force a recomputation.
  *
- * @see {@link cached} for a similar function that caches the result
- * indefinitely.
- * @see {@link cachedWithTTL} for a similar function that caches the result for
- * a specified duration but does not include an effect for manual invalidation.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -170,7 +167,7 @@ const cachedWithTTL = exports.cachedWithTTL = circular.cached;
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // expensive task...
  * // result 1
@@ -179,6 +176,11 @@ const cachedWithTTL = exports.cachedWithTTL = circular.cached;
  * // result 2
  * ```
  *
+ * @see {@link cached} for a similar function that caches the result
+ * indefinitely.
+ * @see {@link cachedWithTTL} for a similar function that caches the result for
+ * a specified duration but does not include an effect for manual invalidation.
+ *
  * @since 2.0.0
  * @category Caching
  */
@@ -201,12 +203,8 @@ const cachedInvalidateWithTTL = exports.cachedInvalidateWithTTL = circular.cache
  * and all following evaluations will immediately return the cached value,
  * improving performance and reducing unnecessary work.
  *
- * @see {@link cachedWithTTL} for a similar function that includes a
- * time-to-live duration for the cached value.
- * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
- * additional effect for manually invalidating the cached value.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -230,7 +228,7 @@ const cachedInvalidateWithTTL = exports.cachedInvalidateWithTTL = circular.cache
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // non-cached version:
  * // expensive task...
@@ -243,6 +241,11 @@ const cachedInvalidateWithTTL = exports.cachedInvalidateWithTTL = circular.cache
  * // result 3
  * ```
  *
+ * @see {@link cachedWithTTL} for a similar function that includes a
+ * time-to-live duration for the cached value.
+ * @see {@link cachedInvalidateWithTTL} for a similar function that includes an
+ * additional effect for manually invalidating the cached value.
+ *
  * @since 2.0.0
  * @category Caching
  */
@@ -273,7 +276,8 @@ const cached = exports.cached = effect.memoize;
  * expensive calculations or operations that should be avoided after the first
  * execution with the same parameters.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Random } from "effect"
  *
@@ -289,7 +293,7 @@ const cached = exports.cached = effect.memoize;
  *   console.log(yield* memoized(10))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // non-memoized version:
  * // 2
@@ -321,7 +325,8 @@ const cachedFunction = exports.cachedFunction = circular.cachedFunction;
  * have initialization tasks, logging, or other one-time actions that should not
  * be repeated. This can help optimize performance and avoid redundant actions.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -332,7 +337,7 @@ const cachedFunction = exports.cachedFunction = circular.cachedFunction;
  *   yield* Effect.repeatN(task2, 2)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1
  * // task1
@@ -391,12 +396,9 @@ const once = exports.once = effect.once;
  * success or failure. Each effect returns `None` for success and `Some` with
  * the error for failure.
  *
- * @see {@link forEach} for iterating over elements and applying an effect.
- * @see {@link allWith} for a data-last version of this function.
+ * **Example** (Combining Effects in Tuples)
  *
- * @example
  * ```ts
- * // Title: Combining Effects in Tuples
  * import { Effect, Console } from "effect"
  *
  * const tupleOfEffects = [
@@ -408,15 +410,16 @@ const once = exports.once = effect.once;
  * //      ▼
  * const resultsAsTuple = Effect.all(tupleOfEffects)
  *
- * // Effect.runPromise(resultsAsTuple).then(console.log)
+ * Effect.runPromise(resultsAsTuple).then(console.log)
  * // Output:
  * // 42
  * // Hello
  * // [ 42, 'Hello' ]
  * ```
  *
- * @example
- * // Title: Combining Effects in Iterables
+ * **Example** (Combining Effects in Iterables)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const iterableOfEffects: Iterable<Effect.Effect<number>> = [1, 2, 3].map(
@@ -427,15 +430,17 @@ const once = exports.once = effect.once;
  * //      ▼
  * const resultsAsArray = Effect.all(iterableOfEffects)
  *
- * // Effect.runPromise(resultsAsArray).then(console.log)
+ * Effect.runPromise(resultsAsArray).then(console.log)
  * // Output:
  * // 1
  * // 2
  * // 3
  * // [ 1, 2, 3 ]
+ * ```
  *
- * @example
- * // Title: Combining Effects in Structs
+ * **Example** (Combining Effects in Structs)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const structOfEffects = {
@@ -447,14 +452,16 @@ const once = exports.once = effect.once;
  * //      ▼
  * const resultsAsStruct = Effect.all(structOfEffects)
  *
- * // Effect.runPromise(resultsAsStruct).then(console.log)
+ * Effect.runPromise(resultsAsStruct).then(console.log)
  * // Output:
  * // 42
  * // Hello
  * // { a: 42, b: 'Hello' }
+ * ```
+ *
+ * **Example** (Combining Effects in Records)
  *
- * @example
- * // Title: Combining Effects in Records
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const recordOfEffects: Record<string, Effect.Effect<number>> = {
@@ -466,14 +473,16 @@ const once = exports.once = effect.once;
  * //      ▼
  * const resultsAsRecord = Effect.all(recordOfEffects)
  *
- * // Effect.runPromise(resultsAsRecord).then(console.log)
+ * Effect.runPromise(resultsAsRecord).then(console.log)
  * // Output:
  * // 1
  * // 2
  * // { key1: 1, key2: 2 }
+ * ```
+ *
+ * **Example** (Short-Circuiting Behavior)
  *
- * @example
- * // Title: Short-Circuiting Behavior
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const program = Effect.all([
@@ -483,7 +492,7 @@ const once = exports.once = effect.once;
  *   Effect.succeed("Task3").pipe(Effect.tap(Console.log))
  * ])
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Task1
  * // {
@@ -491,9 +500,11 @@ const once = exports.once = effect.once;
  * //   _tag: 'Failure',
  * //   cause: { _id: 'Cause', _tag: 'Fail', failure: 'Task2: Oh no!' }
  * // }
+ * ```
+ *
+ * **Example** (Collecting Results with `mode: "either"`)
  *
- * @example
- * // Title: Collecting Results with `mode: "either"`
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const effects = [
@@ -504,7 +515,7 @@ const once = exports.once = effect.once;
  *
  * const program = Effect.all(effects, { mode: "either" })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Task1
  * // Task3
@@ -517,9 +528,11 @@ const once = exports.once = effect.once;
  * //     { _id: 'Either', _tag: 'Right', right: 'Task3' }
  * //   ]
  * // }
+ * ```
  *
- * @example
- * //Example: Collecting Results with `mode: "validate"`
+ * **Example** (Collecting Results with `mode: "validate"`)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const effects = [
@@ -530,7 +543,7 @@ const once = exports.once = effect.once;
  *
  * const program = Effect.all(effects, { mode: "validate" })
  *
- * // Effect.runPromiseExit(program).then((result) => console.log("%o", result))
+ * Effect.runPromiseExit(program).then((result) => console.log("%o", result))
  * // Output:
  * // Task1
  * // Task3
@@ -547,6 +560,10 @@ const once = exports.once = effect.once;
  * //     ]
  * //   }
  * // }
+ * ```
+ *
+ * @see {@link forEach} for iterating over elements and applying an effect.
+ * @see {@link allWith} for a data-last version of this function.
  *
  * @since 2.0.0
  * @category Collecting
@@ -561,7 +578,8 @@ const all = exports.all = fiberRuntime.all;
  * options such as concurrency levels. This version is useful in functional
  * pipelines where you first define your data and then apply operations to it.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -581,7 +599,7 @@ const all = exports.all = fiberRuntime.all;
  *   Effect.allWith({ concurrency: 2 })
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#3 message="task2 done"
  * // timestamp=... level=INFO fiber=#2 message="task1 done"
@@ -609,7 +627,8 @@ const allWith = exports.allWith = fiberRuntime.allWith;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -625,7 +644,7 @@ const allWith = exports.allWith = fiberRuntime.allWith;
  *   console.log(successfulResults)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [1, 2]
  *
  * ```
@@ -657,10 +676,8 @@ const allSuccesses = exports.allSuccesses = fiberRuntime.allSuccesses;
  * This function allows you to conditionally skip over a part of the collection
  * based on some criteria defined in the predicate.
  *
- * @see {@link dropWhile} for a similar function that drops elements while the
- * predicate returns `true`.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -672,10 +689,13 @@ const allSuccesses = exports.allSuccesses = fiberRuntime.allSuccesses;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [5, 6]
  * ```
  *
+ * @see {@link dropWhile} for a similar function that drops elements while the
+ * predicate returns `true`.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -702,10 +722,8 @@ const dropUntil = exports.dropUntil = effect.dropUntil;
  * based on a condition, and only keep the rest when the condition no longer
  * holds.
  *
- * @see {@link dropUntil} for a similar function that drops elements until the
- * predicate returns `true`.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -717,10 +735,13 @@ const dropUntil = exports.dropUntil = effect.dropUntil;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [4, 5, 6]
  * ```
  *
+ * @see {@link dropUntil} for a similar function that drops elements until the
+ * predicate returns `true`.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -751,10 +772,8 @@ const dropWhile = exports.dropWhile = effect.dropWhile;
  * numbers from a list until a certain threshold is reached, or gather items
  * until a specific condition is met.
  *
- * @see {@link takeWhile} for a similar function that takes elements while the
- * predicate returns `true`.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -766,10 +785,13 @@ const dropWhile = exports.dropWhile = effect.dropWhile;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [ 1, 2, 3, 4 ]
  * ```
  *
+ * @see {@link takeWhile} for a similar function that takes elements while the
+ * predicate returns `true`.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -790,9 +812,8 @@ const takeUntil = exports.takeUntil = effect.takeUntil;
  *
  * Once the predicate returns `false`, the remaining elements are discarded.
  *
- * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -804,10 +825,12 @@ const takeUntil = exports.takeUntil = effect.takeUntil;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [1, 2, 3]
  * ```
  *
+ * @see {@link takeUntil} for a similar function that takes elements until the predicate returns `true`.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -833,10 +856,8 @@ const takeWhile = exports.takeWhile = effect.takeWhile;
  * collection meet certain criteria, even when the evaluation of each item
  * involves effects, such as asynchronous checks or complex computations.
  *
- * @see {@link exists} for a similar function that returns a boolean indicating
- * whether **any** element satisfies the predicate.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -848,10 +869,13 @@ const takeWhile = exports.takeWhile = effect.takeWhile;
  *   console.log(allEven)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: true
  * ```
  *
+ * @see {@link exists} for a similar function that returns a boolean indicating
+ * whether **any** element satisfies the predicate.
+ *
  * @since 2.0.0
  * @category Condition Checking
  */
@@ -878,10 +902,8 @@ const every = exports.every = effect.every;
  * This function allows you to quickly check for a condition in a collection
  * without having to manually iterate over it.
  *
- * @see {@link every} for a similar function that checks if **all** elements
- * satisfy the predicate.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -893,10 +915,13 @@ const every = exports.every = effect.every;
  *   console.log(hasLargeNumber)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: true
  * ```
  *
+ * @see {@link every} for a similar function that checks if **all** elements
+ * satisfy the predicate.
+ *
  * @since 2.0.0
  * @category Condition Checking
  */
@@ -925,7 +950,8 @@ const exists = exports.exists = fiberRuntime.exists;
  * This function allows you to selectively keep or remove elements based on a
  * condition that may involve asynchronous or side-effect-causing operations.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -937,7 +963,7 @@ const exists = exports.exists = fiberRuntime.exists;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [2, 4]
  * ```
  *
@@ -953,7 +979,8 @@ const filter = exports.filter = fiberRuntime.filter;
  * element is kept; if it returns `None`, the element is removed. The operation
  * is done sequentially for each element.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect, Option } from "effect"
  *
@@ -968,7 +995,7 @@ const filter = exports.filter = fiberRuntime.filter;
  *   (n) => n % 2 === 0 ? Option.some(n) : Option.none()
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // task1 done
  * // task2 done
@@ -1003,7 +1030,8 @@ const filterMap = exports.filterMap = effect.filterMap;
  * condition, even when the evaluation involves effects like asynchronous
  * operations or side effects.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1015,7 +1043,7 @@ const filterMap = exports.filterMap = effect.filterMap;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: { _id: 'Option', _tag: 'Some', value: 4 }
  * ```
  *
@@ -1044,18 +1072,16 @@ const findFirst = exports.findFirst = effect.findFirst;
  * If the `discard` option is set to `true`, the intermediate results are not
  * collected, and the final result of the operation is `void`.
  *
- * @see {@link all} for combining multiple effects into one.
+ * **Example** (Applying Effects to Iterable Elements)
  *
- * @example
  * ```ts
- * // Title: Applying Effects to Iterable Elements
  * import { Effect, Console } from "effect"
  *
  * const result = Effect.forEach([1, 2, 3, 4, 5], (n, index) =>
  *   Console.log(`Currently at index ${index}`).pipe(Effect.as(n * 2))
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output:
  * // Currently at index 0
  * // Currently at index 1
@@ -1065,8 +1091,9 @@ const findFirst = exports.findFirst = effect.findFirst;
  * // [ 2, 4, 6, 8, 10 ]
  * ```
  *
- * @example
- * // Title: Using discard to Ignore Results
+ * **Example** (Discarding Results)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * // Apply effects but discard the results
@@ -1077,7 +1104,7 @@ const findFirst = exports.findFirst = effect.findFirst;
  *   { discard: true }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output:
  * // Currently at index 0
  * // Currently at index 1
@@ -1085,6 +1112,9 @@ const findFirst = exports.findFirst = effect.findFirst;
  * // Currently at index 3
  * // Currently at index 4
  * // undefined
+ * ```
+ *
+ * @see {@link all} for combining multiple effects into one.
  *
  * @since 2.0.0
  * @category Looping
@@ -1100,7 +1130,8 @@ const forEach = exports.forEach = fiberRuntime.forEach;
  * collection and want to handle the case where the collection might be empty
  * without causing an unhandled exception.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1112,7 +1143,7 @@ const forEach = exports.forEach = fiberRuntime.forEach;
  *   console.log(firstElement)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: 1
  * ```
  *
@@ -1140,7 +1171,8 @@ const head = exports.head = effect.head;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1153,7 +1185,7 @@ const head = exports.head = effect.head;
  *   console.log(total)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: 6
  * ```
  *
@@ -1185,10 +1217,8 @@ const mergeAll = exports.mergeAll = fiberRuntime.mergeAll;
  * work with valid data. The function ensures that failures are captured, while
  * successes are processed normally.
  *
- * @see {@link validateAll} for a function that either collects all failures or all successes.
- * @see {@link validateFirst} for a function that stops at the first success.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1202,11 +1232,14 @@ const mergeAll = exports.mergeAll = fiberRuntime.mergeAll;
  *   }
  * })
  *
- * // Effect.runPromise(program).then(console.log, console.error)
+ * Effect.runPromise(program).then(console.log, console.error)
  * // Output:
  * // [ [ '1 is not even', '3 is not even' ], [ 0, 2, 4 ] ]
  * ```
  *
+ * @see {@link validateAll} for a function that either collects all failures or all successes.
+ * @see {@link validateFirst} for a function that stops at the first success.
+ *
  * @since 2.0.0
  * @category Error Accumulation
  */
@@ -1230,10 +1263,8 @@ const partition = exports.partition = fiberRuntime.partition;
  * numbers or combining results from multiple tasks. It ensures that operations
  * are performed one after the other, maintaining the order of the elements.
  *
- * @see {@link reduceWhile} for a similar function that stops the process based on a predicate.
- * @see {@link reduceRight} for a similar function that works from right to left.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1249,7 +1280,7 @@ const partition = exports.partition = fiberRuntime.partition;
  *       .pipe(Effect.map((order) => acc + order.price))
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Order 1 processed
  * // Order 2 processed
@@ -1258,6 +1289,9 @@ const partition = exports.partition = fiberRuntime.partition;
  * // 1000
  * ```
  *
+ * @see {@link reduceWhile} for a similar function that stops the process based on a predicate.
+ * @see {@link reduceRight} for a similar function that works from right to left.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -1282,7 +1316,8 @@ const reduce = exports.reduce = effect.reduce;
  * if you want to sum values in a list but stop as soon as the sum exceeds a
  * certain threshold, you can use this function.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1301,7 +1336,7 @@ const reduce = exports.reduce = effect.reduce;
  *   }
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Order 1 processed
  * // Order 2 processed
@@ -1332,9 +1367,8 @@ const reduceWhile = exports.reduceWhile = effect.reduceWhile;
  * numbers or combining results from multiple tasks. It ensures that operations
  * are performed one after the other, maintaining the order of the elements.
  *
- * @see {@link reduce} for a similar function that works from left to right.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1350,7 +1384,7 @@ const reduceWhile = exports.reduceWhile = effect.reduceWhile;
  *       .pipe(Effect.map((order) => acc + order.price))
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Order 4 processed
  * // Order 3 processed
@@ -1359,6 +1393,8 @@ const reduceWhile = exports.reduceWhile = effect.reduceWhile;
  * // 1000
  * ```
  *
+ * @see {@link reduce} for a similar function that works from left to right.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -1379,7 +1415,8 @@ const reduceRight = exports.reduceRight = effect.reduceRight;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1393,7 +1430,7 @@ const reduceRight = exports.reduceRight = effect.reduceRight;
  *   (acc, order, i) => acc + order.price
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Order 1 processed
  * // Order 2 processed
@@ -1415,7 +1452,8 @@ const reduceEffect = exports.reduceEffect = fiberRuntime.reduceEffect;
  * (`n`). The result is an array of `n` effects, each of which is identical to
  * the original effect.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1432,7 +1470,7 @@ const reduceEffect = exports.reduceEffect = fiberRuntime.reduceEffect;
  *   }
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Hello, World!
  * // Hello, World!
@@ -1462,7 +1500,8 @@ const replicate = exports.replicate = fiberRuntime.replicate;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -1478,7 +1517,7 @@ const replicate = exports.replicate = fiberRuntime.replicate;
  *   yield* Console.log(`Results: ${results.join(", ")}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Task completed
  * // Task completed
@@ -1512,11 +1551,8 @@ const replicateEffect = exports.replicateEffect = fiberRuntime.replicateEffect;
  * so this function is not suitable when you need to keep the successful results
  * in case of errors.
  *
- * @see {@link forEach} for a similar function that stops at the first error.
- * @see {@link partition} when you need to separate successes and failures
- * instead of losing successes with errors.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -1530,7 +1566,7 @@ const replicateEffect = exports.replicateEffect = fiberRuntime.replicateEffect;
  *   }
  * })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // item 1
  * // item 2
@@ -1546,6 +1582,10 @@ const replicateEffect = exports.replicateEffect = fiberRuntime.replicateEffect;
  * // }
  * ```
  *
+ * @see {@link forEach} for a similar function that stops at the first error.
+ * @see {@link partition} when you need to separate successes and failures
+ * instead of losing successes with errors.
+ *
  * @since 2.0.0
  * @category Error Accumulation
  */
@@ -1564,11 +1604,8 @@ const validateAll = exports.validateAll = fiberRuntime.validateAll;
  * errors. This can be useful when you are interested in the first successful
  * result and want to avoid processing further once a valid result is found.
  *
- * @see {@link validateAll} for a similar function that accumulates all results.
- * @see {@link firstSuccessOf} for a similar function that processes multiple
- * effects and returns the first successful one or the last error.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -1582,12 +1619,16 @@ const validateAll = exports.validateAll = fiberRuntime.validateAll;
  *   }
  * })
  *
- * // Effect.runPromise(program).then(console.log, console.error)
+ * Effect.runPromise(program).then(console.log, console.error)
  * // Output:
  * // item 4
  * // 4
  * ```
  *
+ * @see {@link validateAll} for a similar function that accumulates all results.
+ * @see {@link firstSuccessOf} for a similar function that processes multiple
+ * effects and returns the first successful one or the last error.
+ *
  * @since 2.0.0
  * @category Error Accumulation
  */
@@ -1616,9 +1657,9 @@ const validateFirst = exports.validateFirst = fiberRuntime.validateFirst;
  * Use `Effect.async` when dealing with APIs that use callback-style instead of
  * `async/await` or `Promise`.
  *
- * @example
+ * **Example** (Wrapping a Callback API)
+ *
  * ```ts
- * // Title: Wrapping a Callback API
  * import { Effect } from "effect"
  * import * as NodeFS from "node:fs"
  *
@@ -1640,8 +1681,9 @@ const validateFirst = exports.validateFirst = fiberRuntime.validateFirst;
  * const program = readFile("example.txt")
  * ```
  *
- * @example
- * // Title: Handling Interruption with Cleanup
+ * **Example** (Handling Interruption with Cleanup)
+ *
+ * ```ts
  * import { Effect, Fiber } from "effect"
  * import * as NodeFS from "node:fs"
  *
@@ -1676,12 +1718,14 @@ const validateFirst = exports.validateFirst = fiberRuntime.validateFirst;
  * })
  *
  * // Run the program
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Cleaning up example.txt
+ * ```
+ *
+ * **Example** (Handling Interruption with AbortSignal)
  *
- * @example
- * // Title: Handling Interruption with AbortSignal
+ * ```ts
  * import { Effect, Fiber } from "effect"
  *
  * // A task that supports interruption using AbortSignal
@@ -1707,9 +1751,10 @@ const validateFirst = exports.validateFirst = fiberRuntime.validateFirst;
  * })
  *
  * // Run the program
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Abort signal received
+ * ```
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -1728,7 +1773,8 @@ const asyncEffect = exports.asyncEffect = runtime_.asyncEffect;
  * It is meant to be called with a bag of instructions that become available in
  * the "this" of the effect.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1756,11 +1802,9 @@ const withFiberRuntime = exports.withFiberRuntime = core.withFiberRuntime;
  * will keep propagating unless it is handled. You can handle the error with
  * functions like {@link catchAll} or {@link catchTag}.
  *
- * @see {@link succeed} to create an effect that represents a successful value.
+ * **Example** (Creating a Failed Effect)
  *
- * @example
  * ```ts
- * // Title: Creating a Failed Effect
  * import { Effect } from "effect"
  *
  * //      ┌─── Effect<never, Error, never>
@@ -1770,6 +1814,8 @@ const withFiberRuntime = exports.withFiberRuntime = core.withFiberRuntime;
  * )
  * ```
  *
+ * @see {@link succeed} to create an effect that represents a successful value.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -1813,14 +1859,9 @@ const failCauseSync = exports.failCauseSync = core.failCauseSync;
  * should not be handled as regular errors but instead represent unrecoverable
  * defects.
  *
- * @see {@link dieSync} for a variant that throws a specified error, evaluated
- * lazily.
- * @see {@link dieMessage} for a variant that throws a `RuntimeException` with a
- * message.
+ * **Example** (Terminating on Division by Zero with a Specified Error)
  *
- * @example
  * ```ts
- * // Title: Terminating on Division by Zero with a Specified Error
  * import { Effect } from "effect"
  *
  * const divide = (a: number, b: number) =>
@@ -1832,12 +1873,17 @@ const failCauseSync = exports.failCauseSync = core.failCauseSync;
  * //      ▼
  * const program = divide(1, 0)
  *
- * // Effect.runPromise(program).catch(console.error)
+ * Effect.runPromise(program).catch(console.error)
  * // Output:
  * // (FiberFailure) Error: Cannot divide by zero
  * //   ...stack trace...
  * ```
  *
+ * @see {@link dieSync} for a variant that throws a specified error, evaluated
+ * lazily.
+ * @see {@link dieMessage} for a variant that throws a `RuntimeException` with a
+ * message.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -1860,13 +1906,9 @@ const die = exports.die = core.die;
  * Use this function when you want to terminate a fiber due to an unrecoverable
  * defect and include a clear explanation in the message.
  *
- * @see {@link die} for a variant that throws a specified error.
- * @see {@link dieSync} for a variant that throws a specified error, evaluated
- * lazily.
+ * **Example** (Terminating on Division by Zero with a Specified Message)
  *
- * @example
  * ```ts
- * // Title: Terminating on Division by Zero with a Specified Message
  * import { Effect } from "effect"
  *
  * const divide = (a: number, b: number) =>
@@ -1878,12 +1920,16 @@ const die = exports.die = core.die;
  * //      ▼
  * const program = divide(1, 0)
  *
- * // Effect.runPromise(program).catch(console.error)
+ * Effect.runPromise(program).catch(console.error)
  * // Output:
  * // (FiberFailure) RuntimeException: Cannot divide by zero
  * //   ...stack trace...
  * ```
  *
+ * @see {@link die} for a variant that throws a specified error.
+ * @see {@link dieSync} for a variant that throws a specified error, evaluated
+ * lazily.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -1917,7 +1963,8 @@ const dieSync = exports.dieSync = core.dieSync;
  * explicit control over the execution of effects. You can `yield*` values from
  * effects and return the final result at the end.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -2009,11 +2056,9 @@ const none = exports.none = effect.none;
  *
  * Use this function when you are sure the operation will not reject.
  *
- * @see {@link tryPromise} for a version that can handle failures.
+ * **Example** (Delayed Message)
  *
- * @example
  * ```ts
- * // Title: Delayed Message
  * import { Effect } from "effect"
  *
  * const delay = (message: string) =>
@@ -2031,6 +2076,8 @@ const none = exports.none = effect.none;
  * const program = delay("Async operation completed successfully!")
  * ```
  *
+ * @see {@link tryPromise} for a version that can handle failures.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -2043,11 +2090,9 @@ const promise = exports.promise = effect.promise;
  * Use this function when you need an effect that completes successfully with a
  * specific value without any errors or external dependencies.
  *
- * @see {@link fail} to create an effect that represents a failure.
+ * **Example** (Creating a Successful Effect)
  *
- * @example
  * ```ts
- * // Title: Creating a Successful Effect
  * import { Effect } from "effect"
  *
  * // Creating an effect that represents a successful scenario
@@ -2057,6 +2102,8 @@ const promise = exports.promise = effect.promise;
  * const success = Effect.succeed(42)
  * ```
  *
+ * @see {@link fail} to create an effect that represents a failure.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -2112,9 +2159,9 @@ const succeedSome = exports.succeedSome = effect.succeedSome;
  * computations, managing circular dependencies, or resolving type inference
  * issues.
  *
- * @example
+ * **Example** (Lazy Evaluation with Side Effects)
+ *
  * ```ts
- * // Title: Lazy Evaluation with Side Effects
  * import { Effect } from "effect"
  *
  * let i = 0
@@ -2130,8 +2177,9 @@ const succeedSome = exports.succeedSome = effect.succeedSome;
  * console.log(Effect.runSync(good)) // Output: 2
  * ```
  *
- * @example
- * // Title: Recursive Fibonacci
+ * **Example** (Recursive Fibonacci)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * const blowsUp = (n: number): Effect.Effect<number> =>
@@ -2139,7 +2187,7 @@ const succeedSome = exports.succeedSome = effect.succeedSome;
  *     ? Effect.succeed(1)
  *     : Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)
  *
- * // console.log(Effect.runSync(blowsUp(32)))
+ * console.log(Effect.runSync(blowsUp(32)))
  * // crash: JavaScript heap out of memory
  *
  * const allGood = (n: number): Effect.Effect<number> =>
@@ -2153,9 +2201,11 @@ const succeedSome = exports.succeedSome = effect.succeedSome;
  *
  * console.log(Effect.runSync(allGood(32)))
  * // Output: 3524578
+ * ```
+ *
+ * **Example** (Using Effect.suspend to Help TypeScript Infer Types)
  *
- * @example
- * // Title: Using Effect.suspend to Help TypeScript Infer Types
+ * ```ts
  * import { Effect } from "effect"
  *
  * //   Without suspend, TypeScript may struggle with type inference.
@@ -2176,6 +2226,7 @@ const succeedSome = exports.succeedSome = effect.succeedSome;
  *       ? Effect.fail(new Error("Cannot divide by zero"))
  *       : Effect.succeed(a / b)
  *   )
+ * ```
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -2198,11 +2249,9 @@ const suspend = exports.suspend = core.suspend;
  *
  * Use this function when you are sure the operation will not fail.
  *
- * @see {@link try_ | try} for a version that can handle failures.
+ * **Example** (Logging a Message)
  *
- * @example
  * ```ts
- * // Title: Logging a Message
  * import { Effect } from "effect"
  *
  * const log = (message: string) =>
@@ -2215,6 +2264,8 @@ const suspend = exports.suspend = core.suspend;
  * const program = log("Hello, World!")
  * ```
  *
+ * @see {@link try_ | try} for a version that can handle failures.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -2239,12 +2290,9 @@ const _catch = exports.catch = effect._catch;
  * **Note**: This function only handles recoverable errors. It will not recover
  * from unrecoverable defects.
  *
- * @see {@link catchAllCause} for a version that can recover from both
- * recoverable and unrecoverable errors.
+ * **Example** (Providing Recovery Logic for Recoverable Errors)
  *
- * @example
  * ```ts
- * // Title: Providing Recovery Logic for Recoverable Errors
  * import { Effect, Random } from "effect"
  *
  * class HttpError {
@@ -2278,6 +2326,9 @@ const _catch = exports.catch = effect._catch;
  * )
  * ```
  *
+ * @see {@link catchAllCause} for a version that can recover from both
+ * recoverable and unrecoverable errors.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2299,9 +2350,9 @@ const catchAll = exports.catchAll = core.catchAll;
  * they often indicate serious issues. However, in some cases, such as
  * dynamically loaded plugins, controlled recovery might be needed.
  *
- * @example
+ * **Example** (Recovering from All Errors)
+ *
  * ```ts
- * // Title: Recovering from All Errors
  * import { Cause, Effect } from "effect"
  *
  * // Define an effect that may fail with a recoverable or unrecoverable error
@@ -2316,7 +2367,7 @@ const catchAll = exports.catchAll = core.catchAll;
  *   )
  * )
  *
- * // Effect.runPromise(recovered).then(console.log)
+ * Effect.runPromise(recovered).then(console.log)
  * // Output: "Recovered from a regular error"
  * ```
  *
@@ -2347,9 +2398,9 @@ const catchAllCause = exports.catchAllCause = core.catchAllCause;
  * they often indicate serious issues. However, in some cases, such as
  * dynamically loaded plugins, controlled recovery might be needed.
  *
- * @example
+ * **Example** (Handling All Defects)
+ *
  * ```ts
- * // Title: Handling All Defects
  * import { Effect, Cause, Console } from "effect"
  *
  * // Simulating a runtime error
@@ -2365,7 +2416,7 @@ const catchAllCause = exports.catchAllCause = core.catchAllCause;
  * })
  *
  * // We get an Exit.Success because we caught all defects
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // RuntimeException defect caught: Boom!
  * // {
@@ -2390,9 +2441,9 @@ const catchAllDefect = exports.catchAllDefect = effect.catchAllDefect;
  * alter the error type, so the resulting effect still carries the original
  * error type unless a user-defined type guard is used to narrow the type.
  *
- * @example
+ * **Example** (Catching Specific Errors with a Predicate)
+ *
  * ```ts
- * // Title: Catching Specific Errors with a Predicate
  * import { Effect, Random } from "effect"
  *
  * class HttpError {
@@ -2444,11 +2495,9 @@ const catchIf = exports.catchIf = core.catchIf;
  * program. This function doesn't alter the error type, meaning the error type
  * remains the same as in the original effect.
  *
- * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate.
+ * **Example** (Handling Specific Errors with Effect.catchSome)
  *
- * @example
  * ```ts
- * // Title: Handling Specific Errors with Effect.catchSome
  * import { Effect, Random, Option } from "effect"
  *
  * class HttpError {
@@ -2487,6 +2536,8 @@ const catchIf = exports.catchIf = core.catchIf;
  * )
  * ```
  *
+ * @see {@link catchIf} for a version that allows you to recover from errors based on a predicate.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2527,9 +2578,9 @@ const catchSomeCause = exports.catchSomeCause = effect.catchSomeCause;
  *   an `Option.some` containing the recovery logic.
  * - If the defect does not match, the function returns `Option.none`, allowing the defect to propagate.
  *
- * @example
+ * **Example** (Handling Specific Defects)
+ *
  * ```ts
- * // Title: Handling Specific Defects
  * import { Effect, Cause, Option, Console } from "effect"
  *
  * // Simulating a runtime error
@@ -2548,7 +2599,7 @@ const catchSomeCause = exports.catchSomeCause = effect.catchSomeCause;
  *
  * // Since we are only catching IllegalArgumentException
  * // we will get an Exit.Failure because we simulated a runtime error.
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -2579,12 +2630,9 @@ const catchSomeDefect = exports.catchSomeDefect = effect.catchSomeDefect;
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
  *
- * @see {@link catchTags} for a version that allows you to handle multiple error
- * types at once.
+ * **Example** (Handling Errors by Tag)
  *
- * @example
  * ```ts
- * // Title: Handling Errors by Tag
  * import { Effect, Random } from "effect"
  *
  * class HttpError {
@@ -2619,6 +2667,9 @@ const catchSomeDefect = exports.catchSomeDefect = effect.catchSomeDefect;
  * )
  * ```
  *
+ * @see {@link catchTags} for a version that allows you to handle multiple error
+ * types at once.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2637,9 +2688,9 @@ const catchTag = exports.catchTag = effect.catchTag;
  * The error type must have a readonly `_tag` field to use `catchTag`. This
  * field is used to identify and match errors.
  *
- * @example
+ * **Example** (Handling Multiple Tagged Error Types at Once)
+ *
  * ```ts
- * // Title: Handling Multiple Tagged Error Types at Once
  * import { Effect, Random } from "effect"
  *
  * class HttpError {
@@ -2697,7 +2748,8 @@ const catchTags = exports.catchTags = effect.catchTags;
  * distinguishing between different types of defects (e.g., runtime exceptions,
  * interruptions, etc.).
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -2736,7 +2788,8 @@ const cause = exports.cause = effect.cause;
  * (e.g., a network request), and you want to keep trying without handling or
  * worrying about the errors.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -2755,7 +2808,7 @@ const cause = exports.cause = effect.cause;
  *
  * const program = Effect.eventually(effect)
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // running effect
  * // running effect
@@ -2776,11 +2829,9 @@ const eventually = exports.eventually = effect.eventually;
  * it succeeds or fails. This is useful when you only care about the side
  * effects of the effect and do not need to handle or process its outcome.
  *
- * @see {@link ignoreLogged} to log failures while ignoring them.
+ * **Example** (Using Effect.ignore to Discard Values)
  *
- * @example
  * ```ts
- * // Title: Using Effect.ignore to Discard Values
  * import { Effect } from "effect"
  *
  * //      ┌─── Effect<number, string, never>
@@ -2792,6 +2843,8 @@ const eventually = exports.eventually = effect.eventually;
  * const program = Effect.ignore(task)
  * ```
  *
+ * @see {@link ignoreLogged} to log failures while ignoring them.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2833,7 +2886,8 @@ const ignoreLogged = exports.ignoreLogged = effect.ignoreLogged;
  * error handling in cases where you don't need to differentiate between each
  * failure, but simply want to know that multiple failures occurred.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -2846,7 +2900,7 @@ const ignoreLogged = exports.ignoreLogged = effect.ignoreLogged;
  *   concurrency: "unbounded"
  * }).pipe(Effect.asVoid, Effect.parallelErrors)
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -2876,9 +2930,8 @@ const parallelErrors = exports.parallelErrors = effect.parallelErrors;
  * changes using {@link unsandbox} to return to the original error-handling
  * behavior.
  *
- * @see {@link unsandbox} to restore the original error handling.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -2910,12 +2963,14 @@ const parallelErrors = exports.parallelErrors = effect.parallelErrors;
  * // Restore the original error handling with unsandbox
  * const main = Effect.unsandbox(program)
  *
- * // Effect.runPromise(main).then(console.log)
+ * Effect.runPromise(main).then(console.log)
  * // Output:
  * // Caught a defect: Oh uh!
  * // fallback result on failure
  * ```
  *
+ * @see {@link unsandbox} to restore the original error handling.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2941,12 +2996,9 @@ const sandbox = exports.sandbox = effect.sandbox;
  * can control the number of retries, the delay between them, and when to stop
  * retrying.
  *
- * @see {@link retryOrElse} for a version that allows you to run a fallback.
- * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
+ * **Example** (Retrying with a Fixed Delay)
  *
- * @example
  * ```ts
- * // Title: Retrying with a Fixed Delay
  * import { Effect, Schedule } from "effect"
  *
  * let count = 0
@@ -2968,7 +3020,7 @@ const sandbox = exports.sandbox = effect.sandbox;
  *
  * const repeated = Effect.retry(task, policy)
  *
- * // Effect.runPromise(repeated).then(console.log)
+ * Effect.runPromise(repeated).then(console.log)
  * // Output:
  * // failure
  * // failure
@@ -2977,9 +3029,9 @@ const sandbox = exports.sandbox = effect.sandbox;
  * // yay!
  * ```
  *
- * @example
+ * **Example** (Retrying a Task up to 5 times)
+ *
  * ```ts
- * // Title: Retrying a Task up to 5 times
  * import { Effect } from "effect"
  *
  * let count = 0
@@ -2997,7 +3049,7 @@ const sandbox = exports.sandbox = effect.sandbox;
  * })
  *
  * // Retry the task up to 5 times
- * // Effect.runPromise(Effect.retry(task, { times: 5 }))
+ * Effect.runPromise(Effect.retry(task, { times: 5 })).then(console.log)
  * // Output:
  * // failure
  * // failure
@@ -3005,9 +3057,9 @@ const sandbox = exports.sandbox = effect.sandbox;
  * // success
  * ```
  *
- * @example
+ * **Example** (Retrying Until a Specific Condition is Met)
+ *
  * ```ts
- * // Title: Retrying Until a Specific Condition is Met
  * import { Effect } from "effect"
  *
  * let count = 0
@@ -3023,7 +3075,7 @@ const sandbox = exports.sandbox = effect.sandbox;
  *   until: (err) => err === "Error 3"
  * })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Action called 1 time(s)
  * // Action called 2 time(s)
@@ -3035,6 +3087,9 @@ const sandbox = exports.sandbox = effect.sandbox;
  * // }
  * ```
  *
+ * @see {@link retryOrElse} for a version that allows you to run a fallback.
+ * @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -3055,11 +3110,9 @@ const retry = exports.retry = schedule_.retry_combined;
  * This function is useful when you want to handle failures gracefully by
  * specifying an alternative action after repeated failures.
  *
- * @see {@link retry} for a version that does not run a fallback effect.
+ * **Example** (Retrying with Fallback)
  *
- * @example
  * ```ts
- * // Title: Retrying with Fallback
  * import { Effect, Schedule, Console } from "effect"
  *
  * let count = 0
@@ -3087,7 +3140,7 @@ const retry = exports.retry = schedule_.retry_combined;
  *   () => Console.log("orElse").pipe(Effect.as("default value"))
  * )
  *
- * // Effect.runPromise(repeated).then(console.log)
+ * Effect.runPromise(repeated).then(console.log)
  * // Output:
  * // failure
  * // failure
@@ -3096,6 +3149,8 @@ const retry = exports.retry = schedule_.retry_combined;
  * // default value
  * ```
  *
+ * @see {@link retry} for a version that does not run a fallback effect.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -3152,11 +3207,9 @@ const tryMapPromise = exports.tryMapPromise = effect.tryMapPromise;
  * An optional `AbortSignal` can be provided to allow for interruption of the
  * wrapped `Promise` API.
  *
- * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
+ * **Example** (Fetching a TODO Item)
  *
- * @example
  * ```ts
- * // Title: Fetching a TODO Item
  * import { Effect } from "effect"
  *
  * const getTodo = (id: number) =>
@@ -3170,8 +3223,9 @@ const tryMapPromise = exports.tryMapPromise = effect.tryMapPromise;
  * const program = getTodo(1)
  * ```
  *
- * @example
- * // Title: Custom Error Handling
+ * **Example** (Custom Error Handling)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * const getTodo = (id: number) =>
@@ -3184,6 +3238,9 @@ const tryMapPromise = exports.tryMapPromise = effect.tryMapPromise;
  * //      ┌─── Effect<Response, Error, never>
  * //      ▼
  * const program = getTodo(1)
+ * ```
+ *
+ * @see {@link promise} if the effectful computation is asynchronous and does not throw errors.
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -3241,7 +3298,8 @@ const allowInterrupt = exports.allowInterrupt = effect.allowInterrupt;
  * operation can be interrupted, such as when performing asynchronous operations
  * or handling cancellation.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -3255,10 +3313,10 @@ const allowInterrupt = exports.allowInterrupt = effect.allowInterrupt;
  *   })
  * })
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output: You can interrupt this operation.
  *
- * // Effect.runPromise(program.pipe(Effect.uninterruptible))
+ * Effect.runPromise(program.pipe(Effect.uninterruptible))
  * // Output: This operation cannot be interrupted.
  *
  * ```
@@ -3290,10 +3348,8 @@ const checkInterruptible = exports.checkInterruptible = core.checkInterruptible;
  * error or trigger alternative logic. This enables faster timeout handling
  * without waiting for the completion of the long-running task.
  *
- * @see {@link timeout} for a version that interrupts the effect.
- * @see {@link uninterruptible} for creating an uninterruptible effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3311,7 +3367,7 @@ const checkInterruptible = exports.checkInterruptible = core.checkInterruptible;
  *   Effect.timeout("1 second")
  * )
  *
- * // Effect.runPromiseExit(timedEffect).then(console.log)
+ * Effect.runPromiseExit(timedEffect).then(console.log)
  * // Output:
  * // Start heavy processing...
  * // {
@@ -3326,6 +3382,9 @@ const checkInterruptible = exports.checkInterruptible = core.checkInterruptible;
  * // Heavy processing done.
  * ```
  *
+ * @see {@link timeout} for a version that interrupts the effect.
+ * @see {@link uninterruptible} for creating an uninterruptible effect.
+ *
  * @since 2.0.0
  * @category Interruption
  */
@@ -3341,7 +3400,8 @@ const disconnect = exports.disconnect = fiberRuntime.disconnect;
  * The resulting interruption can be observed in the `Exit` type if the effect
  * is run with functions like {@link runPromiseExit}.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3353,7 +3413,7 @@ const disconnect = exports.disconnect = fiberRuntime.disconnect;
  *   return "some result"
  * })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // start
  * // {
@@ -3406,9 +3466,9 @@ const interruptibleMask = exports.interruptibleMask = core.interruptibleMask;
  * interrupted. This effect will be executed when the fiber is interrupted,
  * allowing you to perform cleanup or other actions.
  *
- * @example
+ * **Example** (Running a Cleanup Action on Interruption)
+ *
  * ```ts
- * // Title: Running a Cleanup Action on Interruption
  * import { Console, Effect } from "effect"
  *
  * // This handler is executed when the fiber is interrupted
@@ -3416,19 +3476,19 @@ const interruptibleMask = exports.interruptibleMask = core.interruptibleMask;
  *
  * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler)
  *
- * // Effect.runFork(success)
+ * Effect.runFork(success)
  * // Output:
  * // Task completed
  *
  * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler)
  *
- * // Effect.runFork(failure)
+ * Effect.runFork(failure)
  * // Output:
  * // Task failed
  *
  * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler)
  *
- * // Effect.runFork(interruption)
+ * Effect.runFork(interruption)
  * // Output:
  * // Task interrupted
  * // Cleanup completed
@@ -3458,7 +3518,8 @@ const uninterruptibleMask = exports.uninterruptibleMask = core.uninterruptibleMa
  * Transforms a `Predicate` function into an `Effect` returning the input value if the predicate returns `true`
  * or failing with specified error if the predicate fails
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3490,15 +3551,15 @@ const liftPredicate = exports.liftPredicate = effect.liftPredicate;
  * result instead. For instance, you can replace the value produced by a
  * computation with a predefined value, ignoring what was calculated before.
  *
- * @example
+ * **Example** (Replacing a Value)
+ *
  * ```ts
- * // Title: Replacing a Value
  * import { pipe, Effect } from "effect"
  *
  * // Replaces the value 5 with the constant "new value"
  * const program = pipe(Effect.succeed(5), Effect.as("new value"))
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output: "new value"
  * ```
  *
@@ -3543,7 +3604,8 @@ const asVoid = exports.asVoid = core.asVoid;
  * error channels. The success value becomes an error, and the error value
  * becomes a success.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3590,13 +3652,9 @@ const flipWith = exports.flipWith = effect.flipWith;
  * effect is not modified. Instead, a new effect is returned with the updated
  * value.
  *
- * @see {@link mapError} for a version that operates on the error channel.
- * @see {@link mapBoth} for a version that operates on both channels.
- * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
+ * **Example** (Adding a Service Charge)
  *
- * @example
  * ```ts
- * // Title: Adding a Service Charge
  * import { pipe, Effect } from "effect"
  *
  * const addServiceCharge = (amount: number) => amount + 1
@@ -3608,9 +3666,14 @@ const flipWith = exports.flipWith = effect.flipWith;
  *   Effect.map(addServiceCharge)
  * )
  *
- * // Effect.runPromise(finalAmount).then(console.log)
+ * Effect.runPromise(finalAmount).then(console.log)
  * // Output: 101
  * ```
+ *
+ * @see {@link mapError} for a version that operates on the error channel.
+ * @see {@link mapBoth} for a version that operates on both channels.
+ * @see {@link flatMap} or {@link andThen} for a version that can return a new effect.
+ *
  * @since 2.0.0
  * @category Mapping
  */
@@ -3634,7 +3697,8 @@ const map = exports.map = core.map;
  * If the input collection is a non-empty array, the return type will match the
  * input collection type.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3647,10 +3711,10 @@ const map = exports.map = core.map;
  * // Apply mapAccum to transform an array of strings
  * const program = Effect.mapAccum(["a", "bb", "ccc"], initialState, transformation)
  *
- * // Effect.runPromise(program).then(([finalState, transformedCollection]) => {
- * //   console.log(finalState)
- * //   console.log(transformedCollection)
- * // })
+ * Effect.runPromise(program).then(([finalState, transformedCollection]) => {
+ *   console.log(finalState)
+ *   console.log(transformedCollection)
+ * })
  * // Output:
  * // 6
  * // [ 'A', 'BB', 'CCC' ]
@@ -3670,10 +3734,8 @@ const mapAccum = exports.mapAccum = effect.mapAccum;
  * the error and the success values without altering the overall success or
  * failure status of the effect.
  *
- * @see {@link map} for a version that operates on the success channel.
- * @see {@link mapError} for a version that operates on the error channel.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3689,6 +3751,9 @@ const mapAccum = exports.mapAccum = effect.mapAccum;
  * })
  * ```
  *
+ * @see {@link map} for a version that operates on the success channel.
+ * @see {@link mapError} for a version that operates on the error channel.
+ *
  * @since 2.0.0
  * @category Mapping
  */
@@ -3704,11 +3769,8 @@ const mapBoth = exports.mapBoth = core.mapBoth;
  * keeping the original behavior of the effect's success values intact. It only
  * operates on the error channel and leaves the success channel unchanged.
  *
- * @see {@link map} for a version that operates on the success channel.
- * @see {@link mapBoth} for a version that operates on both channels.
- * @see {@link orElseFail} if you want to replace the error with a new one.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3724,6 +3786,10 @@ const mapBoth = exports.mapBoth = core.mapBoth;
  * )
  * ```
  *
+ * @see {@link map} for a version that operates on the success channel.
+ * @see {@link mapBoth} for a version that operates on both channels.
+ * @see {@link orElseFail} if you want to replace the error with a new one.
+ *
  * @since 2.0.0
  * @category Mapping
  */
@@ -3753,7 +3819,8 @@ const mapErrorCause = exports.mapErrorCause = effect.mapErrorCause;
  * error type and still capture both successful results and errors as part of
  * the outcome.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -3812,11 +3879,9 @@ const negate = exports.negate = effect.negate;
  * etc.) will not be interrupted, and that the resource will always be released
  * when the `Effect` completes execution.
  *
- * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources.
+ * **Example** (Defining a Simple Resource)
  *
- * @example
  * ```ts
- * // Title: Defining a Simple Resource
  * import { Effect } from "effect"
  *
  * // Define an interface for a resource
@@ -3856,6 +3921,8 @@ const negate = exports.negate = effect.negate;
  * const resource = Effect.acquireRelease(acquire, release)
  * ```
  *
+ * @see {@link acquireUseRelease} for a version that automatically handles the scoping of resources.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -3875,23 +3942,21 @@ const acquireRelease = exports.acquireRelease = fiberRuntime.acquireRelease;
  */
 const acquireReleaseInterruptible = exports.acquireReleaseInterruptible = fiberRuntime.acquireReleaseInterruptible;
 /**
- * Creates a scoped resource and automatically handles the use effect during the
- * scope.
+ * Many real-world operations involve working with resources that must be released when no longer needed, such as:
  *
- * **Details**
+ * - Database connections
+ * - File handles
+ * - Network requests
+ *
+ * This function ensures that a resource is:
  *
- * This function is similar to {@link acquireRelease}, but it introduces an
- * additional `use` effect. This allows you to automatically execute the `use`
- * effect while the resource is acquired, and it also ensures that the `release`
- * effect is performed when the scope is closed.
+ * 1. **Acquired** properly.
+ * 2. **Used** for its intended purpose.
+ * 3. **Released** even if an error occurs.
  *
- * The `acquire` effect is used to obtain the resource, the `use` effect
- * operates while the resource is in use, and the `release` effect cleans up the
- * resource when the scope ends.
+ * **Example** (Automatically Managing Resource Lifetime)
  *
- * @example
  * ```ts
- * // Title: Automatically Managing Resource Lifetime
  * import { Effect, Console } from "effect"
  *
  * // Define an interface for a resource
@@ -3930,7 +3995,7 @@ const acquireReleaseInterruptible = exports.acquireReleaseInterruptible = fiberR
  * //      ▼
  * const program = Effect.acquireUseRelease(acquire, use, release)
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Resource acquired
  * // content is lorem ipsum
@@ -3960,11 +4025,9 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * effect with a finalizer is wrapped in a scope, the finalizer will execute
  * automatically when the scope ends.
  *
- * @see {@link onExit} for attaching a finalizer directly to an effect.
+ * **Example** (Adding a Finalizer on Success)
  *
- * @example
  * ```ts
- * // Title: Adding a Finalizer on Success
  * import { Effect, Console } from "effect"
  *
  * //      ┌─── Effect<string, never, Scope>
@@ -3982,15 +4045,15 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * //      ▼
  * const runnable = Effect.scoped(program)
  *
- * // Effect.runPromiseExit(runnable).then(console.log)
+ * Effect.runPromiseExit(runnable).then(console.log)
  * // Output:
  * // Finalizer executed. Exit status: Success
  * // { _id: 'Exit', _tag: 'Success', value: 'some result' }
  * ```
  *
- * @example
+ * **Example** (Adding a Finalizer on Failure)
+ *
  * ```ts
- * // Title: Adding a Finalizer on Failure
  * import { Effect, Console } from "effect"
  *
  * //      ┌─── Effect<never, string, Scope>
@@ -4008,7 +4071,7 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * //      ▼
  * const runnable = Effect.scoped(program)
  *
- * // Effect.runPromiseExit(runnable).then(console.log)
+ * Effect.runPromiseExit(runnable).then(console.log)
  * // Output:
  * // Finalizer executed. Exit status: Failure
  * // {
@@ -4018,9 +4081,9 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * // }
  * ```
  *
- * @example
+ * **Example** (Adding a Finalizer on Interruption)
+ *
  * ```ts
- * // Title: Adding a Finalizer on Interruption
  * import { Effect, Console } from "effect"
  *
  * //      ┌─── Effect<never, never, Scope>
@@ -4038,7 +4101,7 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * //      ▼
  * const runnable = Effect.scoped(program)
  *
- * // Effect.runPromiseExit(runnable).then(console.log)
+ * Effect.runPromiseExit(runnable).then(console.log)
  * // Output:
  * // Finalizer executed. Exit status: Failure
  * // {
@@ -4057,6 +4120,8 @@ const acquireUseRelease = exports.acquireUseRelease = core.acquireUseRelease;
  * // }
  * ```
  *
+ * @see {@link onExit} for attaching a finalizer directly to an effect.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4083,37 +4148,51 @@ const addFinalizer = exports.addFinalizer = fiberRuntime.addFinalizer;
  * For use cases where you need access to the result of an effect, consider
  * using {@link onExit}.
  *
- * @see {@link onExit} for a version that provides access to the result of an
- * effect.
+ * **Example** (Running a Finalizer in All Outcomes)
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
+ * // Define a cleanup effect
  * const handler = Effect.ensuring(Console.log("Cleanup completed"))
  *
- * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler)
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ *   Effect.as("some result"),
+ *   handler
+ * )
  *
- * // Effect.runFork(success)
+ * Effect.runFork(success)
  * // Output:
  * // Task completed
  * // Cleanup completed
  *
- * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler)
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ *   Effect.andThen(Effect.fail("some error")),
+ *   handler
+ * )
  *
- * // Effect.runFork(failure)
+ * Effect.runFork(failure)
  * // Output:
  * // Task failed
  * // Cleanup completed
  *
- * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler)
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ *   Effect.andThen(Effect.interrupt),
+ *   handler
+ * )
  *
- * // Effect.runFork(interruption)
+ * Effect.runFork(interruption)
  * // Output:
  * // Task interrupted
  * // Cleanup completed
  * ```
  *
+ * @see {@link onExit} for a version that provides access to the result of an
+ * effect.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4133,37 +4212,63 @@ const ensuring = exports.ensuring = fiberRuntime.ensuring;
  * Importantly, the cleanup effect itself is uninterruptible, ensuring that it
  * completes regardless of external interruptions.
  *
- * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure.
- * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits.
+ * **Example** (Running Cleanup Only on Failure)
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
  * // This handler logs the failure cause when the effect fails
- * const handler = Effect.onError((cause) => Console.log(`Cleanup completed: ${cause}`))
+ * const handler = Effect.onError((cause) =>
+ *   Console.log(`Cleanup completed: ${cause}`)
+ * )
  *
- * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler)
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ *   Effect.as("some result"),
+ *   handler
+ * )
  *
- * // Effect.runFork(success)
+ * Effect.runFork(success)
  * // Output:
  * // Task completed
  *
- * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler)
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ *   Effect.andThen(Effect.fail("some error")),
+ *   handler
+ * )
  *
- * // Effect.runFork(failure)
+ * Effect.runFork(failure)
  * // Output:
  * // Task failed
  * // Cleanup completed: Error: some error
  *
- * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler)
+ * // Define a failing effect
+ * const defect = Console.log("Task failed with defect").pipe(
+ *   Effect.andThen(Effect.die("Boom!")),
+ *   handler
+ * )
+ *
+ * Effect.runFork(defect)
+ * // Output:
+ * // Task failed with defect
+ * // Cleanup completed: Error: Boom!
  *
- * // Effect.runFork(interruption)
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ *   Effect.andThen(Effect.interrupt),
+ *   handler
+ * )
+ *
+ * Effect.runFork(interruption)
  * // Output:
  * // Task interrupted
  * // Cleanup completed: All fibers interrupted without errors.
  * ```
  *
+ * @see {@link ensuring} for attaching a cleanup effect that runs on both success and failure.
+ * @see {@link onExit} for attaching a cleanup effect that runs on all possible exits.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4185,30 +4290,45 @@ const onError = exports.onError = core.onError;
  * The cleanup function is guaranteed to run uninterruptibly, ensuring reliable
  * resource management even in complex or high-concurrency scenarios.
  *
- * @example
+ * **Example** (Running a Cleanup Function with the Effect’s Result)
+ *
  * ```ts
  * import { Console, Effect, Exit } from "effect"
  *
- * // Define a cleanup function that logs the outcome of the effect
- * const handler = Effect.onExit((exit) => Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`))
+ * // Define a cleanup effect that logs the result
+ * const handler = Effect.onExit((exit) =>
+ *   Console.log(`Cleanup completed: ${Exit.getOrElse(exit, String)}`)
+ * )
  *
- * const success = Console.log("Task completed").pipe(Effect.as("some result"), handler)
+ * // Define a successful effect
+ * const success = Console.log("Task completed").pipe(
+ *   Effect.as("some result"),
+ *   handler
+ * )
  *
- * // Effect.runFork(success)
+ * Effect.runFork(success)
  * // Output:
  * // Task completed
  * // Cleanup completed: some result
  *
- * const failure = Console.log("Task failed").pipe(Effect.andThen(Effect.fail("some error")), handler)
+ * // Define a failing effect
+ * const failure = Console.log("Task failed").pipe(
+ *   Effect.andThen(Effect.fail("some error")),
+ *   handler
+ * )
  *
- * // Effect.runFork(failure)
+ * Effect.runFork(failure)
  * // Output:
  * // Task failed
  * // Cleanup completed: Error: some error
  *
- * const interruption = Console.log("Task interrupted").pipe(Effect.andThen(Effect.interrupt), handler)
+ * // Define an interrupted effect
+ * const interruption = Console.log("Task interrupted").pipe(
+ *   Effect.andThen(Effect.interrupt),
+ *   handler
+ * )
  *
- * // Effect.runFork(interruption)
+ * Effect.runFork(interruption)
  * // Output:
  * // Task interrupted
  * // Cleanup completed: All fibers interrupted without errors.
@@ -4238,9 +4358,8 @@ const onExit = exports.onExit = core.onExit;
  * these tasks do not depend on the order of execution or introduce race
  * conditions.
  *
- * @see {@link sequentialFinalizers} for a version that ensures finalizers are run sequentially.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -4257,13 +4376,15 @@ const onExit = exports.onExit = core.onExit;
  *
  * const runnable = Effect.scoped(modified)
  *
- * // Effect.runFork(runnable)
+ * Effect.runFork(runnable)
  * // Output:
  * // Finalizer 2 executed
  * // Finalizer 3 executed
  * // Finalizer 1 executed
  * ```
  *
+ * @see {@link sequentialFinalizers} for a version that ensures finalizers are run sequentially.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4350,9 +4471,8 @@ const scoped = exports.scoped = fiberRuntime.scopedEffect;
  * resources are cleaned up as soon as the `use` effect completes, regardless of
  * how the `use` effect ends (success, failure, or interruption).
  *
- * @see {@link scopedWith} Manage scoped operations with a temporary scope.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -4364,13 +4484,15 @@ const scoped = exports.scoped = fiberRuntime.scopedEffect;
  *
  * const program = acquire.pipe(Effect.using(use))
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Acquiring resource
  * // Using resource: 1
  * // Releasing resource
  * ```
  *
+ * @see {@link scopedWith} Manage scoped operations with a temporary scope.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4385,7 +4507,8 @@ const using = exports.using = fiberRuntime.using;
  * workflows where you need early access to the result while retaining control
  * over the resource cleanup process.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -4503,9 +4626,8 @@ const fiberIdWith = exports.fiberIdWith = core.fiberIdWith;
  * higher-level functions like {@link raceWith}, {@link zip}, or others that can
  * manage concurrency for you.
  *
- * @see {@link forkWithErrorHandler} for a version that allows you to handle errors.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -4519,6 +4641,8 @@ const fiberIdWith = exports.fiberIdWith = core.fiberIdWith;
  * const fib10Fiber = Effect.fork(fib(10))
  * ```
  *
+ * @see {@link forkWithErrorHandler} for a version that allows you to handle errors.
+ *
  * @since 2.0.0
  * @category Supervision & Fibers
  */
@@ -4535,9 +4659,9 @@ const fork = exports.fork = fiberRuntime.fork;
  * useful for tasks that need to run in the background independently, such as
  * periodic logging, monitoring, or background data processing.
  *
- * @example
+ * **Example** (Creating a Daemon Fibe)
+ *
  * ```ts
- * // Title: Creating a Daemon Fibe
  * import { Effect, Console, Schedule } from "effect"
  *
  * // Daemon fiber that logs a message repeatedly every second
@@ -4554,7 +4678,7 @@ const fork = exports.fork = fiberRuntime.fork;
  *   console.log("parent: finished!")
  * })
  *
- * // Effect.runFork(parent)
+ * Effect.runFork(parent)
  * // Output:
  * // parent: started!
  * // daemon: still running!
@@ -4593,15 +4717,13 @@ const forkAll = exports.forkAll = circular.forkAll;
  *
  * The fiber will be interrupted when the scope is closed.
  *
- * @example
- * ```ts
- * // Title: Forking a Fiber in a Specific Scope
- * //
- * // In this example, the child fiber is forked into the outerScope,
- * // allowing it to outlive the inner scope but still be terminated
- * // when the outerScope is closed.
- * //
+ * **Example** (Forking a Fiber in a Specific Scope)
+ *
+ * In this example, the child fiber is forked into the outerScope,
+ * allowing it to outlive the inner scope but still be terminated
+ * when the outerScope is closed.
  *
+ * ```ts
  * import { Console, Effect, Schedule } from "effect"
  *
  * // Child fiber that logs a message repeatedly every second
@@ -4635,7 +4757,7 @@ const forkAll = exports.forkAll = circular.forkAll;
  *   })
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // child: still running!
  * // child: still running!
@@ -4671,14 +4793,12 @@ const forkIn = exports.forkIn = circular.forkIn;
  * terminates. With `forkScoped`, the child fiber will keep running until the
  * local scope ends, regardless of the state of the parent fiber.
  *
- * @example
- * ```ts
- * // Title: Forking a Fiber in a Local Scope
- * //
- * // In this example, the child fiber continues to run beyond the lifetime of the parent fiber.
- * // The child fiber is tied to the local scope and will be terminated only when the scope ends.
- * //
+ * **Example** (Forking a Fiber in a Local Scope)
+ *
+ * In this example, the child fiber continues to run beyond the lifetime of the parent fiber.
+ * The child fiber is tied to the local scope and will be terminated only when the scope ends.
  *
+ * ```ts
  * import { Effect, Console, Schedule } from "effect"
  *
  * // Child fiber that logs a message repeatedly every second
@@ -4708,7 +4828,7 @@ const forkIn = exports.forkIn = circular.forkIn;
  *   })
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Local scope started!
  * // parent: started!
@@ -4762,9 +4882,9 @@ const fromFiberEffect = exports.fromFiberEffect = circular.fromFiberEffect;
  * This enables you to capture detailed information about these child fibers,
  * such as their status, through the supervisor.
  *
- * @example
+ * **Example** (Monitoring Fiber Count)
+ *
  * ```ts
- * // Title: Monitoring Fiber Count
  * import { Effect, Supervisor, Schedule, Fiber, FiberStatus } from "effect"
  *
  * // Main program that monitors fibers while calculating a Fibonacci number
@@ -4832,7 +4952,7 @@ const fromFiberEffect = exports.fromFiberEffect = circular.fromFiberEffect;
  *     return v1 + v2 // Combine the results
  *   })
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // number of fibers: 0
  * // number of fibers: 2
@@ -4902,7 +5022,8 @@ const withMaxOpsBeforeYield = exports.withMaxOpsBeforeYield = core.withMaxOpsBef
 /**
  * Retrieves the `Clock` service from the context.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -4912,7 +5033,7 @@ const withMaxOpsBeforeYield = exports.withMaxOpsBeforeYield = core.withMaxOpsBef
  *   console.log(`Current time in milliseconds: ${currentTime}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // Current time in milliseconds: 1735484796134
  * ```
@@ -4925,7 +5046,8 @@ const clock = exports.clock = effect.clock;
  * Retrieves the `Clock` service from the context and provides it to the
  * specified effectful function.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -4936,7 +5058,7 @@ const clock = exports.clock = effect.clock;
  *   )
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // Current time is: 1735484929744
  * ```
@@ -5004,7 +5126,8 @@ const withConsole = exports.withConsole = console_.withConsole;
  * Internally, this function does not block the thread; instead, it uses an
  * efficient, non-blocking mechanism to introduce the delay.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -5017,7 +5140,7 @@ const withConsole = exports.withConsole = console_.withConsole;
  *   )
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // start
  * // Task executed
@@ -5041,7 +5164,8 @@ const delay = exports.delay = effect.delay;
  * `Duration` module, such as a string (`"2 seconds"`) or numeric value
  * representing milliseconds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5051,7 +5175,7 @@ const delay = exports.delay = effect.delay;
  *   console.log("Task completed!")
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Starting task...
  * // Task completed!
@@ -5077,7 +5201,8 @@ const sleep = exports.sleep = effect.sleep;
  * unchanged, and the timing information is provided alongside the result in a
  * tuple.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Duration, Effect } from "effect"
  *
@@ -5093,7 +5218,7 @@ const sleep = exports.sleep = effect.sleep;
  *   console.log(`Task completed in ${Duration.toMillis(duration)} ms with result: ${result}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: Task completed in 2003.749125 ms with result: some result
  * ```
  *
@@ -5133,12 +5258,8 @@ const timedWith = exports.timedWith = effect.timedWith;
  *   specified duration.
  * - Fail with a `TimeoutException` if the time limit is exceeded.
  *
- * @see {@link timeoutFail} for a version that raises a custom error.
- * @see {@link timeoutFailCause} for a version that raises a custom defect.
- * @see {@link timeoutTo} for a version that allows specifying both success and
- * timeout handlers.
- *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5153,7 +5274,7 @@ const timedWith = exports.timedWith = effect.timedWith;
  * // than the specified timeout duration
  * const timedEffect = task.pipe(Effect.timeout("1 second"))
  *
- * // Effect.runPromiseExit(timedEffect).then(console.log)
+ * Effect.runPromiseExit(timedEffect).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5167,6 +5288,11 @@ const timedWith = exports.timedWith = effect.timedWith;
  * // }
  * ```
  *
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
  * @since 2.0.0
  * @category Delays & Timeouts
  */
@@ -5190,13 +5316,8 @@ const timeout = exports.timeout = circular.timeout;
  * to fail, making it easier to manage situations where you expect tasks might
  * take too long but want to continue executing other tasks.
  *
- * @see {@link timeout} for a version that raises a `TimeoutException`.
- * @see {@link timeoutFail} for a version that raises a custom error.
- * @see {@link timeoutFailCause} for a version that raises a custom defect.
- * @see {@link timeoutTo} for a version that allows specifying both success and
- * timeout handlers.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5212,7 +5333,7 @@ const timeout = exports.timeout = circular.timeout;
  *   task.pipe(Effect.timeoutOption("1 second"))
  * ])
  *
- * // Effect.runPromise(timedOutEffect).then(console.log)
+ * Effect.runPromise(timedOutEffect).then(console.log)
  * // Output:
  * // Start processing...
  * // Processing complete.
@@ -5223,6 +5344,12 @@ const timeout = exports.timeout = circular.timeout;
  * // ]
  * ```
  *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
  * @since 3.1.0
  * @category Delays & Timeouts
  */
@@ -5247,12 +5374,8 @@ const timeoutOption = exports.timeoutOption = circular.timeoutOption;
  * normally. Otherwise, the `onTimeout` function is triggered, and its output is
  * used as the error for the effect.
  *
- * @see {@link timeout} for a version that raises a `TimeoutException`.
- * @see {@link timeoutFailCause} for a version that raises a custom defect.
- * @see {@link timeoutTo} for a version that allows specifying both success and
- * timeout handlers.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5274,7 +5397,7 @@ const timeoutOption = exports.timeoutOption = circular.timeoutOption;
  *   })
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5288,6 +5411,11 @@ const timeoutOption = exports.timeoutOption = circular.timeoutOption;
  * // }
  * ```
  *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
  * @since 2.0.0
  * @category Delays & Timeouts
  */
@@ -5314,12 +5442,8 @@ const timeoutFail = exports.timeoutFail = circular.timeoutFail;
  * failures in your application and wish to include meaningful information in
  * the defect.
  *
- * @see {@link timeout} for a version that raises a `TimeoutException`.
- * @see {@link timeoutFail} for a version that raises a custom error.
- * @see {@link timeoutTo} for a version that allows specifying both success and
- * timeout handlers.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Cause } from "effect"
  *
@@ -5337,7 +5461,7 @@ const timeoutFail = exports.timeoutFail = circular.timeoutFail;
  *   })
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5347,6 +5471,11 @@ const timeoutFail = exports.timeoutFail = circular.timeoutFail;
  * // }
  * ```
  *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutTo} for a version that allows specifying both success and
+ * timeout handlers.
+ *
  * @since 2.0.0
  * @category Delays & Timeouts
  */
@@ -5372,11 +5501,8 @@ const timeoutFailCause = exports.timeoutFailCause = circular.timeoutFailCause;
  * and successes into a specific data structure, like an `Either` type, to
  * represent these outcomes in a meaningful way.
  *
- * @see {@link timeout} for a version that raises a `TimeoutException`.
- * @see {@link timeoutFail} for a version that raises a custom error.
- * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Either } from "effect"
  *
@@ -5397,7 +5523,7 @@ const timeoutFailCause = exports.timeoutFailCause = circular.timeoutFailCause;
  *   })
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5407,6 +5533,10 @@ const timeoutFailCause = exports.timeoutFailCause = circular.timeoutFailCause;
  * // }
  * ```
  *
+ * @see {@link timeout} for a version that raises a `TimeoutException`.
+ * @see {@link timeoutFail} for a version that raises a custom error.
+ * @see {@link timeoutFailCause} for a version that raises a custom defect.
+ *
  * @since 2.0.0
  * @category Delays & Timeouts
  */
@@ -5439,7 +5569,8 @@ const configProviderWith = exports.configProviderWith = defaultServices.configPr
  * This is particularly useful when you need to use a different set of
  * configuration values or sources for specific parts of your application.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Config, ConfigProvider, Effect } from "effect"
  *
@@ -5454,7 +5585,7 @@ const configProviderWith = exports.configProviderWith = defaultServices.configPr
  *   })
  * )
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Config value: custom-value
  * ```
@@ -5527,7 +5658,8 @@ const contextWithEffect = exports.contextWithEffect = core.contextWithEffect;
  * 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
+ * **Example**
+ *
  * ```ts
  * import { Context, Effect } from "effect"
  *
@@ -5579,9 +5711,8 @@ const mapInputContext = exports.mapInputContext = core.mapInputContext;
  * environment for effects. For example, layers can be used to configure
  * databases, logging services, or any other required dependencies.
  *
- * @see {@link provideService} for providing a service to an effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Context, Effect, Layer } from "effect"
  *
@@ -5610,12 +5741,14 @@ const mapInputContext = exports.mapInputContext = core.mapInputContext;
  * //      ▼
  * const runnable = Effect.provide(program, DatabaseLive)
  *
- * // Effect.runPromise(runnable).then(console.log)
+ * Effect.runPromise(runnable).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message="Executing query: SELECT * FROM users"
  * // []
  * ```
  *
+ * @see {@link provideService} for providing a service to an effect.
+ *
  * @since 2.0.0
  * @category Context
  */
@@ -5636,9 +5769,8 @@ const provide = exports.provide = layer.effect_provide;
  * provided, all parts of the effect that rely on the service will automatically
  * use the implementation you supplied.
  *
- * @see {@link provide} for providing multiple layers to an effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Context } from "effect"
  *
@@ -5664,11 +5796,13 @@ const provide = exports.provide = layer.effect_provide;
  * })
  *
  * // Run successfully
- * // Effect.runPromise(runnable)
+ * Effect.runPromise(runnable)
  * // Example Output:
  * // random number: 0.8241872233134417
  * ```
  *
+ * @see {@link provide} for providing multiple layers to an effect.
+ *
  * @since 2.0.0
  * @category Context
  */
@@ -5795,11 +5929,8 @@ const updateService = exports.updateService = effect.updateService;
  * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  *
- * @see {@link bind}
- * @see {@link bindTo}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
  * import * as assert from "node:assert"
  * import { Effect, pipe } from "effect"
@@ -5813,6 +5944,10 @@ const updateService = exports.updateService = effect.updateService;
  * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
  * ```
  *
+ * @see {@link bind}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
  * @category Do notation
  * @since 2.0.0
  */
@@ -5827,11 +5962,8 @@ const Do = exports.Do = effect.Do;
  * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  *
- * @see {@link Do}
- * @see {@link bindTo}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
  * import * as assert from "node:assert"
  * import { Effect, pipe } from "effect"
@@ -5845,6 +5977,10 @@ const Do = exports.Do = effect.Do;
  * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
  * ```
  *
+ * @see {@link Do}
+ * @see {@link bindTo}
+ * @see {@link let_ let}
+ *
  * @category Do notation
  * @since 2.0.0
  */
@@ -5854,7 +5990,8 @@ const bind = exports.bind = effect.bind;
  * when you want to concurrently run multiple effects and then combine their
  * results in a Do notation pipeline.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import * as assert from "node:assert"
  * import { Effect, Either, pipe } from "effect"
@@ -5884,11 +6021,8 @@ const bindAll = exports.bindAll = circular.bindAll;
  * 3. You can accumulate multiple `bind` statements to define multiple variables within the scope
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  *
- * @see {@link Do}
- * @see {@link bind}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
  * import * as assert from "node:assert"
  * import { Effect, pipe } from "effect"
@@ -5902,6 +6036,10 @@ const bindAll = exports.bindAll = circular.bindAll;
  * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
  * ```
  *
+ * @see {@link Do}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
  * @category Do notation
  * @since 2.0.0
  */
@@ -5922,17 +6060,14 @@ const let_ = exports.let = effect.let_;
  * directly. However, unrecoverable errors, also referred to as defects, are
  * not captured and will still result in failure.
  *
- * @see {@link either} for a version that uses `Either` instead.
- * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ * **Example** (Using Effect.option to Handle Errors)
  *
- * @example
  * ```ts
- * // Title: Using Effect.option to Handle Errors
  * import { Effect } from "effect"
  *
  * const maybe1 = Effect.option(Effect.succeed(1))
  *
- * // Effect.runPromiseExit(maybe1).then(console.log)
+ * Effect.runPromiseExit(maybe1).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -5942,7 +6077,7 @@ const let_ = exports.let = effect.let_;
  *
  * const maybe2 = Effect.option(Effect.fail("Uh oh!"))
  *
- * // Effect.runPromiseExit(maybe2).then(console.log)
+ * Effect.runPromiseExit(maybe2).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -5952,7 +6087,7 @@ const let_ = exports.let = effect.let_;
  *
  * const maybe3 = Effect.option(Effect.die("Boom!"))
  *
- * // Effect.runPromiseExit(maybe3).then(console.log)
+ * Effect.runPromiseExit(maybe3).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -5961,6 +6096,9 @@ const let_ = exports.let = effect.let_;
  * // }
  * ```
  *
+ * @see {@link either} for a version that uses `Either` instead.
+ * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ *
  * @since 2.0.0
  * @category Outcome Encapsulation
  */
@@ -5988,10 +6126,8 @@ const option = exports.option = effect.option;
  * The resulting effect cannot fail directly because all recoverable failures
  * are represented inside the `Either` type.
  *
- * @see {@link option} for a version that uses `Option` instead.
- * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Either, Random } from "effect"
  *
@@ -6030,6 +6166,9 @@ const option = exports.option = effect.option;
  * })
  * ```
  *
+ * @see {@link option} for a version that uses `Option` instead.
+ * @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+ *
  * @since 2.0.0
  * @category Outcome Encapsulation
  */
@@ -6053,10 +6192,8 @@ const either = exports.either = core.either;
  * error type is `never`). It is particularly useful for workflows where all
  * outcomes, including unexpected defects, must be managed and analyzed.
  *
- * @see {@link option} for a version that uses `Option` instead.
- * @see {@link either} for a version that uses `Either` instead.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Cause, Console, Exit } from "effect"
  *
@@ -6081,7 +6218,7 @@ const either = exports.either = core.either;
  * })
  *
  * // We get an Exit.Success because we caught all failures
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // RuntimeException defect caught: Boom!
  * // {
@@ -6091,6 +6228,9 @@ const either = exports.either = core.either;
  * // }
  * ```
  *
+ * @see {@link option} for a version that uses `Option` instead.
+ * @see {@link either} for a version that uses `Either` instead.
+ *
  * @since 2.0.0
  * @category Outcome Encapsulation
  */
@@ -6105,7 +6245,8 @@ const exit = exports.exit = core.exit;
  * completed with the success value. If the effect fails, the `Deferred` is completed with the
  * failure. Additionally, if the effect is interrupted, the `Deferred` will also be interrupted.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Deferred, Effect } from "effect"
  *
@@ -6126,7 +6267,7 @@ const exit = exports.exit = core.exit;
  *   return isCompleted
  * })
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // 42
  * // true
@@ -6204,7 +6345,8 @@ const filterOrElse = exports.filterOrElse = effect.filterOrElse;
  * guard](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
  * Let's explore this concept through an example:
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -6243,7 +6385,8 @@ const filterOrFail = exports.filterOrFail = effect.filterOrFail;
  * effect. The `orElse` effect can produce an alternative value or perform
  * additional computations.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -6283,7 +6426,8 @@ const filterEffectOrElse = exports.filterEffectOrElse = core.filterEffectOrElse;
  * This is useful for enforcing constraints and treating violations as
  * recoverable errors.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -6345,12 +6489,9 @@ const unlessEffect = exports.unlessEffect = effect.unlessEffect;
  * whether to execute an effect based on runtime logic, while also representing
  * the skipped case explicitly.
  *
- * @see {@link whenEffect} for a version that allows the condition to be an effect.
- * @see {@link unless} for a version that executes the effect when the condition is `false`.
+ * **Example** (Conditional Effect Execution)
  *
- * @example
  * ```ts
- * // Title: Conditional Effect Execution
  * import { Effect, Option } from "effect"
  *
  * const validateWeightOption = (
@@ -6360,7 +6501,7 @@ const unlessEffect = exports.unlessEffect = effect.unlessEffect;
  *   Effect.succeed(weight).pipe(Effect.when(() => weight >= 0))
  *
  * // Run with a valid weight
- * // Effect.runPromise(validateWeightOption(100)).then(console.log)
+ * Effect.runPromise(validateWeightOption(100)).then(console.log)
  * // Output:
  * // {
  * //   _id: "Option",
@@ -6369,7 +6510,7 @@ const unlessEffect = exports.unlessEffect = effect.unlessEffect;
  * // }
  *
  * // Run with an invalid weight
- * // Effect.runPromise(validateWeightOption(-5)).then(console.log)
+ * Effect.runPromise(validateWeightOption(-5)).then(console.log)
  * // Output:
  * // {
  * //   _id: "Option",
@@ -6377,6 +6518,9 @@ const unlessEffect = exports.unlessEffect = effect.unlessEffect;
  * // }
  * ```
  *
+ * @see {@link whenEffect} for a version that allows the condition to be an effect.
+ * @see {@link unless} for a version that executes the effect when the condition is `false`.
+ *
  * @since 2.0.0
  * @category Conditional Operators
  */
@@ -6398,12 +6542,9 @@ const when = exports.when = effect.when;
  * depends on the result of another effect, such as a random value, a
  * user-provided input, or a network request result.
  *
- * @see {@link when} for a version that allows the condition to be a boolean.
- * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`.
+ * **Example** (Using an Effect as a Condition)
  *
- * @example
  * ```ts
- * // Title: Using an Effect as a Condition
  * import { Effect, Random } from "effect"
  *
  * const randomIntOption = Random.nextInt.pipe(
@@ -6415,6 +6556,9 @@ const when = exports.when = effect.when;
  * // { _id: 'Option', _tag: 'Some', value: 8609104974198840 }
  * ```
  *
+ * @see {@link when} for a version that allows the condition to be a boolean.
+ * @see {@link unlessEffect} for a version that executes the effect when the condition is `false`.
+ *
  * @since 2.0.0
  * @category Conditional Operators
  */
@@ -6483,9 +6627,8 @@ const whenRef = exports.whenRef = effect.whenRef;
  * step produces a new `Effect` while flattening any nested effects that may
  * occur.
  *
- * @see {@link tap} for a version that ignores the result of the effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { pipe, Effect } from "effect"
  *
@@ -6507,10 +6650,12 @@ const whenRef = exports.whenRef = effect.whenRef;
  *   Effect.flatMap((amount) => applyDiscount(amount, 5))
  * )
  *
- * // Effect.runPromise(finalAmount).then(console.log)
+ * Effect.runPromise(finalAmount).then(console.log)
  * // Output: 95
  * ```
  *
+ * @see {@link tap} for a version that ignores the result of the effect.
+ *
  * @since 2.0.0
  * @category Sequencing
  */
@@ -6549,9 +6694,9 @@ const flatMap = exports.flatMap = core.flatMap;
  * **Note:** `andThen` works well with both `Option` and `Either` types,
  * treating them as effects.
  *
- * @example
+ * **Example** (Applying a Discount Based on Fetched Amount)
+ *
  * ```ts
- * // Title: Applying a Discount Based on Fetched Amount
  * import { pipe, Effect } from "effect"
  *
  * // Function to apply a discount safely to a transaction amount
@@ -6573,7 +6718,7 @@ const flatMap = exports.flatMap = core.flatMap;
  *   Effect.flatMap((amount) => applyDiscount(amount, 5))
  * )
  *
- * // Effect.runPromise(result1).then(console.log)
+ * Effect.runPromise(result1).then(console.log)
  * // Output: 190
  *
  * // Using Effect.andThen
@@ -6583,7 +6728,7 @@ const flatMap = exports.flatMap = core.flatMap;
  *   Effect.andThen((amount) => applyDiscount(amount, 5))
  * )
  *
- * // Effect.runPromise(result2).then(console.log)
+ * Effect.runPromise(result2).then(console.log)
  * // Output: 190
  * ```
  *
@@ -6622,12 +6767,9 @@ const flatten = exports.flatten = core.flatten;
  * wraps the result in an `Either` type, allowing you to see if the result
  * was a success (`Right`) or a failure (`Left`).
  *
- * @see {@link raceAll} for a version that handles multiple effects.
- * @see {@link raceFirst} for a version that returns the result of the first effect to complete.
+ * **Example** (Both Tasks Succeed)
  *
- * @example
  * ```ts
- * // Title: Both Tasks Succeed
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.succeed("task1").pipe(
@@ -6643,15 +6785,15 @@ const flatten = exports.flatten = core.flatten;
  *
  * const program = Effect.race(task1, task2)
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1 done
  * // task2 interrupted
  * ```
  *
- * @example
+ * **Example** (One Task Fails, One Succeeds)
+ *
  * ```ts
- * // Title: One Task Fails, One Succeeds
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6667,14 +6809,14 @@ const flatten = exports.flatten = core.flatten;
  *
  * const program = Effect.race(task1, task2)
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task2 done
  * ```
  *
- * @example
+ * **Example** (Both Tasks Fail)
+ *
  * ```ts
- * // Title: Both Tasks Fail
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6690,7 +6832,7 @@ const flatten = exports.flatten = core.flatten;
  *
  * const program = Effect.race(task1, task2)
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -6704,9 +6846,9 @@ const flatten = exports.flatten = core.flatten;
  * // }
  * ```
  *
- * @example
+ * **Example** (Handling Success or Failure with Either)
+ *
  * ```ts
- * // Title: Handling Success or Failure with Either
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6724,12 +6866,15 @@ const flatten = exports.flatten = core.flatten;
  * // in Either to capture success or failure
  * const program = Effect.race(Effect.either(task1), Effect.either(task2))
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // task2 interrupted
  * // { _id: 'Either', _tag: 'Left', left: 'task1' }
  * ```
  *
+ * @see {@link raceAll} for a version that handles multiple effects.
+ * @see {@link raceFirst} for a version that returns the result of the first effect to complete.
+ *
  * @since 2.0.0
  * @category Racing
  */
@@ -6753,11 +6898,9 @@ const race = exports.race = fiberRuntime.race;
  * retries, or when you want to optimize for the faster response without
  * worrying about the other effects.
  *
- * @see {@link race} for a version that handles only two effects.
+ * **Example** (All Tasks Succeed)
  *
- * @example
  * ```ts
- * // Title: All Tasks Succeed
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.succeed("task1").pipe(
@@ -6779,16 +6922,16 @@ const race = exports.race = fiberRuntime.race;
  *
  * const program = Effect.raceAll([task1, task2, task3])
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1 done
  * // task2 interrupted
  * // task3 interrupted
  * ```
  *
- * @example
+ * **Example** (One Task Fails, Two Tasks Succeed)
+ *
  * ```ts
- * // Title: One Task Fails, Two Tasks Succeed
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6810,15 +6953,15 @@ const race = exports.race = fiberRuntime.race;
  *
  * const program = Effect.raceAll([task1, task2, task3])
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task3 done
  * // task2 interrupted
  * ```
  *
- * @example
+ * **Example** (All Tasks Fail)
+ *
  * ```ts
- * // Title: All Tasks Fail
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6840,7 +6983,7 @@ const race = exports.race = fiberRuntime.race;
  *
  * const program = Effect.raceAll([task1, task2, task3])
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -6849,6 +6992,8 @@ const race = exports.race = fiberRuntime.race;
  * // }
  * ```
  *
+ * @see {@link race} for a version that handles only two effects.
+ *
  * @since 2.0.0
  * @category Racing
  */
@@ -6886,9 +7031,9 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  *
  * This allows both effects to complete independently while still terminating the losing effect in the background.
  *
- * @example
+ * **Example** (Both Tasks Succeed)
+ *
  * ```ts
- * // Title: Both Tasks Succeed
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.succeed("task1").pipe(
@@ -6910,7 +7055,7 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  *   Effect.tap(Console.log("more work..."))
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task1 done
  * // task2 interrupted
@@ -6918,9 +7063,9 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  * // { _id: 'Exit', _tag: 'Success', value: 'task1' }
  * ```
  *
- * @example
+ * **Example** (One Task Fails, One Succeeds)
+ *
  * ```ts
- * // Title: One Task Fails, One Succeeds
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.fail("task1").pipe(
@@ -6942,7 +7087,7 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  *   Effect.tap(Console.log("more work..."))
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task2 interrupted
  * // {
@@ -6952,9 +7097,9 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  * // }
  * ```
  *
- * @example
+ * **Example** (Using Effect.disconnect for Quicker Return)
+ *
  * ```ts
- * // Title: Using Effect.disconnect for Quicker Return
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.succeed("task1").pipe(
@@ -6978,7 +7123,7 @@ const raceAll = exports.raceAll = fiberRuntime.raceAll;
  *   Effect.disconnect(task2)
  * ).pipe(Effect.tap(Console.log("more work...")))
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task1 done
  * // more work...
@@ -7011,9 +7156,9 @@ const raceFirst = exports.raceFirst = circular.raceFirst;
  * effect without waiting for both to finish. It can be used whenever you want
  * to take action based on the first available result.
  *
- * @example
+ * **Example** (Handling Results of Concurrent Tasks)
+ *
  * ```ts
- * // Title: Handling Results of Concurrent Tasks
  * import { Effect, Console } from "effect"
  *
  * const task1 = Effect.succeed("task1").pipe(
@@ -7036,7 +7181,7 @@ const raceFirst = exports.raceFirst = circular.raceFirst;
  *   onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1 done
  * // task1 exited with {
@@ -7078,11 +7223,9 @@ const summarized = exports.summarized = effect.summarized;
  * observe or record an action but want the original value to be passed to the
  * next step.
  *
- * @see {@link flatMap} for a version that allows you to change the value.
+ * **Example** (Logging a step in a pipeline)
  *
- * @example
  * ```ts
- * // Title: Logging a step in a pipeline
  * import { Console, Effect, pipe } from "effect"
  *
  * // Function to apply a discount safely to a transaction amount
@@ -7105,12 +7248,14 @@ const summarized = exports.summarized = effect.summarized;
  *   Effect.flatMap((amount) => applyDiscount(amount, 5))
  * )
  *
- * // Effect.runPromise(finalAmount).then(console.log)
+ * Effect.runPromise(finalAmount).then(console.log)
  * // Output:
  * // Apply a discount to: 100
  * // 95
  * ```
  *
+ * @see {@link flatMap} for a version that allows you to change the value.
+ *
  * @since 2.0.0
  * @category Sequencing
  */
@@ -7134,7 +7279,8 @@ const tap = exports.tap = core.tap;
  * If either the success or failure handler fails, the overall effect will also
  * fail.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Random, Console } from "effect"
  *
@@ -7152,7 +7298,7 @@ const tap = exports.tap = core.tap;
  *     Console.log(`random number: ${randomNumber}`)
  * })
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Example Output:
  * // failure: random number is negative
  * ```
@@ -7177,7 +7323,8 @@ const tapBoth = exports.tapBoth = effect.tapBoth;
  * way. Importantly, this does not alter the main result of the effect. If no
  * defect occurs, the effect behaves as if this function was not used.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -7189,7 +7336,7 @@ const tapBoth = exports.tapBoth = effect.tapBoth;
  *   Console.log(`defect: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping1)
+ * Effect.runFork(tapping1)
  * // No Output
  *
  * // Simulate a severe failure in the system
@@ -7202,7 +7349,7 @@ const tapBoth = exports.tapBoth = effect.tapBoth;
  *   Console.log(`defect: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping2)
+ * Effect.runFork(tapping2)
  * // Output:
  * // defect: RuntimeException: Something went wrong
  * //   ... stack trace ...
@@ -7227,7 +7374,8 @@ const tapDefect = exports.tapDefect = effect.tapDefect;
  * effect succeeds, the function is ignored, and the success value is propagated
  * as usual.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -7239,7 +7387,7 @@ const tapDefect = exports.tapDefect = effect.tapDefect;
  *   Console.log(`expected error: ${error}`)
  * )
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Output:
  * // expected error: NetworkError
  * ```
@@ -7262,7 +7410,8 @@ const tapError = exports.tapError = effect.tapError;
  * If the error doesn't match the specified tag, this function does nothing, and
  * the effect proceeds as usual.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -7285,7 +7434,7 @@ const tapError = exports.tapError = effect.tapError;
  *   Console.log(`expected error: ${error.statusCode}`)
  * )
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Output:
  * // expected error: 504
  * ```
@@ -7309,7 +7458,8 @@ const tapErrorTag = exports.tapErrorTag = effect.tapErrorTag;
  * The effect itself is not modified, and any errors or defects remain in the
  * error channel of the original effect.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -7320,7 +7470,7 @@ const tapErrorTag = exports.tapErrorTag = effect.tapErrorTag;
  *   Console.log(`error cause: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping1)
+ * Effect.runFork(tapping1)
  * // Output:
  * // error cause: Error: NetworkError
  *
@@ -7333,7 +7483,7 @@ const tapErrorTag = exports.tapErrorTag = effect.tapErrorTag;
  *   Console.log(`error cause: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping2)
+ * Effect.runFork(tapping2)
  * // Output:
  * // error cause: RuntimeException: Something went wrong
  * //   ... stack trace ...
@@ -7397,9 +7547,9 @@ const forever = exports.forever = effect.forever;
  * asynchronous or side-effectful operations, such as polling or iterative
  * computations that depend on external factors.
  *
- * @example
+ * **Example** (Effectful Iteration)
+ *
  * ```ts
- * // Title: Effectful Iteration
  * import { Effect } from "effect"
  *
  * const result = Effect.iterate(
@@ -7413,7 +7563,7 @@ const forever = exports.forever = effect.forever;
  *   }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output: 6
  * ```
  *
@@ -7462,9 +7612,9 @@ const iterate = exports.iterate = effect.iterate;
  * computations repeatedly, such as processing items in a list, generating
  * values, or performing iterative updates.
  *
- * @example
+ * **Example** (Looping with Collected Results)
+ *
  * ```ts
- * // Title: Looping with Collected Results
  * import { Effect } from "effect"
  *
  * // A loop that runs 5 times, collecting each iteration's result
@@ -7481,12 +7631,13 @@ const iterate = exports.iterate = effect.iterate;
  *   }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output: [1, 2, 3, 4, 5]
  * ```
  *
- * @example
- * // Title: Loop with Discarded Results
+ * **Example** (Loop with Discarded Results)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const result = Effect.loop(
@@ -7504,7 +7655,7 @@ const iterate = exports.iterate = effect.iterate;
  *   }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output:
  * // Currently at state 1
  * // Currently at state 2
@@ -7512,6 +7663,7 @@ const iterate = exports.iterate = effect.iterate;
  * // Currently at state 4
  * // Currently at state 5
  * // undefined
+ * ```
  *
  * @since 2.0.0
  * @category Looping
@@ -7539,20 +7691,21 @@ const loop = exports.loop = effect.loop;
  * delays, limiting recursions, or dynamically adjusting based on the outcome of
  * each execution.
  *
- * @example
+ * **Example** (Success Example)
+ *
  * ```ts
- * // Success Example
  * import { Effect, Schedule, Console } from "effect"
  *
  * const action = Console.log("success")
  * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
  * const program = Effect.repeat(action, policy)
  *
- * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
  * ```
  *
- * @example
- * // Failure Example
+ * **Example** (Failure Example)
+ *
+ * ```ts
  * import { Effect, Schedule } from "effect"
  *
  * let count = 0
@@ -7572,7 +7725,8 @@ const loop = exports.loop = effect.loop;
  * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
  * const program = Effect.repeat(action, policy)
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
+ * ```
  *
  * @since 2.0.0
  * @category Repetition / Recursion
@@ -7596,14 +7750,15 @@ const repeat = exports.repeat = schedule_.repeat_combined;
  * This function is useful for tasks that need to be retried a fixed number of
  * times or for performing repeated actions without requiring a schedule.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
  * const action = Console.log("success")
  * const program = Effect.repeatN(action, 2)
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * ```
  *
  * @since 2.0.0
@@ -7627,7 +7782,8 @@ const repeatN = exports.repeatN = effect.repeatN;
  * failure occurs during any iteration, the failure handler is invoked to handle
  * the situation.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Schedule } from "effect"
  *
@@ -7657,7 +7813,7 @@ const repeatN = exports.repeatN = effect.repeatN;
  *   })
  * )
  *
- * // Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
  * ```
  *
  * @since 2.0.0
@@ -7806,18 +7962,19 @@ const updateFiberRefs = exports.updateFiberRefs = effect.updateFiberRefs;
  * The resulting effect cannot fail (`never` in the error channel) but retains
  * the context of the original effect.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
  * const failure = Effect.fail("Uh oh!")
  *
- * // console.log(Effect.runSync(Effect.isFailure(failure)))
+ * console.log(Effect.runSync(Effect.isFailure(failure)))
  * // Output: true
  *
  * const defect = Effect.dieMessage("BOOM!")
  *
- * // Effect.runSync(Effect.isFailure(defect))
+ * Effect.runSync(Effect.isFailure(defect))
  * // throws: BOOM!
  * ```
  *
@@ -7857,11 +8014,9 @@ const isSuccess = exports.isSuccess = effect.isSuccess;
  * This is useful for structuring your code to respond differently to success or
  * failure without triggering side effects.
  *
- * @see {@link matchEffect} if you need to perform side effects in the handlers.
+ * **Example** (Handling Both Success and Failure Cases)
  *
- * @example
  * ```ts
- * // Title: Handling Both Success and Failure Cases
  * import { Effect } from "effect"
  *
  * const success: Effect.Effect<number, Error> = Effect.succeed(42)
@@ -7872,7 +8027,7 @@ const isSuccess = exports.isSuccess = effect.isSuccess;
  * })
  *
  * // Run and log the result of the successful effect
- * // Effect.runPromise(program1).then(console.log)
+ * Effect.runPromise(program1).then(console.log)
  * // Output: "success: 42"
  *
  * const failure: Effect.Effect<number, Error> = Effect.fail(
@@ -7885,10 +8040,12 @@ const isSuccess = exports.isSuccess = effect.isSuccess;
  * })
  *
  * // Run and log the result of the failed effect
- * // Effect.runPromise(program2).then(console.log)
+ * Effect.runPromise(program2).then(console.log)
  * // Output: "failure: Uh oh!"
  * ```
  *
+ * @see {@link matchEffect} if you need to perform side effects in the handlers.
+ *
  * @since 2.0.0
  * @category Matching
  */
@@ -7907,13 +8064,9 @@ const match = exports.match = effect.match;
  * regular failures, defects, or interruptions. You can provide specific
  * handling logic for each failure type based on the cause.
  *
- * @see {@link matchCauseEffect} if you need to perform side effects in the
- * handlers.
- * @see {@link match} if you don't need to handle the cause of the failure.
+ * **Example** (Handling Different Failure Causes)
  *
- * @example
  * ```ts
- * // Title: Handling Different Failure Causes
  * import { Effect } from "effect"
  *
  * const task: Effect.Effect<number, Error> = Effect.die("Uh oh!")
@@ -7939,11 +8092,14 @@ const match = exports.match = effect.match;
  *     `succeeded with ${value} value`
  * })
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output: "Die: Uh oh!"
- *
  * ```
  *
+ * @see {@link matchCauseEffect} if you need to perform side effects in the
+ * handlers.
+ * @see {@link match} if you don't need to handle the cause of the failure.
+ *
  * @since 2.0.0
  * @category Matching
  */
@@ -7960,12 +8116,9 @@ const matchCause = exports.matchCause = core.matchCause;
  * you to respond accordingly while performing side effects (like logging or
  * other operations).
  *
- * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure.
- * @see {@link matchEffect} if you don't need to handle the cause of the failure.
+ * **Example** (Handling Different Failure Causes with Side Effects)
  *
- * @example
  * ```ts
- * // Title: Handling Different Failure Causes with Side Effects
  * import { Effect, Console } from "effect"
  *
  * const task: Effect.Effect<number, Error> = Effect.die("Uh oh!")
@@ -7991,10 +8144,13 @@ const matchCause = exports.matchCause = core.matchCause;
  *     Console.log(`succeeded with ${value} value`)
  * })
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output: "Die: Uh oh!"
  * ```
  *
+ * @see {@link matchCause} if you don't need side effects and only want to handle the result or failure.
+ * @see {@link matchEffect} if you don't need to handle the cause of the failure.
+ *
  * @since 2.0.0
  * @category Matching
  */
@@ -8013,12 +8169,9 @@ const matchCauseEffect = exports.matchCauseEffect = core.matchCauseEffect;
  * This is useful when you need to execute additional actions, like logging or
  * notifying users, based on whether an effect succeeds or fails.
  *
- * @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
  * ```ts
- * // Title: Handling Both Success and Failure Cases with Side Effects
  * import { Effect } from "effect"
  *
  * const success: Effect.Effect<number, Error> = Effect.succeed(42)
@@ -8055,6 +8208,9 @@ const matchCauseEffect = exports.matchCauseEffect = core.matchCauseEffect;
  * // failure: Uh oh!
  * ```
  *
+ * @see {@link match} if you don't need side effects and only want to handle the
+ * result or failure.
+ *
  * @since 2.0.0
  * @category Matching
  */
@@ -8075,7 +8231,8 @@ const matchEffect = exports.matchEffect = core.matchEffect;
  * level, and fiber ID, making it suitable for debugging and tracking purposes.
  * This function does not interrupt or alter the effect's execution flow.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Cause, Effect } from "effect"
  *
@@ -8086,7 +8243,7 @@ const matchEffect = exports.matchEffect = core.matchEffect;
  *   Cause.die("Oh uh!")
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message=message1 message=message2 cause="Error: Oh no!
  * // Error: Oh uh!"
@@ -8106,7 +8263,8 @@ const log = exports.log = effect.log;
  * flexibility in categorizing logs based on their importance or severity,
  * making it easier to filter logs during debugging or production monitoring.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Cause, Effect, LogLevel } from "effect"
  *
@@ -8116,7 +8274,7 @@ const log = exports.log = effect.log;
  *   Cause.die("System failure!")
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // timestamp=... level=ERROR fiber=#0 message=Critical error encountered cause="Error: System failure!"
  * ```
@@ -8136,13 +8294,14 @@ const logWithLevel = (level, ...message) => effect.logWithLevel(level)(...messag
  * configuration by setting the minimum log level to `LogLevel.Trace` using
  * `Logger.withMinimumLogLevel`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Logger, LogLevel } from "effect"
  *
  * const program = Effect.logTrace("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Trace))
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=TRACE fiber=#0 message=message1
  * ```
  *
@@ -8161,13 +8320,14 @@ const logTrace = exports.logTrace = effect.logTrace;
  * less detailed information than TRACE logs but are still not shown by default.
  * To view these logs, adjust the log level using `Logger.withMinimumLogLevel`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Logger, LogLevel } from "effect"
  *
  * const program = Effect.logDebug("message1").pipe(Logger.withMinimumLogLevel(LogLevel.Debug))
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=DEBUG fiber=#0 message=message1
  * ```
  *
@@ -8244,7 +8404,8 @@ const logFatal = exports.logFatal = effect.logFatal;
  * operation. The span information is included in the log metadata, making it
  * easy to trace performance metrics in logs.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8253,7 +8414,7 @@ const logFatal = exports.logFatal = effect.logFatal;
  *   yield* Effect.log("The job is finished!")
  * }).pipe(Effect.withLogSpan("myspan"))
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=INFO fiber=#0 message="The job is finished!" myspan=1011ms
  * ```
  *
@@ -8279,9 +8440,8 @@ const withLogSpan = exports.withLogSpan = effect.withLogSpan;
  * The annotated key-value pairs will appear alongside the log message in the
  * output.
  *
- * @see {@link annotateLogsScoped} to add log annotations with a limited scope.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8290,11 +8450,13 @@ const withLogSpan = exports.withLogSpan = effect.withLogSpan;
  *   yield* Effect.log("message2")
  * }).pipe(Effect.annotateLogs("taskId", "1234")) // Annotation as key/value pair
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=INFO fiber=#0 message=message1 taskId=1234
  * // timestamp=... level=INFO fiber=#0 message=message2 taskId=1234
  * ```
  *
+ * @see {@link annotateLogsScoped} to add log annotations with a limited scope.
+ *
  * @since 2.0.0
  * @category Logging
  */
@@ -8315,9 +8477,8 @@ const annotateLogs = exports.annotateLogs = effect.annotateLogs;
  * multiple key-value pairs. This flexibility enables fine-grained control over
  * the additional metadata included in logs for specific tasks or operations.
  *
- * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8328,13 +8489,15 @@ const annotateLogs = exports.annotateLogs = effect.annotateLogs;
  *   yield* Effect.log("message2") // Annotation is applied to this log
  * }).pipe(Effect.scoped, Effect.andThen(Effect.log("no annotations again")))
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=INFO fiber=#0 message="no annotations"
  * // timestamp=... level=INFO fiber=#0 message=message1 key=value
  * // timestamp=... level=INFO fiber=#0 message=message2 key=value
  * // timestamp=... level=INFO fiber=#0 message="no annotations again"
  * ```
  *
+ * @see {@link annotateLogs} to add custom annotations to log entries generated within an effect.
+ *
  * @since 3.1.0
  * @category Logging
  */
@@ -8377,7 +8540,8 @@ const logAnnotations = exports.logAnnotations = effect.logAnnotations;
  * It is especially useful when you want to reduce noise in logs or prioritize
  * certain types of errors.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Fiber, LogLevel, Option } from "effect"
  *
@@ -8386,7 +8550,7 @@ const logAnnotations = exports.logAnnotations = effect.logAnnotations;
  *   yield* Fiber.join(fiber)
  * })
  *
- * // Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error))))
+ * Effect.runFork(program.pipe(Effect.withUnhandledErrorLogLevel(Option.some(LogLevel.Error))))
  * // Output:
  * // timestamp=... level=ERROR fiber=#1 message="Fiber terminated with an unhandled error" cause="Error: Unhandled error!"
  * ```
@@ -8408,7 +8572,8 @@ const withUnhandledErrorLogLevel = exports.withUnhandledErrorLogLevel = core.wit
  * This function is useful for conditionally executing logging-related effects
  * or other operations that depend on the current log level configuration.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Logger, LogLevel } from "effect"
  *
@@ -8417,7 +8582,7 @@ const withUnhandledErrorLogLevel = exports.withUnhandledErrorLogLevel = core.wit
  *   yield* Effect.whenLogLevel(Effect.logDebug("message2"), LogLevel.Debug); // returns `Some`
  * }).pipe(Logger.withMinimumLogLevel(LogLevel.Debug));
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // timestamp=... level=DEBUG fiber=#0 message=message2
  * ```
  *
@@ -8444,11 +8609,9 @@ const whenLogLevel = exports.whenLogLevel = fiberRuntime.whenLogLevel;
  * Use `orDie` when failures should be treated as unrecoverable defects and no
  * error handling is required.
  *
- * @see {@link orDieWith} if you need to customize the error.
+ * **Example** (Propagating an Error as a Defect)
  *
- * @example
  * ```ts
- * // Title: Propagating an Error as a Defect
  * import { Effect } from "effect"
  *
  * const divide = (a: number, b: number) =>
@@ -8460,12 +8623,14 @@ const whenLogLevel = exports.whenLogLevel = fiberRuntime.whenLogLevel;
  * //      ▼
  * const program = Effect.orDie(divide(1, 0))
  *
- * // Effect.runPromise(program).catch(console.error)
+ * Effect.runPromise(program).catch(console.error)
  * // Output:
  * // (FiberFailure) Error: Cannot divide by zero
  * //   ...stack trace...
  * ```
  *
+ * @see {@link orDieWith} if you need to customize the error.
+ *
  * @since 2.0.0
  * @category Converting Failures to Defects
  */
@@ -8485,11 +8650,9 @@ const orDie = exports.orDie = core.orDie;
  * Use `orDieWith` when failures should terminate the fiber as defects, and you want to customize
  * the error for clarity or debugging purposes.
  *
- * @see {@link orDie} if you don't need to customize the error.
+ * **Example** (Customizing Defect)
  *
- * @example
  * ```ts
- * // Title: Customizing Defect
  * import { Effect } from "effect"
  *
  * const divide = (a: number, b: number) =>
@@ -8504,12 +8667,14 @@ const orDie = exports.orDie = core.orDie;
  *   (error) => new Error(`defect: ${error.message}`)
  * )
  *
- * // Effect.runPromise(program).catch(console.error)
+ * Effect.runPromise(program).catch(console.error)
  * // Output:
  * // (FiberFailure) Error: defect: Cannot divide by zero
  * //   ...stack trace...
  * ```
  *
+ * @see {@link orDie} if you don't need to customize the error.
+ *
  * @since 2.0.0
  * @category Converting Failures to Defects
  */
@@ -8528,9 +8693,8 @@ const orDieWith = exports.orDieWith = core.orDieWith;
  * The error type of the resulting effect will be that of the fallback effect,
  * as the first effect's error is replaced when the fallback is executed.
  *
- * @see {@link catchAll} if you need to access the error in the fallback effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8549,6 +8713,8 @@ const orDieWith = exports.orDieWith = core.orDieWith;
  * // Output: "fallback"
  * ```
  *
+ * @see {@link catchAll} if you need to access the error in the fallback effect.
+ *
  * @since 2.0.0
  * @category Fallback
  */
@@ -8571,9 +8737,8 @@ const orElse = exports.orElse = core.orElse;
  * error management by ensuring that all failures are replaced with a controlled
  * alternative.
  *
- * @see {@link mapError} if you need to access the error to transform it.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8598,6 +8763,8 @@ const orElse = exports.orElse = core.orElse;
  * // }
  * ```
  *
+ * @see {@link mapError} if you need to access the error to transform it.
+ *
  * @since 2.0.0
  * @category Fallback
  */
@@ -8621,7 +8788,8 @@ const orElseFail = exports.orElseFail = effect.orElseFail;
  * function, you can avoid the need for complex error handling and guarantee a
  * fallback result.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8671,7 +8839,8 @@ const orElseSucceed = exports.orElseSucceed = effect.orElseSucceed;
  * alternative sources to obtain a result, such as attempting multiple APIs,
  * retrieving configurations, or accessing resources in a prioritized manner.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -8881,7 +9050,8 @@ const unsafeMakeSemaphore = exports.unsafeMakeSemaphore = circular.unsafeMakeSem
  * shared resource. The number of permits determines how many tasks can access
  * the resource concurrently.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -8906,7 +9076,8 @@ const unsafeMakeLatch = exports.unsafeMakeLatch = circular.unsafeMakeLatch;
  * This function initializes a `Latch` safely, ensuring proper runtime
  * guarantees. By default, the latch starts in the closed state.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -8927,7 +9098,7 @@ const unsafeMakeLatch = exports.unsafeMakeLatch = circular.unsafeMakeLatch;
  *   yield* fiber.await
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: open sesame (after 1 second)
  * ```
  *
@@ -8965,9 +9136,9 @@ const makeLatch = exports.makeLatch = circular.makeLatch;
  * This function is ideal if you don't need the result immediately or if the
  * effect is part of a larger concurrent workflow.
  *
- * @example
+ * **Example** (Running an Effect in the Background)
+ *
  * ```ts
- * // Title: Running an Effect in the Background
  * import { Effect, Console, Schedule, Fiber } from "effect"
  *
  * //      ┌─── Effect<number, never, never>
@@ -9028,25 +9199,27 @@ const runCallback = exports.runCallback = runtime_.unsafeRunEffect;
  * in a promise-based system, such as when integrating with third-party
  * libraries that expect `Promise` results.
  *
- * @see {@link runPromiseExit} for a version that returns an `Exit` type instead
- * of rejecting.
+ * **Example** (Running a Successful Effect as a Promise)
  *
- * @example
  * ```ts
- * // Title: Running a Successful Effect as a Promise
  * import { Effect } from "effect"
  *
- * // Effect.runPromise(Effect.succeed(1)).then(console.log)
+ * Effect.runPromise(Effect.succeed(1)).then(console.log)
  * // Output: 1
  * ```
  *
- * @example
- * //Example: Handling a Failing Effect as a Rejected Promise
+ * **Example** (Handling a Failing Effect as a Rejected Promise)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
- * // Effect.runPromise(Effect.fail("my error")).catch(console.error)
+ * Effect.runPromise(Effect.fail("my error")).catch(console.error)
  * // Output:
  * // (FiberFailure) Error: my error
+ * ```
+ *
+ * @see {@link runPromiseExit} for a version that returns an `Exit` type instead
+ * of rejecting.
  *
  * @since 2.0.0
  * @category Running Effects
@@ -9077,13 +9250,13 @@ const runPromise = exports.runPromise = runtime_.unsafeRunPromiseEffect;
  * that rely on promises but need more detailed error handling than a simple
  * rejection.
  *
- * @example
+ * **Example** (Handling Results as Exit)
+ *
  * ```ts
- * // Title: Handling Results as Exit
  * import { Effect } from "effect"
  *
  * // Execute a successful effect and get the Exit result as a Promise
- * // Effect.runPromiseExit(Effect.succeed(1)).then(console.log)
+ * Effect.runPromiseExit(Effect.succeed(1)).then(console.log)
  * // Output:
  * // {
  * //   _id: "Exit",
@@ -9092,7 +9265,7 @@ const runPromise = exports.runPromise = runtime_.unsafeRunPromiseEffect;
  * // }
  *
  * // Execute a failing effect and get the Exit result as a Promise
- * // Effect.runPromiseExit(Effect.fail("my error")).then(console.log)
+ * Effect.runPromiseExit(Effect.fail("my error")).then(console.log)
  * // Output:
  * // {
  * //   _id: "Exit",
@@ -9139,12 +9312,9 @@ const runPromiseExit = exports.runPromiseExit = runtime_.unsafeRunPromiseExitEff
  * handling. For such cases, consider using {@link runPromise} or
  * {@link runSyncExit}.
  *
- * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
- * throwing an error.
+ * **Example** (Synchronous Logging)
  *
- * @example
  * ```ts
- * // Title: Synchronous Logging
  * import { Effect } from "effect"
  *
  * const program = Effect.sync(() => {
@@ -9159,8 +9329,9 @@ const runPromiseExit = exports.runPromiseExit = runtime_.unsafeRunPromiseExitEff
  * // Output: 1
  * ```
  *
- * @example
- * // Title: Incorrect Usage with Failing or Async Effects
+ * **Example** (Incorrect Usage with Failing or Async Effects)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * try {
@@ -9180,6 +9351,10 @@ const runPromiseExit = exports.runPromiseExit = runtime_.unsafeRunPromiseExitEff
  * }
  * // Output:
  * // (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work
+ * ```
+ *
+ * @see {@link runSyncExit} for a version that returns an `Exit` type instead of
+ * throwing an error.
  *
  * @since 2.0.0
  * @category Running Effects
@@ -9210,9 +9385,9 @@ const runSync = exports.runSync = runtime_.unsafeRunSyncEffect;
  *
  * Avoid using this function for effects that involve asynchronous operations, as it will fail with a `Die` cause.
  *
- * @example
+ * **Example** (Handling Results as Exit)
+ *
  * ```ts
- * // Title: Handling Results as Exit
  * import { Effect } from "effect"
  *
  * console.log(Effect.runSyncExit(Effect.succeed(1)))
@@ -9236,8 +9411,9 @@ const runSync = exports.runSync = runtime_.unsafeRunSyncEffect;
  * // }
  * ```
  *
- * @example
- * // Title: Asynchronous Operation Resulting in Die
+ * **Example** (Asynchronous Operation Resulting in Die)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * console.log(Effect.runSyncExit(Effect.promise(() => Promise.resolve(1))))
@@ -9255,6 +9431,7 @@ const runSync = exports.runSync = runtime_.unsafeRunSyncEffect;
  * //     }
  * //   }
  * // }
+ * ```
  *
  * @since 2.0.0
  * @category Running Effects
@@ -9275,9 +9452,8 @@ const runSyncExit = exports.runSyncExit = runtime_.unsafeRunSyncExitEffect;
  * provides flexibility in scenarios where you want to maximize performance or
  * ensure specific ordering.
  *
- * @see {@link zip} for a version that stops at the first error.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -9292,7 +9468,7 @@ const runSyncExit = exports.runSyncExit = runtime_.unsafeRunSyncExitEffect;
  *   Effect.validate(task4)
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task1
  * // task2
@@ -9308,6 +9484,8 @@ const runSyncExit = exports.runSyncExit = runtime_.unsafeRunSyncExitEffect;
  * // }
  * ```
  *
+ * @see {@link zip} for a version that stops at the first error.
+ *
  * @since 2.0.0
  * @category Error Accumulation
  */
@@ -9347,13 +9525,9 @@ const validateWith = exports.validateWith = fiberRuntime.validateWith;
  * is set to `true`, the effects will run concurrently, potentially improving
  * performance for independent operations.
  *
- * @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
  * ```ts
- * // Title: Combining Two Effects Sequentially
  * import { Effect } from "effect"
  *
  * const task1 = Effect.succeed(1).pipe(
@@ -9371,15 +9545,16 @@ const validateWith = exports.validateWith = fiberRuntime.validateWith;
  * //      ▼
  * const program = Effect.zip(task1, task2)
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message="task1 done"
  * // timestamp=... level=INFO fiber=#0 message="task2 done"
  * // [ 1, 'hello' ]
  * ```
  *
- * @example
- * // Title: Combining Two Effects Concurrently
+ * **Example** (Combining Two Effects Concurrently)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * const task1 = Effect.succeed(1).pipe(
@@ -9394,11 +9569,16 @@ const validateWith = exports.validateWith = fiberRuntime.validateWith;
  * // Run both effects concurrently using the concurrent option
  * const program = Effect.zip(task1, task2, { concurrent: true })
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message="task2 done"
  * // timestamp=... level=INFO fiber=#0 message="task1 done"
  * // [ 1, 'hello' ]
+ * ```
+ *
+ * @see {@link zipWith} for a version that combines the results with a custom
+ * function.
+ * @see {@link validate} for a version that accumulates errors.
  *
  * @since 2.0.0
  * @category Zipping
@@ -9425,10 +9605,8 @@ const zip = exports.zip = fiberRuntime.zipOptions;
  * effect but still need to run the second effect for its side effects, such as
  * logging or performing a cleanup action.
  *
- * @see {@link zipRight} for a version that returns the result of the second
- * effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9443,13 +9621,16 @@ const zip = exports.zip = fiberRuntime.zipOptions;
  *
  * const program = Effect.zipLeft(task1, task2)
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message="task1 done"
  * // timestamp=... level=INFO fiber=#0 message="task2 done"
  * // 1
  * ```
  *
+ * @see {@link zipRight} for a version that returns the result of the second
+ * effect.
+ *
  * @since 2.0.0
  * @category Zipping
  */
@@ -9475,10 +9656,8 @@ const zipLeft = exports.zipLeft = fiberRuntime.zipLeftOptions;
  * effect but still need to run the first effect for its side effects, such as
  * initialization or setup tasks.
  *
- * @see {@link zipLeft} for a version that returns the result of the first
- * effect.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9493,13 +9672,16 @@ const zipLeft = exports.zipLeft = fiberRuntime.zipLeftOptions;
  *
  * const program = Effect.zipRight(task1, task2)
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#0 message="task1 done"
  * // timestamp=... level=INFO fiber=#0 message="task2 done"
  * // hello
  * ```
  *
+ * @see {@link zipLeft} for a version that returns the result of the first
+ * effect.
+ *
  * @since 2.0.0
  * @category Zipping
  */
@@ -9516,9 +9698,9 @@ const zipRight = exports.zipRight = fiberRuntime.zipRightOptions;
  * this function processes the results with a custom function to produce a
  * single output.
  *
- * @example
+ * **Example** (Combining Effects with a Custom Function)
+ *
  * ```ts
- * // Title: Combining Effects with a Custom Function
  * import { Effect } from "effect"
  *
  * const task1 = Effect.succeed(1).pipe(
@@ -9537,7 +9719,7 @@ const zipRight = exports.zipRight = fiberRuntime.zipRightOptions;
  *   (number, string) => number + string.length
  * )
  *
- * // Effect.runPromise(task3).then(console.log)
+ * Effect.runPromise(task3).then(console.log)
  * // Output:
  * // timestamp=... level=INFO fiber=#3 message="task1 done"
  * // timestamp=... level=INFO fiber=#2 message="task2 done"
@@ -9625,9 +9807,8 @@ const withTracerScoped = exports.withTracerScoped = fiberRuntime.withTracerScope
 /**
  * Disable the tracer for the given Effect.
  *
- * @since 2.0.0
- * @category Tracing
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9637,6 +9818,9 @@ const withTracerScoped = exports.withTracerScoped = fiberRuntime.withTracerScope
  *   Effect.withTracerEnabled(false)
  * )
  * ```
+ *
+ * @since 2.0.0
+ * @category Tracing
  */
 const withTracerEnabled = exports.withTracerEnabled = core.withTracerEnabled;
 /**
@@ -9747,9 +9931,8 @@ const withSpan = exports.withSpan = effect.withSpan;
 /**
  * Wraps a function that returns an effect with a new span for tracing.
  *
- * @since 3.2.0
- * @category Tracing
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9761,6 +9944,9 @@ const withSpan = exports.withSpan = effect.withSpan;
  *   })
  * })
  * ```
+ *
+ * @since 3.2.0
+ * @category Tracing
  */
 const functionWithSpan = exports.functionWithSpan = effect.functionWithSpan;
 /**
@@ -9802,7 +9988,8 @@ const withParentSpan = exports.withParentSpan = effect.withParentSpan;
  * and you want to ensure that only non-null values are processed. It helps
  * enforce null-safety and makes error handling more explicit.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9810,7 +9997,7 @@ const withParentSpan = exports.withParentSpan = effect.withParentSpan;
  * //      ▼
  * const maybe1 = Effect.fromNullable(1)
  *
- * // Effect.runPromiseExit(maybe1).then(console.log)
+ * Effect.runPromiseExit(maybe1).then(console.log)
  * // Output:
  * // { _id: 'Exit', _tag: 'Success', value: 1 }
  *
@@ -9818,7 +10005,7 @@ const withParentSpan = exports.withParentSpan = effect.withParentSpan;
  * //      ▼
  * const maybe2 = Effect.fromNullable(null as number | null)
  *
- * // Effect.runPromiseExit(maybe2).then(console.log)
+ * Effect.runPromiseExit(maybe2).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -9858,7 +10045,8 @@ const fromNullable = exports.fromNullable = effect.fromNullable;
  * It’s ideal for scenarios where you want to explicitly represent optionality
  * in a type-safe way while retaining other failure information.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9870,7 +10058,7 @@ const fromNullable = exports.fromNullable = effect.fromNullable;
  * //      ▼
  * const option1 = Effect.optionFromOptional(maybe1)
  *
- * // Effect.runPromise(option1).then(console.log)
+ * Effect.runPromise(option1).then(console.log)
  * // Output: { _id: 'Option', _tag: 'Some', value: 1 }
  *
  * //      ┌─── Effect<number, NoSuchElementException, never>
@@ -9881,7 +10069,7 @@ const fromNullable = exports.fromNullable = effect.fromNullable;
  * //      ▼
  * const option2 = Effect.optionFromOptional(maybe2)
  *
- * // Effect.runPromise(option2).then(console.log)
+ * Effect.runPromise(option2).then(console.log)
  * // Output: { _tag: 'None' }
  * ```
  *
@@ -9899,7 +10087,8 @@ const optionFromOptional = exports.optionFromOptional = effect.optionFromOptiona
  * will immediately succeed with a `None` value. If the `Option` is `Some`, the
  * inner `Effect` will be executed, and its result wrapped in a `Some`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Option } from "effect"
  *
@@ -9964,7 +10153,8 @@ const makeTagProxy = TagClass => {
  * method) are turned into static properties of the Notifications class, making
  * it easier to access them.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -10017,7 +10207,8 @@ const Tag = id => () => {
  * provided automatically when the service is used. Accessors can be optionally
  * generated for the service, making it more convenient to use.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from 'effect';
  *