effect 3.13.9 → 3.13.11

package/dist/esm/Effect.js

@@ -62,12 +62,8 @@ export const 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"
  *
@@ -89,7 +85,7 @@ export const isEffect = core.isEffect;
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // expensive task...
  * // result 1
@@ -98,6 +94,11 @@ export const 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
  */
@@ -129,12 +130,8 @@ export const 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"
  *
@@ -159,7 +156,7 @@ export const cachedWithTTL = circular.cached;
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // expensive task...
  * // result 1
@@ -168,6 +165,11 @@ export const 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
  */
@@ -190,12 +192,8 @@ export const cachedInvalidateWithTTL = circular.cachedInvalidateWithTTL;
  * 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"
  *
@@ -219,7 +217,7 @@ export const cachedInvalidateWithTTL = circular.cachedInvalidateWithTTL;
  *   yield* cached.pipe(Effect.andThen(Console.log))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // non-cached version:
  * // expensive task...
@@ -232,6 +230,11 @@ export const cachedInvalidateWithTTL = circular.cachedInvalidateWithTTL;
  * // 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
  */
@@ -262,7 +265,8 @@ export const 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"
  *
@@ -278,7 +282,7 @@ export const cached = effect.memoize;
  *   console.log(yield* memoized(10))
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // non-memoized version:
  * // 2
@@ -310,7 +314,8 @@ export const 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"
  *
@@ -321,7 +326,7 @@ export const cachedFunction = circular.cachedFunction;
  *   yield* Effect.repeatN(task2, 2)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1
  * // task1
@@ -380,12 +385,9 @@ export const 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 = [
@@ -397,15 +399,16 @@ export const 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(
@@ -416,15 +419,17 @@ export const 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** (Combining Effects in Structs)
  *
- * @example
- * // Title: Combining Effects in Structs
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const structOfEffects = {
@@ -436,14 +441,16 @@ export const 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>> = {
@@ -455,14 +462,16 @@ export const 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([
@@ -472,7 +481,7 @@ export const 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
  * // {
@@ -480,9 +489,11 @@ export const once = effect.once;
  * //   _tag: 'Failure',
  * //   cause: { _id: 'Cause', _tag: 'Fail', failure: 'Task2: Oh no!' }
  * // }
+ * ```
  *
- * @example
- * // Title: Collecting Results with `mode: "either"`
+ * **Example** (Collecting Results with `mode: "either"`)
+ *
+ * ```ts
  * import { Effect, Console } from "effect"
  *
  * const effects = [
@@ -493,7 +504,7 @@ export const 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
@@ -506,9 +517,11 @@ export const 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 = [
@@ -519,7 +532,7 @@ export const 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
@@ -536,6 +549,10 @@ export const 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
@@ -550,7 +567,8 @@ export const 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"
  *
@@ -570,7 +588,7 @@ export const 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"
@@ -598,7 +616,8 @@ export const allWith = fiberRuntime.allWith;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -614,7 +633,7 @@ export const allWith = fiberRuntime.allWith;
  *   console.log(successfulResults)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [1, 2]
  *
  * ```
@@ -646,10 +665,8 @@ export const 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"
  *
@@ -661,10 +678,13 @@ export const 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
  */
@@ -691,10 +711,8 @@ export const 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"
  *
@@ -706,10 +724,13 @@ export const 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
  */
@@ -740,10 +761,8 @@ export const 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"
  *
@@ -755,10 +774,13 @@ export const 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
  */
@@ -779,9 +801,8 @@ export const 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"
  *
@@ -793,10 +814,12 @@ export const 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
  */
@@ -822,10 +845,8 @@ export const 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"
  *
@@ -837,10 +858,13 @@ export const 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
  */
@@ -867,10 +891,8 @@ export const 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"
  *
@@ -882,10 +904,13 @@ export const 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
  */
@@ -914,7 +939,8 @@ export const 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"
  *
@@ -926,7 +952,7 @@ export const exists = fiberRuntime.exists;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: [2, 4]
  * ```
  *
@@ -942,7 +968,8 @@ export const 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"
  *
@@ -957,7 +984,7 @@ export const 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
@@ -992,7 +1019,8 @@ export const filterMap = effect.filterMap;
  * condition, even when the evaluation involves effects like asynchronous
  * operations or side effects.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1004,7 +1032,7 @@ export const filterMap = effect.filterMap;
  *   console.log(result)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: { _id: 'Option', _tag: 'Some', value: 4 }
  * ```
  *
@@ -1033,18 +1061,16 @@ export const 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
@@ -1054,8 +1080,9 @@ export const 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
@@ -1066,7 +1093,7 @@ export const 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
@@ -1074,6 +1101,9 @@ export const 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
@@ -1089,7 +1119,8 @@ export const 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"
  *
@@ -1101,7 +1132,7 @@ export const forEach = fiberRuntime.forEach;
  *   console.log(firstElement)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: 1
  * ```
  *
@@ -1129,7 +1160,8 @@ export const head = effect.head;
  * These options provide flexibility in running the effects concurrently or
  * adjusting other execution details.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -1142,7 +1174,7 @@ export const head = effect.head;
  *   console.log(total)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: 6
  * ```
  *
@@ -1174,10 +1206,8 @@ export const 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"
  *
@@ -1191,11 +1221,14 @@ export const 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
  */
@@ -1219,10 +1252,8 @@ export const 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"
  *
@@ -1238,7 +1269,7 @@ export const 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
@@ -1247,6 +1278,9 @@ export const 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
  */
@@ -1271,7 +1305,8 @@ export const 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"
  *
@@ -1290,7 +1325,7 @@ export const reduce = effect.reduce;
  *   }
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Order 1 processed
  * // Order 2 processed
@@ -1321,9 +1356,8 @@ export const 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"
  *
@@ -1339,7 +1373,7 @@ export const 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
@@ -1348,6 +1382,8 @@ export const reduceWhile = effect.reduceWhile;
  * // 1000
  * ```
  *
+ * @see {@link reduce} for a similar function that works from left to right.
+ *
  * @since 2.0.0
  * @category Collecting
  */
@@ -1368,7 +1404,8 @@ export const 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"
  *
@@ -1382,7 +1419,7 @@ export const 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
@@ -1404,7 +1441,8 @@ export const 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"
  *
@@ -1421,7 +1459,7 @@ export const reduceEffect = fiberRuntime.reduceEffect;
  *   }
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Hello, World!
  * // Hello, World!
@@ -1451,7 +1489,8 @@ export const 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"
  *
@@ -1467,7 +1506,7 @@ export const replicate = fiberRuntime.replicate;
  *   yield* Console.log(`Results: ${results.join(", ")}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Task completed
  * // Task completed
@@ -1501,11 +1540,8 @@ export const 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"
  *
@@ -1519,7 +1555,7 @@ export const replicateEffect = fiberRuntime.replicateEffect;
  *   }
  * })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // item 1
  * // item 2
@@ -1535,6 +1571,10 @@ export const 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
  */
@@ -1553,11 +1593,8 @@ export const 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"
  *
@@ -1571,12 +1608,16 @@ export const 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
  */
@@ -1605,9 +1646,9 @@ export const 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"
  *
@@ -1629,8 +1670,9 @@ export const 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"
  *
@@ -1665,12 +1707,14 @@ export const 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
@@ -1696,9 +1740,10 @@ export const validateFirst = fiberRuntime.validateFirst;
  * })
  *
  * // Run the program
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Abort signal received
+ * ```
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -1717,7 +1762,8 @@ export const 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"
  *
@@ -1745,11 +1791,9 @@ export const 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>
@@ -1759,6 +1803,8 @@ export const withFiberRuntime = core.withFiberRuntime;
  * )
  * ```
  *
+ * @see {@link succeed} to create an effect that represents a successful value.
+ *
  * @since 2.0.0
  * @category Creating Effects
  */
@@ -1802,14 +1848,9 @@ export const 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) =>
@@ -1821,12 +1862,17 @@ export const 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
  */
@@ -1849,13 +1895,9 @@ export const 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) =>
@@ -1867,12 +1909,16 @@ export const 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
  */
@@ -1906,7 +1952,8 @@ export const 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"
  *
@@ -1998,11 +2045,9 @@ export const 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) =>
@@ -2020,6 +2065,8 @@ export const 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
  */
@@ -2032,11 +2079,9 @@ export const 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
@@ -2046,6 +2091,8 @@ export const 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
  */
@@ -2101,9 +2148,9 @@ export const 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
@@ -2119,8 +2166,9 @@ export const 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> =>
@@ -2128,7 +2176,7 @@ export const 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> =>
@@ -2142,9 +2190,11 @@ export const succeedSome = effect.succeedSome;
  *
  * console.log(Effect.runSync(allGood(32)))
  * // Output: 3524578
+ * ```
  *
- * @example
- * // Title: Using Effect.suspend to Help TypeScript Infer Types
+ * **Example** (Using Effect.suspend to Help TypeScript Infer Types)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * //   Without suspend, TypeScript may struggle with type inference.
@@ -2165,6 +2215,7 @@ export const succeedSome = effect.succeedSome;
  *       ? Effect.fail(new Error("Cannot divide by zero"))
  *       : Effect.succeed(a / b)
  *   )
+ * ```
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -2187,11 +2238,9 @@ export const 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) =>
@@ -2204,6 +2253,8 @@ export const 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
  */
@@ -2245,9 +2296,8 @@ export {
  * match the specified type, the function allows the original effect to
  * continue as it was.
  *
- * @see {@link catchTag} for a version that can recover from errors based on a `_tag` discriminator.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -2269,10 +2319,12 @@ export {
  *   console.log(`Result: ${result}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: Result: recovered from error: NetworkError
  * ```
  *
+ * @see {@link catchTag} for a version that can recover from errors based on a `_tag` discriminator.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2290,12 +2342,9 @@ _catch as 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 {
@@ -2329,6 +2378,9 @@ _catch as catch };
  * )
  * ```
  *
+ * @see {@link catchAllCause} for a version that can recover from both
+ * recoverable and unrecoverable errors.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2350,9 +2402,9 @@ export const 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
@@ -2367,7 +2419,7 @@ export const catchAll = core.catchAll;
  *   )
  * )
  *
- * // Effect.runPromise(recovered).then(console.log)
+ * Effect.runPromise(recovered).then(console.log)
  * // Output: "Recovered from a regular error"
  * ```
  *
@@ -2398,9 +2450,9 @@ export const 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
@@ -2416,7 +2468,7 @@ export const 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!
  * // {
@@ -2441,9 +2493,9 @@ export const 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 {
@@ -2495,11 +2547,9 @@ export const 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 {
@@ -2538,6 +2588,8 @@ export const 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
  */
@@ -2578,9 +2630,9 @@ export const 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
@@ -2599,7 +2651,7 @@ export const 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',
@@ -2630,12 +2682,9 @@ export const 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 {
@@ -2670,6 +2719,9 @@ export const 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
  */
@@ -2688,9 +2740,9 @@ export const 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 {
@@ -2748,7 +2800,8 @@ export const catchTags = effect.catchTags;
  * distinguishing between different types of defects (e.g., runtime exceptions,
  * interruptions, etc.).
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, Console } from "effect"
  *
@@ -2787,7 +2840,8 @@ export const 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"
  *
@@ -2806,7 +2860,7 @@ export const 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
@@ -2827,11 +2881,9 @@ export const 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>
@@ -2843,6 +2895,8 @@ export const eventually = effect.eventually;
  * const program = Effect.ignore(task)
  * ```
  *
+ * @see {@link ignoreLogged} to log failures while ignoring them.
+ *
  * @since 2.0.0
  * @category Error handling
  */
@@ -2884,7 +2938,8 @@ export const 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"
  *
@@ -2897,7 +2952,7 @@ export const 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',
@@ -2927,9 +2982,8 @@ export const 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"
  *
@@ -2961,12 +3015,14 @@ export const 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
  */
@@ -2992,12 +3048,9 @@ export const 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
@@ -3019,7 +3072,7 @@ export const sandbox = effect.sandbox;
  *
  * const repeated = Effect.retry(task, policy)
  *
- * // Effect.runPromise(repeated).then(console.log)
+ * Effect.runPromise(repeated).then(console.log)
  * // Output:
  * // failure
  * // failure
@@ -3028,9 +3081,9 @@ export const 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
@@ -3048,7 +3101,7 @@ export const 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
@@ -3056,9 +3109,9 @@ export const 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
@@ -3074,7 +3127,7 @@ export const 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)
@@ -3086,6 +3139,9 @@ export const 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
  */
@@ -3106,11 +3162,9 @@ export const 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
@@ -3138,7 +3192,7 @@ export const 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
@@ -3147,6 +3201,8 @@ export const 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
  */
@@ -3173,12 +3229,9 @@ export {
  * 2. If you provide a `catch` function, the error is caught and the `catch`
  *    function maps it to an error of type `E`.
  *
- * @see {@link sync} if the effectful computation is synchronous and does not
- * throw errors.
+ * **Example** (Safe JSON Parsing)
  *
- * @example
  * ```ts
- * // Title: Safe JSON Parsing
  * import { Effect } from "effect"
  *
  * const parse = (input: string) =>
@@ -3190,8 +3243,10 @@ export {
  * const program = parse("")
  *
  * ```
- * @example
- * // Title: Custom Error Handling
+ *
+ * **Example** (Custom Error Handling)
+ *
+ * ```ts
  * import { Effect } from "effect"
  *
  * const parse = (input: string) =>
@@ -3205,6 +3260,10 @@ export {
  * //      ┌─── Effect<any, Error, never>
  * //      ▼
  * const program = parse("")
+ * ```
+ *
+ * @see {@link sync} if the effectful computation is synchronous and does not
+ * throw errors.
  *
  * @since 2.0.0
  * @category Creating Effects
@@ -3261,11 +3320,9 @@ export const 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) =>
@@ -3279,8 +3336,9 @@ export const 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) =>
@@ -3293,6 +3351,9 @@ export const 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
@@ -3350,7 +3411,8 @@ export const allowInterrupt = effect.allowInterrupt;
  * operation can be interrupted, such as when performing asynchronous operations
  * or handling cancellation.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Console, Effect } from "effect"
  *
@@ -3364,10 +3426,10 @@ export const 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.
  *
  * ```
@@ -3399,10 +3461,8 @@ export const 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"
  *
@@ -3420,7 +3480,7 @@ export const checkInterruptible = core.checkInterruptible;
  *   Effect.timeout("1 second")
  * )
  *
- * // Effect.runPromiseExit(timedEffect).then(console.log)
+ * Effect.runPromiseExit(timedEffect).then(console.log)
  * // Output:
  * // Start heavy processing...
  * // {
@@ -3435,6 +3495,9 @@ export const 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
  */
@@ -3450,7 +3513,8 @@ export const 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"
  *
@@ -3462,7 +3526,7 @@ export const disconnect = fiberRuntime.disconnect;
  *   return "some result"
  * })
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // start
  * // {
@@ -3515,9 +3579,9 @@ export const 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
@@ -3525,19 +3589,19 @@ export const 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
@@ -3567,7 +3631,8 @@ export const uninterruptibleMask = core.uninterruptibleMask;
  * 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"
  *
@@ -3599,15 +3664,15 @@ export const 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"
  * ```
  *
@@ -3652,7 +3717,8 @@ export const 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"
  *
@@ -3699,13 +3765,9 @@ export const 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
@@ -3717,9 +3779,14 @@ export const 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
  */
@@ -3743,7 +3810,8 @@ export const 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"
  *
@@ -3756,10 +3824,10 @@ export const 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' ]
@@ -3779,10 +3847,8 @@ export const 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"
  *
@@ -3798,6 +3864,9 @@ export const 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
  */
@@ -3813,11 +3882,8 @@ export const 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"
  *
@@ -3833,6 +3899,10 @@ export const 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
  */
@@ -3862,7 +3932,8 @@ export const 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"
  *
@@ -3921,11 +3992,9 @@ export const 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
@@ -3965,6 +4034,8 @@ export const 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
  */
@@ -3984,23 +4055,21 @@ export const acquireRelease = fiberRuntime.acquireRelease;
  */
 export const 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 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.
+ * This function ensures that a resource is:
  *
- * 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.
+ * 1. **Acquired** properly.
+ * 2. **Used** for its intended purpose.
+ * 3. **Released** even if an error occurs.
+ *
+ * **Example** (Automatically Managing Resource Lifetime)
  *
- * @example
  * ```ts
- * // Title: Automatically Managing Resource Lifetime
  * import { Effect, Console } from "effect"
  *
  * // Define an interface for a resource
@@ -4039,7 +4108,7 @@ export const acquireReleaseInterruptible = fiberRuntime.acquireReleaseInterrupti
  * //      ▼
  * const program = Effect.acquireUseRelease(acquire, use, release)
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Resource acquired
  * // content is lorem ipsum
@@ -4069,11 +4138,9 @@ export const 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>
@@ -4091,15 +4158,15 @@ export const 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>
@@ -4117,7 +4184,7 @@ export const 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
  * // {
@@ -4127,9 +4194,9 @@ export const 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>
@@ -4147,7 +4214,7 @@ export const 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
  * // {
@@ -4166,6 +4233,8 @@ export const acquireUseRelease = core.acquireUseRelease;
  * // }
  * ```
  *
+ * @see {@link onExit} for attaching a finalizer directly to an effect.
+ *
  * @since 2.0.0
  * @category Scoping, Resources & Finalization
  */
@@ -4192,37 +4261,51 @@ export const 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
  */
@@ -4242,37 +4325,63 @@ export const 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!
+ *
+ * // 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.
  * ```
  *
+ * @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
  */
@@ -4294,30 +4403,45 @@ export const 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.
@@ -4347,9 +4471,8 @@ export const 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"
  *
@@ -4366,13 +4489,15 @@ export const 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
  */
@@ -4459,9 +4584,8 @@ export const 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"
  *
@@ -4473,13 +4597,15 @@ export const 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
  */
@@ -4494,7 +4620,8 @@ export const 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"
  *
@@ -4612,9 +4739,8 @@ export const 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"
  *
@@ -4628,6 +4754,8 @@ export const 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
  */
@@ -4644,9 +4772,9 @@ export const 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
@@ -4663,7 +4791,7 @@ export const fork = fiberRuntime.fork;
  *   console.log("parent: finished!")
  * })
  *
- * // Effect.runFork(parent)
+ * Effect.runFork(parent)
  * // Output:
  * // parent: started!
  * // daemon: still running!
@@ -4702,15 +4830,13 @@ export const 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
@@ -4744,7 +4870,7 @@ export const forkAll = circular.forkAll;
  *   })
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // child: still running!
  * // child: still running!
@@ -4780,14 +4906,12 @@ export const 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
@@ -4817,7 +4941,7 @@ export const forkIn = circular.forkIn;
  *   })
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Local scope started!
  * // parent: started!
@@ -4871,9 +4995,9 @@ export const 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
@@ -4941,7 +5065,7 @@ export const fromFiberEffect = circular.fromFiberEffect;
  *     return v1 + v2 // Combine the results
  *   })
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // number of fibers: 0
  * // number of fibers: 2
@@ -5011,7 +5135,8 @@ export const withMaxOpsBeforeYield = core.withMaxOpsBeforeYield;
 /**
  * Retrieves the `Clock` service from the context.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5021,7 +5146,7 @@ export const withMaxOpsBeforeYield = core.withMaxOpsBeforeYield;
  *   console.log(`Current time in milliseconds: ${currentTime}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // Current time in milliseconds: 1735484796134
  * ```
@@ -5034,7 +5159,8 @@ export const 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"
  *
@@ -5045,7 +5171,7 @@ export const clock = effect.clock;
  *   )
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Example Output:
  * // Current time is: 1735484929744
  * ```
@@ -5113,7 +5239,8 @@ export const 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"
  *
@@ -5126,7 +5253,7 @@ export const withConsole = console_.withConsole;
  *   )
  * )
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // start
  * // Task executed
@@ -5150,7 +5277,8 @@ export const delay = effect.delay;
  * `Duration` module, such as a string (`"2 seconds"`) or numeric value
  * representing milliseconds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -5160,7 +5288,7 @@ export const delay = effect.delay;
  *   console.log("Task completed!")
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // Starting task...
  * // Task completed!
@@ -5186,7 +5314,8 @@ export const sleep = effect.sleep;
  * unchanged, and the timing information is provided alongside the result in a
  * tuple.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Duration, Effect } from "effect"
  *
@@ -5202,7 +5331,7 @@ export const 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
  * ```
  *
@@ -5242,12 +5371,8 @@ export const 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"
  *
@@ -5262,7 +5387,7 @@ export const 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...
  * // {
@@ -5276,6 +5401,11 @@ export const 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
  */
@@ -5299,13 +5429,8 @@ export const 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"
  *
@@ -5321,7 +5446,7 @@ export const 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.
@@ -5332,6 +5457,12 @@ export const 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
  */
@@ -5356,12 +5487,8 @@ export const 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"
  *
@@ -5383,7 +5510,7 @@ export const timeoutOption = circular.timeoutOption;
  *   })
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5397,6 +5524,11 @@ export const 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
  */
@@ -5423,12 +5555,8 @@ export const 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"
  *
@@ -5446,7 +5574,7 @@ export const timeoutFail = circular.timeoutFail;
  *   })
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5456,6 +5584,11 @@ export const 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
  */
@@ -5481,11 +5614,8 @@ export const 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"
  *
@@ -5506,7 +5636,7 @@ export const timeoutFailCause = circular.timeoutFailCause;
  *   })
  * )
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // Start processing...
  * // {
@@ -5516,6 +5646,10 @@ export const 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
  */
@@ -5548,7 +5682,8 @@ export const configProviderWith = defaultServices.configProviderWith;
  * 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"
  *
@@ -5563,7 +5698,7 @@ export const configProviderWith = defaultServices.configProviderWith;
  *   })
  * )
  *
- * // Effect.runPromise(program)
+ * Effect.runPromise(program)
  * // Output:
  * // Config value: custom-value
  * ```
@@ -5636,7 +5771,8 @@ export const 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"
  *
@@ -5688,9 +5824,8 @@ export const 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"
  *
@@ -5719,12 +5854,14 @@ export const 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
  */
@@ -5745,9 +5882,8 @@ export const 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"
  *
@@ -5773,11 +5909,13 @@ export const 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
  */
@@ -5904,11 +6042,8 @@ export const 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"
@@ -5922,6 +6057,10 @@ export const 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
  */
@@ -5936,11 +6075,8 @@ export const 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"
@@ -5954,6 +6090,10 @@ export const 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
  */
@@ -5963,7 +6103,8 @@ export const 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"
@@ -5993,11 +6134,8 @@ export const 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"
@@ -6011,6 +6149,10 @@ export const 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
  */
@@ -6027,11 +6169,8 @@ export {
  * 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 bindTo}
+ * **Example**
  *
- * @example
  * ```ts
  * import * as assert from "node:assert"
  * import { Effect, pipe } from "effect"
@@ -6045,6 +6184,11 @@ export {
  * assert.deepStrictEqual(Effect.runSync(result), { x: 2, y: 3, sum: 5 })
  *
  * ```
+ *
+ * @see {@link Do}
+ * @see {@link bind}
+ * @see {@link bindTo}
+ *
  * @category Do notation
  * @since 2.0.0
  */
@@ -6064,17 +6208,14 @@ let_ as 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',
@@ -6084,7 +6225,7 @@ let_ as let };
  *
  * const maybe2 = Effect.option(Effect.fail("Uh oh!"))
  *
- * // Effect.runPromiseExit(maybe2).then(console.log)
+ * Effect.runPromiseExit(maybe2).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -6094,7 +6235,7 @@ let_ as let };
  *
  * const maybe3 = Effect.option(Effect.die("Boom!"))
  *
- * // Effect.runPromiseExit(maybe3).then(console.log)
+ * Effect.runPromiseExit(maybe3).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -6103,6 +6244,9 @@ let_ as 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
  */
@@ -6130,10 +6274,8 @@ export const 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"
  *
@@ -6172,6 +6314,9 @@ export const 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
  */
@@ -6195,10 +6340,8 @@ export const 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"
  *
@@ -6223,7 +6366,7 @@ export const 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!
  * // {
@@ -6233,6 +6376,9 @@ export const 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
  */
@@ -6247,7 +6393,8 @@ export const 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"
  *
@@ -6268,7 +6415,7 @@ export const exit = core.exit;
  *   return isCompleted
  * })
  *
- * // Effect.runPromise(program).then(console.log)
+ * Effect.runPromise(program).then(console.log)
  * // Output:
  * // 42
  * // true
@@ -6287,9 +6434,9 @@ export {
  * evaluates to `true` or `false`. If the predicate is `true`, the `onTrue` effect
  * is executed. If it is `false`, the `onFalse` effect is executed instead.
  *
- * @example
+ * **Example** (Simulating a Coin Flip)
+ *
  * ```ts
- * // Title: Simulating a Coin Flip
  * import { Effect, Random, Console } from "effect"
  *
  * const flipTheCoin = Effect.if(Random.nextBoolean, {
@@ -6297,9 +6444,9 @@ export {
  *   onFalse: () => Console.log("Tail") // Runs if the predicate is false
  * })
  *
- * // Effect.runFork(flipTheCoin)
- *
+ * Effect.runFork(flipTheCoin)
  * ```
+ *
  * @since 2.0.0
  * @category Conditional Operators
  */
@@ -6371,7 +6518,8 @@ export const 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"
  *
@@ -6410,7 +6558,8 @@ export const filterOrFail = effect.filterOrFail;
  * effect. The `orElse` effect can produce an alternative value or perform
  * additional computations.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -6450,7 +6599,8 @@ export const filterEffectOrElse = core.filterEffectOrElse;
  * This is useful for enforcing constraints and treating violations as
  * recoverable errors.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect, pipe } from "effect"
  *
@@ -6512,12 +6662,9 @@ export const 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 = (
@@ -6527,7 +6674,7 @@ export const 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",
@@ -6536,7 +6683,7 @@ export const 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",
@@ -6544,6 +6691,9 @@ export const 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
  */
@@ -6565,12 +6715,9 @@ export const 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(
@@ -6582,6 +6729,9 @@ export const 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
  */
@@ -6650,9 +6800,8 @@ export const 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"
  *
@@ -6674,10 +6823,12 @@ export const 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
  */
@@ -6716,9 +6867,9 @@ export const 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
@@ -6740,7 +6891,7 @@ export const 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
@@ -6750,7 +6901,7 @@ export const flatMap = core.flatMap;
  *   Effect.andThen((amount) => applyDiscount(amount, 5))
  * )
  *
- * // Effect.runPromise(result2).then(console.log)
+ * Effect.runPromise(result2).then(console.log)
  * // Output: 190
  * ```
  *
@@ -6789,12 +6940,9 @@ export const 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(
@@ -6810,15 +6958,15 @@ export const 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(
@@ -6834,14 +6982,14 @@ export const 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(
@@ -6857,7 +7005,7 @@ export const flatten = core.flatten;
  *
  * const program = Effect.race(task1, task2)
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // {
  * //   _id: 'Exit',
@@ -6871,9 +7019,9 @@ export const 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(
@@ -6891,12 +7039,15 @@ export const 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
  */
@@ -6920,11 +7071,9 @@ export const 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(
@@ -6946,16 +7095,16 @@ export const 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(
@@ -6977,15 +7126,15 @@ export const 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(
@@ -7007,7 +7156,7 @@ export const 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',
@@ -7016,6 +7165,8 @@ export const race = fiberRuntime.race;
  * // }
  * ```
  *
+ * @see {@link race} for a version that handles only two effects.
+ *
  * @since 2.0.0
  * @category Racing
  */
@@ -7053,9 +7204,9 @@ export const 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(
@@ -7077,7 +7228,7 @@ export const 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
@@ -7085,9 +7236,9 @@ export const 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(
@@ -7109,7 +7260,7 @@ export const raceAll = fiberRuntime.raceAll;
  *   Effect.tap(Console.log("more work..."))
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task2 interrupted
  * // {
@@ -7119,9 +7270,9 @@ export const 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(
@@ -7145,7 +7296,7 @@ export const 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...
@@ -7178,9 +7329,9 @@ export const 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(
@@ -7203,7 +7354,7 @@ export const raceFirst = circular.raceFirst;
  *   onOtherDone: (exit) => Console.log(`task2 exited with ${exit}`)
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output:
  * // task1 done
  * // task1 exited with {
@@ -7245,11 +7396,9 @@ export const 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
@@ -7272,12 +7421,14 @@ export const 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
  */
@@ -7301,7 +7452,8 @@ export const 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"
  *
@@ -7319,7 +7471,7 @@ export const tap = core.tap;
  *     Console.log(`random number: ${randomNumber}`)
  * })
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Example Output:
  * // failure: random number is negative
  * ```
@@ -7344,7 +7496,8 @@ export const 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"
  *
@@ -7356,7 +7509,7 @@ export const tapBoth = effect.tapBoth;
  *   Console.log(`defect: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping1)
+ * Effect.runFork(tapping1)
  * // No Output
  *
  * // Simulate a severe failure in the system
@@ -7369,7 +7522,7 @@ export const tapBoth = effect.tapBoth;
  *   Console.log(`defect: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping2)
+ * Effect.runFork(tapping2)
  * // Output:
  * // defect: RuntimeException: Something went wrong
  * //   ... stack trace ...
@@ -7394,7 +7547,8 @@ export const 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"
  *
@@ -7406,7 +7560,7 @@ export const tapDefect = effect.tapDefect;
  *   Console.log(`expected error: ${error}`)
  * )
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Output:
  * // expected error: NetworkError
  * ```
@@ -7429,7 +7583,8 @@ export const 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"
  *
@@ -7452,7 +7607,7 @@ export const tapError = effect.tapError;
  *   Console.log(`expected error: ${error.statusCode}`)
  * )
  *
- * // Effect.runFork(tapping)
+ * Effect.runFork(tapping)
  * // Output:
  * // expected error: 504
  * ```
@@ -7476,7 +7631,8 @@ export const 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"
  *
@@ -7487,7 +7643,7 @@ export const tapErrorTag = effect.tapErrorTag;
  *   Console.log(`error cause: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping1)
+ * Effect.runFork(tapping1)
  * // Output:
  * // error cause: Error: NetworkError
  *
@@ -7500,7 +7656,7 @@ export const tapErrorTag = effect.tapErrorTag;
  *   Console.log(`error cause: ${cause}`)
  * )
  *
- * // Effect.runFork(tapping2)
+ * Effect.runFork(tapping2)
  * // Output:
  * // error cause: RuntimeException: Something went wrong
  * //   ... stack trace ...
@@ -7564,9 +7720,9 @@ export const 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(
@@ -7580,7 +7736,7 @@ export const forever = effect.forever;
  *   }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output: 6
  * ```
  *
@@ -7629,9 +7785,9 @@ export const 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
@@ -7648,12 +7804,13 @@ export const 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(
@@ -7671,7 +7828,7 @@ export const iterate = effect.iterate;
  *   }
  * )
  *
- * // Effect.runPromise(result).then(console.log)
+ * Effect.runPromise(result).then(console.log)
  * // Output:
  * // Currently at state 1
  * // Currently at state 2
@@ -7679,6 +7836,7 @@ export const iterate = effect.iterate;
  * // Currently at state 4
  * // Currently at state 5
  * // undefined
+ * ```
  *
  * @since 2.0.0
  * @category Looping
@@ -7706,20 +7864,21 @@ export const 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
@@ -7739,7 +7898,8 @@ export const 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
@@ -7763,14 +7923,15 @@ export const 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
@@ -7794,7 +7955,8 @@ export const 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"
  *
@@ -7824,7 +7986,7 @@ export const 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
@@ -7973,18 +8135,19 @@ export const 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!
  * ```
  *
@@ -8024,11 +8187,9 @@ export const 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)
@@ -8039,7 +8200,7 @@ export const 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(
@@ -8052,10 +8213,12 @@ export const 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
  */
@@ -8074,13 +8237,9 @@ export const 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!")
@@ -8106,11 +8265,14 @@ export const 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
  */
@@ -8127,12 +8289,9 @@ export const 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!")
@@ -8158,10 +8317,13 @@ export const 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
  */
@@ -8180,12 +8342,9 @@ export const 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)
@@ -8222,6 +8381,9 @@ export const 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
  */
@@ -8242,7 +8404,8 @@ export const 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"
  *
@@ -8253,7 +8416,7 @@ export const 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!"
@@ -8273,7 +8436,8 @@ export const 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"
  *
@@ -8283,7 +8447,7 @@ export const 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!"
  * ```
@@ -8303,13 +8467,14 @@ export const logWithLevel = (level, ...message) => effect.logWithLevel(level)(..
  * 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
  * ```
  *
@@ -8327,13 +8492,14 @@ export const 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
  * ```
  *
@@ -8410,7 +8576,8 @@ export const 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"
  *
@@ -8419,7 +8586,7 @@ export const 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
  * ```
  *
@@ -8445,9 +8612,8 @@ export const 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"
  *
@@ -8456,11 +8622,13 @@ export const 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
  */
@@ -8481,9 +8649,8 @@ export const 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"
  *
@@ -8494,13 +8661,15 @@ export const 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
  */
@@ -8543,7 +8712,8 @@ export const 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"
  *
@@ -8552,7 +8722,7 @@ export const 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!"
  * ```
@@ -8574,7 +8744,8 @@ export const withUnhandledErrorLogLevel = core.withUnhandledErrorLogLevel;
  * 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"
  *
@@ -8583,7 +8754,7 @@ export const withUnhandledErrorLogLevel = core.withUnhandledErrorLogLevel;
  *   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
  * ```
  *
@@ -8610,11 +8781,9 @@ export const 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) =>
@@ -8626,12 +8795,14 @@ export const 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
  */
@@ -8651,11 +8822,9 @@ export const 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) =>
@@ -8670,12 +8839,14 @@ export const 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
  */
@@ -8694,9 +8865,8 @@ export const 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"
  *
@@ -8715,6 +8885,8 @@ export const 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
  */
@@ -8737,9 +8909,8 @@ export const 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"
  *
@@ -8764,6 +8935,8 @@ export const orElse = core.orElse;
  * // }
  * ```
  *
+ * @see {@link mapError} if you need to access the error to transform it.
+ *
  * @since 2.0.0
  * @category Fallback
  */
@@ -8787,7 +8960,8 @@ export const 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"
  *
@@ -8837,7 +9011,8 @@ export const 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"
  *
@@ -9047,7 +9222,8 @@ export const unsafeMakeSemaphore = circular.unsafeMakeSemaphore;
  * shared resource. The number of permits determines how many tasks can access
  * the resource concurrently.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9072,7 +9248,8 @@ export const 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"
  *
@@ -9093,7 +9270,7 @@ export const unsafeMakeLatch = circular.unsafeMakeLatch;
  *   yield* fiber.await
  * })
  *
- * // Effect.runFork(program)
+ * Effect.runFork(program)
  * // Output: open sesame (after 1 second)
  * ```
  *
@@ -9131,9 +9308,9 @@ export const 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>
@@ -9194,25 +9371,27 @@ export const 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
@@ -9243,13 +9422,13 @@ export const 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",
@@ -9258,7 +9437,7 @@ export const 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",
@@ -9305,12 +9484,9 @@ export const runPromiseExit = runtime_.unsafeRunPromiseExitEffect;
  * 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(() => {
@@ -9325,8 +9501,9 @@ export const runPromiseExit = runtime_.unsafeRunPromiseExitEffect;
  * // 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 {
@@ -9346,6 +9523,10 @@ export const runPromiseExit = runtime_.unsafeRunPromiseExitEffect;
  * }
  * // 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
@@ -9376,9 +9557,9 @@ export const 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)))
@@ -9402,8 +9583,9 @@ export const 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))))
@@ -9421,6 +9603,7 @@ export const runSync = runtime_.unsafeRunSyncEffect;
  * //     }
  * //   }
  * // }
+ * ```
  *
  * @since 2.0.0
  * @category Running Effects
@@ -9441,9 +9624,8 @@ export const 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"
  *
@@ -9458,7 +9640,7 @@ export const runSyncExit = runtime_.unsafeRunSyncExitEffect;
  *   Effect.validate(task4)
  * )
  *
- * // Effect.runPromiseExit(program).then(console.log)
+ * Effect.runPromiseExit(program).then(console.log)
  * // Output:
  * // task1
  * // task2
@@ -9474,6 +9656,8 @@ export const runSyncExit = runtime_.unsafeRunSyncExitEffect;
  * // }
  * ```
  *
+ * @see {@link zip} for a version that stops at the first error.
+ *
  * @since 2.0.0
  * @category Error Accumulation
  */
@@ -9513,13 +9697,9 @@ export const 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(
@@ -9537,15 +9717,16 @@ export const 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(
@@ -9560,11 +9741,16 @@ export const 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
@@ -9591,10 +9777,8 @@ export const 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"
  *
@@ -9609,13 +9793,16 @@ export const 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
  */
@@ -9641,10 +9828,8 @@ export const 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"
  *
@@ -9659,13 +9844,16 @@ export const 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
  */
@@ -9682,9 +9870,9 @@ export const 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(
@@ -9703,7 +9891,7 @@ export const 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"
@@ -9791,9 +9979,8 @@ export const withTracerScoped = fiberRuntime.withTracerScoped;
 /**
  * Disable the tracer for the given Effect.
  *
- * @since 2.0.0
- * @category Tracing
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Effect } from "effect"
  *
@@ -9803,6 +9990,9 @@ export const withTracerScoped = fiberRuntime.withTracerScoped;
  *   Effect.withTracerEnabled(false)
  * )
  * ```
+ *
+ * @since 2.0.0
+ * @category Tracing
  */
 export const withTracerEnabled = core.withTracerEnabled;
 /**
@@ -9913,9 +10103,8 @@ export const 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"
  *
@@ -9927,6 +10116,9 @@ export const withSpan = effect.withSpan;
  *   })
  * })
  * ```
+ *
+ * @since 3.2.0
+ * @category Tracing
  */
 export const functionWithSpan = effect.functionWithSpan;
 /**
@@ -9968,7 +10160,8 @@ export const 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"
  *
@@ -9976,7 +10169,7 @@ export const 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 }
  *
@@ -9984,7 +10177,7 @@ export const 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',
@@ -10024,7 +10217,8 @@ export const 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"
  *
@@ -10036,7 +10230,7 @@ export const 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>
@@ -10047,7 +10241,7 @@ export const fromNullable = effect.fromNullable;
  * //      ▼
  * const option2 = Effect.optionFromOptional(maybe2)
  *
- * // Effect.runPromise(option2).then(console.log)
+ * Effect.runPromise(option2).then(console.log)
  * // Output: { _tag: 'None' }
  * ```
  *
@@ -10065,7 +10259,8 @@ export const optionFromOptional = effect.optionFromOptional;
  * 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"
  *
@@ -10129,7 +10324,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"
  *
@@ -10182,7 +10378,8 @@ export 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';
  *