effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Cause.d.ts

@@ -58,12 +58,10 @@ export declare const ReasonTypeId: "~effect/Cause/Reason";
  *
  * **Example** (Creating and inspecting a cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.fail("Something went wrong")
- * console.log(cause.reasons.length) // 1
- * console.log(Cause.isFailReason(cause.reasons[0])) // true
+ * Cause.fail("Something went wrong") // => Cause.fail("Something went wrong")
  * ```
  *
  * @category models
@@ -78,11 +76,11 @@ export interface Cause<out E> extends Pipeable, Inspectable, Equal {
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isCause(Cause.fail("error"))) // true
- * console.log(Cause.isCause("not a cause")) // false
+ * Cause.isCause(Cause.fail("error")) // => true
+ * Cause.isCause("not a cause") // => false
  * ```
  *
  * @category guards
@@ -94,12 +92,12 @@ export declare const isCause: (self: unknown) => self is Cause<unknown>;
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const reason = Cause.fail("error").reasons[0]
- * console.log(Cause.isReason(reason)) // true
- * console.log(Cause.isReason("not a reason")) // false
+ * Cause.isReason(reason) // => true
+ * Cause.isReason("not a reason") // => false
  * ```
  *
  * @category guards
@@ -123,12 +121,12 @@ export declare const isReason: (self: unknown) => self is Reason<unknown>;
  *
  * **Example** (Narrowing a reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const reason = Cause.fail("error").reasons[0]
  * if (Cause.isFailReason(reason)) {
- *   console.log(reason.error) // "error"
+ *   reason.error // => "error"
  * }
  * ```
  *
@@ -146,12 +144,12 @@ export type Reason<E> = Fail<E> | Die | Interrupt;
  *
  * **Example** (Filtering fail reasons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.fail("error")
  * const fails = cause.reasons.filter(Cause.isFailReason)
- * console.log(fails[0].error) // "error"
+ * fails[0].error // => "error"
  * ```
  *
  * @see {@link isDieReason} — narrow to `Die`
@@ -171,12 +169,12 @@ export declare const isFailReason: <E>(self: Reason<E>) => self is Fail<E>;
  *
  * **Example** (Filtering die reasons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.die("defect")
  * const dies = cause.reasons.filter(Cause.isDieReason)
- * console.log(dies[0].defect) // "defect"
+ * dies[0].defect // => "defect"
  * ```
  *
  * @see {@link isFailReason} — narrow to `Fail`
@@ -196,12 +194,12 @@ export declare const isDieReason: <E>(self: Reason<E>) => self is Die;
  *
  * **Example** (Filtering interrupt reasons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.interrupt(123)
  * const interrupts = cause.reasons.filter(Cause.isInterruptReason)
- * console.log(interrupts[0].fiberId) // 123
+ * interrupts[0].fiberId // => 123
  * ```
  *
  * @see {@link isFailReason} — narrow to `Fail`
@@ -222,14 +220,14 @@ export declare namespace Cause {
      *
      * **Example** (Extracting the error type)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Cause } from "effect"
      *
      * // string
      * type E = Cause.Cause.Error<Cause.Cause<string>>
      * ```
      *
-     * @category models
+     * @category utility types
      * @since 4.0.0
      */
     type Error<T> = T extends Cause<infer E> ? E : never;
@@ -266,14 +264,14 @@ export declare namespace Reason {
      *
      * **Example** (Extracting the error type)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Cause } from "effect"
      *
      * // string
      * type E = Cause.Reason.Error<Cause.Reason<string>>
      * ```
      *
-     * @category models
+     * @category utility types
      * @since 4.0.0
      */
     type Error<T> = T extends Reason<infer E> ? E : never;
@@ -294,13 +292,13 @@ export declare namespace Reason {
  *
  * **Example** (Accessing the defect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.die("Unexpected")
  * const reason = cause.reasons[0]
  * if (Cause.isDieReason(reason)) {
- *   console.log(reason.defect) // "Unexpected"
+ *   reason.defect // => "Unexpected"
  * }
  * ```
  *
@@ -328,13 +326,13 @@ export interface Die extends Cause.ReasonProto<"Die"> {
  *
  * **Example** (Accessing the error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.fail("Something went wrong")
  * const reason = cause.reasons[0]
  * if (Cause.isFailReason(reason)) {
- *   console.log(reason.error) // "Something went wrong"
+ *   reason.error // => "Something went wrong"
  * }
  * ```
  *
@@ -357,13 +355,13 @@ export interface Fail<out E> extends Cause.ReasonProto<"Fail"> {
  *
  * **Example** (Accessing the fiber ID)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.interrupt(123)
  * const reason = cause.reasons[0]
  * if (Cause.isInterruptReason(reason)) {
- *   console.log(reason.fiberId) // 123
+ *   reason.fiberId // => 123
  * }
  * ```
  *
@@ -394,15 +392,14 @@ export interface Interrupt extends Cause.ReasonProto<"Interrupt"> {
  *
  * **Example** (Building a cause from reasons)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const reasons = [
  *   Cause.makeFailReason("err1"),
  *   Cause.makeFailReason("err2")
  * ]
- * const cause = Cause.fromReasons(reasons)
- * console.log(cause.reasons.length) // 2
+ * Cause.fromReasons(reasons) // => Cause.combine(Cause.fail("err1"), Cause.fail("err2"))
  * ```
  *
  * @see {@link combine} — merge two existing causes
@@ -426,13 +423,10 @@ export declare const fromReasons: <E>(reasons: ReadonlyArray<Reason<E>>) => Caus
  *
  * **Example** (Combining with the empty cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.combine(Cause.empty, Cause.fail("boom"))
- *
- * console.log(cause.reasons.length) // 1
- * console.log(Cause.hasFails(cause)) // true
+ * Cause.combine(Cause.empty, Cause.fail("boom")) // => Cause.fail("boom")
  * ```
  *
  * @see {@link combine} for merging causes where `empty` acts as the identity
@@ -451,12 +445,10 @@ export declare const empty: Cause<never>;
  *
  * **Example** (Creating a fail cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.fail("Something went wrong")
- * console.log(cause.reasons.length) // 1
- * console.log(Cause.isFailReason(cause.reasons[0])) // true
+ * Cause.fail("Something went wrong") // => Cause.fromReasons([Cause.makeFailReason("Something went wrong")])
  * ```
  *
  * @see {@link die} — for untyped defects
@@ -476,12 +468,10 @@ export declare const fail: <E>(error: E) => Cause<E>;
  *
  * **Example** (Creating a die cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.die("Unexpected")
- * console.log(cause.reasons.length) // 1
- * console.log(Cause.isDieReason(cause.reasons[0])) // true
+ * Cause.die("Unexpected") // => Cause.fromReasons([Cause.makeDieReason("Unexpected")])
  * ```
  *
  * @see {@link fail} — for typed errors
@@ -497,12 +487,10 @@ export declare const die: (defect: unknown) => Cause<never>;
  *
  * **Example** (Creating an interrupt cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.interrupt(123)
- * console.log(cause.reasons.length) // 1
- * console.log(Cause.isInterruptReason(cause.reasons[0])) // true
+ * Cause.interrupt(123) // => Cause.fromReasons([Cause.makeInterruptReason(123)])
  * ```
  *
  * @see {@link fail} — for typed errors
@@ -522,12 +510,10 @@ export declare const interrupt: (fiberId?: number | undefined) => Cause<never>;
  *
  * **Example** (Creating a Fail reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const reason = Cause.makeFailReason("error")
- * console.log(reason._tag) // "Fail"
- * console.log(reason.error) // "error"
+ * Cause.makeFailReason("error") // => Cause.fail("error").reasons[0]
  * ```
  *
  * @see {@link makeDieReason} — create a `Die` reason
@@ -547,12 +533,10 @@ export declare const makeFailReason: <E>(error: E) => Fail<E>;
  *
  * **Example** (Creating a Die reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const reason = Cause.makeDieReason("bug")
- * console.log(reason._tag) // "Die"
- * console.log(reason.defect) // "bug"
+ * Cause.makeDieReason("bug") // => Cause.die("bug").reasons[0]
  * ```
  *
  * @see {@link makeFailReason} — create a `Fail` reason
@@ -573,12 +557,10 @@ export declare const makeDieReason: (defect: unknown) => Die;
  *
  * **Example** (Creating an Interrupt reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const reason = Cause.makeInterruptReason(42)
- * console.log(reason._tag) // "Interrupt"
- * console.log(reason.fiberId) // 42
+ * Cause.makeInterruptReason(42) // => Cause.interrupt(42).reasons[0]
  * ```
  *
  * @see {@link makeFailReason} — create a `Fail` reason
@@ -598,12 +580,12 @@ export declare const makeInterruptReason: (fiberId?: number | undefined) => Inte
  *
  * **Example** (Checking interrupt-only causes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.hasInterruptsOnly(Cause.interrupt(123))) // true
- * console.log(Cause.hasInterruptsOnly(Cause.fail("error")))  // false
- * console.log(Cause.hasInterruptsOnly(Cause.empty))          // false
+ * Cause.hasInterruptsOnly(Cause.interrupt(123)) // => true
+ * Cause.hasInterruptsOnly(Cause.fail("error")) // => false
+ * Cause.hasInterruptsOnly(Cause.empty) // => false
  * ```
  *
  * @see {@link hasInterrupts} — `true` if the cause contains *any* interrupts
@@ -630,14 +612,14 @@ export declare const hasInterruptsOnly: <E>(self: Cause<E>) => boolean;
  *
  * **Example** (Mapping errors to uppercase)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.fail("error")
  * const mapped = Cause.map(cause, (e) => e.toUpperCase())
  * const reason = mapped.reasons[0]
  * if (Cause.isFailReason(reason)) {
- *   console.log(reason.error) // "ERROR"
+ *   reason.error // => "ERROR"
  * }
  * ```
  *
@@ -663,14 +645,14 @@ export declare const map: {
      *
      * **Example** (Mapping errors to uppercase)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause } from "effect"
      *
      * const cause = Cause.fail("error")
      * const mapped = Cause.map(cause, (e) => e.toUpperCase())
      * const reason = mapped.reasons[0]
      * if (Cause.isFailReason(reason)) {
-     *   console.log(reason.error) // "ERROR"
+     *   reason.error // => "ERROR"
      * }
      * ```
      *
@@ -696,14 +678,14 @@ export declare const map: {
      *
      * **Example** (Mapping errors to uppercase)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause } from "effect"
      *
      * const cause = Cause.fail("error")
      * const mapped = Cause.map(cause, (e) => e.toUpperCase())
      * const reason = mapped.reasons[0]
      * if (Cause.isFailReason(reason)) {
-     *   console.log(reason.error) // "ERROR"
+     *   reason.error // => "ERROR"
      * }
      * ```
      *
@@ -728,13 +710,11 @@ export declare const map: {
  *
  * **Example** (Combining two causes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause1 = Cause.fail("error1")
- * const cause2 = Cause.fail("error2")
- * const combined = Cause.combine(cause1, cause2)
- * console.log(combined.reasons.length) // 2
+ * const combined = Cause.combine(Cause.fail("error1"), Cause.fail("error2"))
+ * combined // => Cause.fromReasons([Cause.makeFailReason("error1"), Cause.makeFailReason("error2")])
  * ```
  *
  * @see {@link fromReasons} — build a cause from an array of reasons
@@ -760,13 +740,11 @@ export declare const combine: {
      *
      * **Example** (Combining two causes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause } from "effect"
      *
-     * const cause1 = Cause.fail("error1")
-     * const cause2 = Cause.fail("error2")
-     * const combined = Cause.combine(cause1, cause2)
-     * console.log(combined.reasons.length) // 2
+     * const combined = Cause.combine(Cause.fail("error1"), Cause.fail("error2"))
+     * combined // => Cause.fromReasons([Cause.makeFailReason("error1"), Cause.makeFailReason("error2")])
      * ```
      *
      * @see {@link fromReasons} — build a cause from an array of reasons
@@ -792,13 +770,11 @@ export declare const combine: {
      *
      * **Example** (Combining two causes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause } from "effect"
      *
-     * const cause1 = Cause.fail("error1")
-     * const cause2 = Cause.fail("error2")
-     * const combined = Cause.combine(cause1, cause2)
-     * console.log(combined.reasons.length) // 2
+     * const combined = Cause.combine(Cause.fail("error1"), Cause.fail("error2"))
+     * combined // => Cause.fromReasons([Cause.makeFailReason("error1"), Cause.makeFailReason("error2")])
      * ```
      *
      * @see {@link fromReasons} — build a cause from an array of reasons
@@ -835,11 +811,11 @@ export declare const combine: {
  *
  * **Example** (Squashing a cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.squash(Cause.fail("error")))    // "error"
- * console.log(Cause.squash(Cause.die("defect")))    // "defect"
+ * Cause.squash(Cause.fail("error")) // => "error"
+ * Cause.squash(Cause.die("defect")) // => "defect"
  * ```
  *
  * @see {@link prettyErrors} — non-lossy conversion to `Array<Error>`
@@ -859,11 +835,11 @@ export declare const squash: <E>(self: Cause<E>) => unknown;
  *
  * **Example** (Checking for typed errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.hasFails(Cause.fail("error"))) // true
- * console.log(Cause.hasFails(Cause.die("defect"))) // false
+ * Cause.hasFails(Cause.fail("error")) // => true
+ * Cause.hasFails(Cause.die("defect")) // => false
  * ```
  *
  * @see {@link hasDies} — check for defects
@@ -886,13 +862,10 @@ export declare const hasFails: <E>(self: Cause<E>) => boolean;
  *
  * **Example** (Extracting the first Fail reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.findFail(Cause.fail("error"))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success.error) // "error"
- * }
+ * Cause.findFail(Cause.fail("error")) // => Result.succeed(Cause.makeFailReason("error"))
  * ```
  *
  * @see {@link findError} — extract the unwrapped `E` value
@@ -915,13 +888,10 @@ export declare const findFail: <E>(self: Cause<E>) => Result.Result<Fail<E>, Cau
  *
  * **Example** (Extracting the first error value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.findError(Cause.fail("error"))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success) // "error"
- * }
+ * Cause.findError(Cause.fail("error")) // => Result.succeed("error")
  * ```
  *
  * @see {@link findFail} — extract the full `Fail` reason
@@ -942,14 +912,11 @@ export declare const findError: <E>(self: Cause<E>) => Result.Result<E, Cause<ne
  *
  * **Example** (Extracting an error as Option)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Option } from "effect"
  *
- * const some = Cause.findErrorOption(Cause.fail("error"))
- * console.log(Option.isSome(some)) // true
- *
- * const none = Cause.findErrorOption(Cause.die("defect"))
- * console.log(Option.isNone(none)) // true
+ * Cause.findErrorOption(Cause.fail("error")) // => Option.some("error")
+ * Cause.findErrorOption(Cause.die("defect")) // => Option.none()
  * ```
  *
  * @see {@link findError} — `Result`-based variant
@@ -968,11 +935,11 @@ export declare const findErrorOption: <E>(input: Cause<E>) => Option<E>;
  *
  * **Example** (Checking for defects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.hasDies(Cause.die("defect"))) // true
- * console.log(Cause.hasDies(Cause.fail("error"))) // false
+ * Cause.hasDies(Cause.die("defect")) // => true
+ * Cause.hasDies(Cause.fail("error")) // => false
  * ```
  *
  * @see {@link hasFails} — check for typed errors
@@ -994,13 +961,10 @@ export declare const hasDies: <E>(self: Cause<E>) => boolean;
  *
  * **Example** (Extracting the first Die reason)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.findDie(Cause.die("defect"))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success.defect) // "defect"
- * }
+ * Cause.findDie(Cause.die("defect")) // => Result.succeed(Cause.makeDieReason("defect"))
  * ```
  *
  * @see {@link findDefect} — extract the unwrapped defect value
@@ -1022,13 +986,10 @@ export declare const findDie: <E>(self: Cause<E>) => Result.Result<Die, Cause<E>
  *
  * **Example** (Extracting the first defect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.findDefect(Cause.die("defect"))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success) // "defect"
- * }
+ * Cause.findDefect(Cause.die("defect")) // => Result.succeed("defect")
  * ```
  *
  * @see {@link findDie} — extract the full `Die` reason
@@ -1043,11 +1004,11 @@ export declare const findDefect: <E>(self: Cause<E>) => Result.Result<unknown, C
  *
  * **Example** (Checking for interruptions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.hasInterrupts(Cause.interrupt(123))) // true
- * console.log(Cause.hasInterrupts(Cause.fail("error")))  // false
+ * Cause.hasInterrupts(Cause.interrupt(123)) // => true
+ * Cause.hasInterrupts(Cause.fail("error")) // => false
  * ```
  *
  * @see {@link hasInterruptsOnly} — `true` only when *all* reasons are interrupts
@@ -1070,13 +1031,10 @@ export declare const hasInterrupts: <E>(self: Cause<E>) => boolean;
  *
  * **Example** (Extracting the first interrupt)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.findInterrupt(Cause.interrupt(42))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success.fiberId) // 42
- * }
+ * Cause.findInterrupt(Cause.interrupt(42)) // => Result.succeed(Cause.makeInterruptReason(42))
  * ```
  *
  * @see {@link interruptors} — collect all interrupting fiber IDs as a `Set`
@@ -1097,7 +1055,7 @@ export declare const findInterrupt: <E>(self: Cause<E>) => Result.Result<Interru
  *
  * **Example** (Collecting interruptors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
  * const cause = Cause.combine(
@@ -1105,12 +1063,12 @@ export declare const findInterrupt: <E>(self: Cause<E>) => Result.Result<Interru
  *   Cause.interrupt(2)
  * )
  *
- * console.log(Cause.interruptors(cause)) // Set(2) { 1, 2 }
+ * Cause.interruptors(cause) // => new Set([1, 2])
  * ```
  *
  * @see {@link filterInterruptors} — `Result`-based variant
  *
- * @category accessors
+ * @category getters
  * @since 2.0.0
  */
 export declare const interruptors: <E>(self: Cause<E>) => ReadonlySet<number>;
@@ -1132,13 +1090,10 @@ export declare const interruptors: <E>(self: Cause<E>) => ReadonlySet<number>;
  *
  * **Example** (Extracting interruptors with Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Result } from "effect"
  *
- * const result = Cause.filterInterruptors(Cause.interrupt(1))
- * if (!Result.isFailure(result)) {
- *   console.log(result.success) // Set(1) { 1 }
- * }
+ * Cause.filterInterruptors(Cause.interrupt(1)) // => Result.succeed(new Set([1]))
  * ```
  *
  * @see {@link interruptors} — always-succeeding variant
@@ -1176,18 +1131,16 @@ export declare const filterInterruptors: <E>(self: Cause<E>) => Result.Result<Se
  *
  * **Example** (Converting a cause to errors)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const cause = Cause.fail(new Error("boom"))
- * const errors = Cause.prettyErrors(cause)
- * console.log(errors[0].message) // "boom"
+ * Cause.prettyErrors(Cause.fail(new Error("boom")))[0].message // => "boom"
  * ```
  *
  * @see {@link pretty} — renders the cause as a single string
  * @see {@link squash} — lossy collapse to a single thrown value
  *
- * @category rendering
+ * @category formatting
  * @since 3.2.0
  */
 export declare const prettyErrors: <E>(self: Cause<E>, options?: {
@@ -1225,16 +1178,15 @@ export declare const prettyErrors: <E>(self: Cause<E>, options?: {
  *
  * **Example** (Rendering a cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const rendered = Cause.pretty(Cause.fail("something went wrong"))
- * console.log(rendered.includes("something went wrong")) // true
+ * Cause.pretty(Cause.fail("something went wrong")).includes("something went wrong") // => true
  * ```
  *
  * @see {@link prettyErrors} — get the individual `Error` instances
  *
- * @category rendering
+ * @category formatting
  * @since 2.0.0
  */
 export declare const pretty: <E>(cause: Cause<E>) => string;
@@ -1251,14 +1203,16 @@ export declare const pretty: <E>(cause: Cause<E>) => string;
  *
  * **Example** (Yielding an error in Effect.gen)
  *
- * ```ts
- * import { Cause, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit } from "effect"
  *
  * const error = new Cause.NoSuchElementError("not found")
  *
  * const program = Effect.gen(function*() {
  *   return yield* error // fails the effect with NoSuchElementError
  * })
+ *
+ * await Effect.runPromiseExit(program) // => Exit.fail(error)
  * ```
  *
  * @category errors
@@ -1273,11 +1227,11 @@ export interface YieldableError extends Error, Pipeable, Inspectable {
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isNoSuchElementError(new Cause.NoSuchElementError())) // true
- * console.log(Cause.isNoSuchElementError("nope")) // false
+ * Cause.isNoSuchElementError(new Cause.NoSuchElementError()) // => true
+ * Cause.isNoSuchElementError("nope") // => false
  * ```
  *
  * @category guards
@@ -1310,16 +1264,6 @@ export declare const NoSuchElementErrorTypeId: "~effect/Cause/NoSuchElementError
  * expected case. This error is mainly for APIs that intentionally turn absence
  * into a thrown value or failed effect.
  *
- * **Example** (Creating and checking a NoSuchElementError)
- *
- * ```ts
- * import { Cause } from "effect"
- *
- * const error = new Cause.NoSuchElementError("Element not found")
- * console.log(error._tag)    // "NoSuchElementError"
- * console.log(error.message) // "Element not found"
- * ```
- *
  * @category errors
  * @since 4.0.0
  */
@@ -1337,11 +1281,10 @@ export interface NoSuchElementError extends YieldableError {
  *
  * **Example** (Creating a NoSuchElementError)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const error = new Cause.NoSuchElementError("Element not found")
- * console.log(error.message) // "Element not found"
+ * new Cause.NoSuchElementError("Element not found").message // => "Element not found"
  * ```
  *
  * @see {@link isNoSuchElementError} for checking unknown values
@@ -1355,11 +1298,11 @@ export declare const NoSuchElementError: new (message?: string) => NoSuchElement
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isDone(Cause.Done())) // true
- * console.log(Cause.isDone("not done"))   // false
+ * Cause.isDone(Cause.Done()) // => true
+ * Cause.isDone("not done") // => false
  * ```
  *
  * @category guards
@@ -1390,7 +1333,7 @@ export declare const DoneTypeId: "~effect/Cause/Done";
  *
  * **Example** (Signaling queue completion)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1398,9 +1341,12 @@ export declare const DoneTypeId: "~effect/Cause/Done";
  *   yield* Queue.offer(queue, 1)
  *   yield* Queue.end(queue)
  *
+ *   yield* Queue.take(queue)
  *   const result = yield* Effect.flip(Queue.take(queue))
- *   console.log(Cause.isDone(result)) // true
+ *   return Cause.isDone(result)
  * })
+ *
+ * await Effect.runPromise(program) // => true
  * ```
  *
  * @category errors
@@ -1456,14 +1402,12 @@ export declare const Done: <A = void>(value?: A) => Done<A>;
  *
  * **Example** (Failing with Done)
  *
- * ```ts
- * import { Cause, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit } from "effect"
  *
  * const program = Cause.done("finished")
  *
- * Effect.runPromiseExit(program).then((exit) => {
- *   console.log(exit._tag) // "Failure"
- * })
+ * await Effect.runPromiseExit(program) // => Exit.fail(Cause.Done("finished"))
  * ```
  *
  * @see {@link Done} — create the signal value without an Effect
@@ -1484,11 +1428,11 @@ export declare const TimeoutErrorTypeId: "~effect/Cause/TimeoutError";
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isTimeoutError(new Cause.TimeoutError())) // true
- * console.log(Cause.isTimeoutError("nope")) // false
+ * Cause.isTimeoutError(new Cause.TimeoutError()) // => true
+ * Cause.isTimeoutError("nope") // => false
  * ```
  *
  * @category guards
@@ -1503,16 +1447,6 @@ export declare const isTimeoutError: (u: unknown) => u is TimeoutError;
  * Produced by `Effect.timeout` and related APIs. Implements
  * `YieldableError`.
  *
- * **Example** (Creating and checking a TimeoutError)
- *
- * ```ts
- * import { Cause } from "effect"
- *
- * const error = new Cause.TimeoutError("Operation timed out")
- * console.log(error._tag)    // "TimeoutError"
- * console.log(error.message) // "Operation timed out"
- * ```
- *
  * @category errors
  * @since 4.0.0
  */
@@ -1525,11 +1459,10 @@ export interface TimeoutError extends YieldableError {
  *
  * **Example** (Creating a TimeoutError)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const error = new Cause.TimeoutError("Operation timed out")
- * console.log(error.message) // "Operation timed out"
+ * new Cause.TimeoutError("Operation timed out").message // => "Operation timed out"
  * ```
  *
  * @category constructors
@@ -1548,11 +1481,11 @@ export declare const IllegalArgumentErrorTypeId: "~effect/Cause/IllegalArgumentE
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isIllegalArgumentError(new Cause.IllegalArgumentError())) // true
- * console.log(Cause.isIllegalArgumentError("nope")) // false
+ * Cause.isIllegalArgumentError(new Cause.IllegalArgumentError()) // => true
+ * Cause.isIllegalArgumentError("nope") // => false
  * ```
  *
  * @category guards
@@ -1567,16 +1500,6 @@ export declare const isIllegalArgumentError: (u: unknown) => u is IllegalArgumen
  *
  * Implements `YieldableError`.
  *
- * **Example** (Creating and checking an IllegalArgumentError)
- *
- * ```ts
- * import { Cause } from "effect"
- *
- * const error = new Cause.IllegalArgumentError("Expected positive number")
- * console.log(error._tag)    // "IllegalArgumentError"
- * console.log(error.message) // "Expected positive number"
- * ```
- *
  * @category errors
  * @since 4.0.0
  */
@@ -1589,11 +1512,10 @@ export interface IllegalArgumentError extends YieldableError {
  *
  * **Example** (Creating an IllegalArgumentError)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const error = new Cause.IllegalArgumentError("Invalid argument")
- * console.log(error.message) // "Invalid argument"
+ * new Cause.IllegalArgumentError("Invalid argument").message // => "Invalid argument"
  * ```
  *
  * @category constructors
@@ -1605,11 +1527,11 @@ export declare const IllegalArgumentError: new (message?: string) => IllegalArgu
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isExceededCapacityError(new Cause.ExceededCapacityError())) // true
- * console.log(Cause.isExceededCapacityError("nope")) // false
+ * Cause.isExceededCapacityError(new Cause.ExceededCapacityError()) // => true
+ * Cause.isExceededCapacityError("nope") // => false
  * ```
  *
  * @category guards
@@ -1636,16 +1558,6 @@ export declare const ExceededCapacityErrorTypeId: "~effect/Cause/ExceededCapacit
  *
  * Implements `YieldableError`.
  *
- * **Example** (Creating and checking an ExceededCapacityError)
- *
- * ```ts
- * import { Cause } from "effect"
- *
- * const error = new Cause.ExceededCapacityError("Queue full")
- * console.log(error._tag)    // "ExceededCapacityError"
- * console.log(error.message) // "Queue full"
- * ```
- *
  * @category errors
  * @since 4.0.0
  */
@@ -1662,11 +1574,10 @@ export interface ExceededCapacityError extends YieldableError {
  *
  * **Example** (Creating an ExceededCapacityError)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const error = new Cause.ExceededCapacityError("Queue full")
- * console.log(error.message) // "Queue full"
+ * new Cause.ExceededCapacityError("Queue full").message // => "Queue full"
  * ```
  *
  * @see {@link isExceededCapacityError} for checking unknown values
@@ -1688,15 +1599,14 @@ export declare const AsyncFiberErrorTypeId: "~effect/Cause/AsyncFiberError";
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
- * import { Cause } from "effect"
- * import type { Fiber } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect } from "effect"
  *
- * declare const fiber: Fiber.Fiber<unknown, unknown>
+ * const fiber = Effect.runFork(Effect.void)
  *
  * const error = new Cause.AsyncFiberError(fiber)
- * console.log(Cause.isAsyncFiberError(error)) // true
- * console.log(Cause.isAsyncFiberError("nope")) // false
+ * Cause.isAsyncFiberError(error) // => true
+ * Cause.isAsyncFiberError("nope") // => false
  * ```
  *
  * @category guards
@@ -1718,15 +1628,14 @@ export declare const isAsyncFiberError: (u: unknown) => u is AsyncFiberError;
  *
  * **Example** (Accessing the fiber)
  *
- * ```ts
- * import { Cause } from "effect"
- * import type { Fiber } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect } from "effect"
  *
- * declare const fiber: Fiber.Fiber<unknown, unknown>
+ * const fiber = Effect.runFork(Effect.void)
  *
- * const error = new Cause.AsyncFiberError(fiber)
- * console.log(error._tag) // "AsyncFiberError"
- * console.log(error.fiber === fiber) // true
+ * const value = new Cause.AsyncFiberError(fiber)
+ * const isSameFiber = value.fiber === fiber
+ * isSameFiber // => true
  * ```
  *
  * @category errors
@@ -1748,14 +1657,12 @@ export interface AsyncFiberError extends YieldableError {
  *
  * **Example** (Creating an AsyncFiberError)
  *
- * ```ts
- * import { Cause } from "effect"
- * import type { Fiber } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect } from "effect"
  *
- * declare const fiber: Fiber.Fiber<unknown, unknown>
+ * const fiber = Effect.runFork(Effect.void)
  *
- * const error = new Cause.AsyncFiberError(fiber)
- * console.log(error.message) // "An asynchronous Effect was executed with Effect.runSync"
+ * new Cause.AsyncFiberError(fiber).message // => "An asynchronous Effect was executed with Effect.runSync"
  * ```
  *
  * @see {@link isAsyncFiberError} for checking unknown values
@@ -1776,11 +1683,11 @@ export declare const UnknownErrorTypeId: "~effect/Cause/UnknownError";
  *
  * **Example** (Checking the runtime type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * console.log(Cause.isUnknownError(new Cause.UnknownError("x"))) // true
- * console.log(Cause.isUnknownError("nope")) // false
+ * Cause.isUnknownError(new Cause.UnknownError("x")) // => true
+ * Cause.isUnknownError("nope") // => false
  * ```
  *
  * @category guards
@@ -1796,16 +1703,6 @@ export declare const isUnknownError: (u: unknown) => u is UnknownError;
  * typed error. The original value is stored in the `cause` property inherited
  * from `Error`. Implements `YieldableError`.
  *
- * **Example** (Creating and checking an UnknownError)
- *
- * ```ts
- * import { Cause } from "effect"
- *
- * const error = new Cause.UnknownError("original", "Something unknown")
- * console.log(error._tag)    // "UnknownError"
- * console.log(error.message) // "Something unknown"
- * ```
- *
  * @category errors
  * @since 4.0.0
  */
@@ -1820,11 +1717,10 @@ export interface UnknownError extends YieldableError {
  *
  * **Example** (Creating an UnknownError)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause } from "effect"
  *
- * const error = new Cause.UnknownError({ raw: true }, "Unexpected value")
- * console.log(error.message) // "Unexpected value"
+ * new Cause.UnknownError({ raw: true }, "Unexpected value").message // => "Unexpected value"
  * ```
  *
  * @category constructors
@@ -1850,15 +1746,13 @@ export declare const UnknownError: new (cause: unknown, message?: string) => Unk
  *
  * **Example** (Annotating a cause)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Context } from "effect"
  *
  * class RequestId extends Context.Service<RequestId, string>()("RequestId") {}
  *
- * const cause = Cause.fail("error")
- * const annotated = Cause.annotate(cause, Context.make(RequestId, "req-1"))
- *
- * console.log(Context.getOrUndefined(Cause.annotations(annotated), RequestId)) // "req-1"
+ * const annotated = Cause.annotate(Cause.fail("error"), Context.make(RequestId, "req-1"))
+ * Context.getOrUndefined(Cause.annotations(annotated), RequestId) // => "req-1"
  * ```
  *
  * @see {@link annotations} for reading merged annotations from a cause
@@ -1887,15 +1781,13 @@ export declare const annotate: {
      *
      * **Example** (Annotating a cause)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause, Context } from "effect"
      *
      * class RequestId extends Context.Service<RequestId, string>()("RequestId") {}
      *
-     * const cause = Cause.fail("error")
-     * const annotated = Cause.annotate(cause, Context.make(RequestId, "req-1"))
-     *
-     * console.log(Context.getOrUndefined(Cause.annotations(annotated), RequestId)) // "req-1"
+     * const annotated = Cause.annotate(Cause.fail("error"), Context.make(RequestId, "req-1"))
+     * Context.getOrUndefined(Cause.annotations(annotated), RequestId) // => "req-1"
      * ```
      *
      * @see {@link annotations} for reading merged annotations from a cause
@@ -1926,15 +1818,13 @@ export declare const annotate: {
      *
      * **Example** (Annotating a cause)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause, Context } from "effect"
      *
      * class RequestId extends Context.Service<RequestId, string>()("RequestId") {}
      *
-     * const cause = Cause.fail("error")
-     * const annotated = Cause.annotate(cause, Context.make(RequestId, "req-1"))
-     *
-     * console.log(Context.getOrUndefined(Cause.annotations(annotated), RequestId)) // "req-1"
+     * const annotated = Cause.annotate(Cause.fail("error"), Context.make(RequestId, "req-1"))
+     * Context.getOrUndefined(Cause.annotations(annotated), RequestId) // => "req-1"
      * ```
      *
      * @see {@link annotations} for reading merged annotations from a cause
@@ -1957,7 +1847,7 @@ export declare const annotate: {
  *
  * **Example** (Reading reason annotations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Context } from "effect"
  *
  * class RequestId extends Context.Service<RequestId, string>()("RequestId") {}
@@ -1965,7 +1855,7 @@ export declare const annotate: {
  * const reason = Cause.makeFailReason("error")
  * const annotated = reason.annotate(Context.make(RequestId, "req-1"))
  *
- * console.log(Context.getOrUndefined(Cause.reasonAnnotations(annotated), RequestId)) // "req-1"
+ * Context.getOrUndefined(Cause.reasonAnnotations(annotated), RequestId) // => "req-1"
  * ```
  *
  * @see {@link annotations} — merged annotations from all reasons in a cause
@@ -1988,7 +1878,7 @@ export declare const reasonAnnotations: <E>(self: Reason<E>) => Context.Context<
  *
  * **Example** (Reading merged annotations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Context } from "effect"
  *
  * class RequestId extends Context.Service<RequestId, string>()("RequestId") {}
@@ -1998,7 +1888,7 @@ export declare const reasonAnnotations: <E>(self: Reason<E>) => Context.Context<
  *   Context.make(RequestId, "req-1")
  * )
  *
- * console.log(Context.getOrUndefined(Cause.annotations(cause), RequestId)) // "req-1"
+ * Context.getOrUndefined(Cause.annotations(cause), RequestId) // => "req-1"
  * ```
  *
  * @see {@link reasonAnnotations} — annotations from a single reason
@@ -2026,7 +1916,7 @@ declare const StackTrace_base: Context.ServiceClass<StackTrace, "effect/Cause/St
  * @see {@link annotations} for reading merged annotations from a cause
  * @see {@link InterruptorStackTrace} for the interrupt-specific stack-frame annotation
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export declare class StackTrace extends StackTrace_base {
@@ -2049,7 +1939,7 @@ declare const InterruptorStackTrace_base: Context.ServiceClass<InterruptorStackT
  * @see {@link reasonAnnotations} for reading annotations from a single reason
  * @see {@link annotate} for attaching annotations to a cause
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export declare class InterruptorStackTrace extends InterruptorStackTrace_base {