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

package/dist/Deferred.d.ts

@@ -27,36 +27,23 @@ declare const TypeId = "~effect/Deferred";
  *
  * **Example** (Creating a Deferred for inter-fiber communication)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect, Fiber } from "effect"
  *
- * // Create and use a Deferred for inter-fiber communication
  * const program = Effect.gen(function*() {
- *   // Create a Deferred that will hold a string value
  *   const deferred: Deferred.Deferred<string> = yield* Deferred.make<string>()
- *
- *   // Fork a fiber that will set the deferred value
  *   const producer = yield* Effect.forkChild(
  *     Effect.gen(function*() {
- *       yield* Effect.sleep("100 millis")
  *       yield* Deferred.succeed(deferred, "Hello, World!")
  *     })
  *   )
  *
- *   // Fork a fiber that will await the deferred value
- *   const consumer = yield* Effect.forkChild(
- *     Effect.gen(function*() {
- *       const value = yield* Deferred.await(deferred)
- *       console.log("Received:", value)
- *       return value
- *     })
- *   )
- *
- *   // Wait for both fibers to complete
+ *   const consumer = yield* Effect.forkChild(Deferred.await(deferred))
  *   yield* Fiber.join(producer)
- *   const result = yield* Fiber.join(consumer)
- *   return result
+ *   return yield* Fiber.join(consumer)
  * })
+ *
+ * await Effect.runPromise(program) // => "Hello, World!"
  * ```
  *
  * @category models
@@ -121,11 +108,11 @@ export declare namespace Deferred {
  *
  * **Example** (Creating a Deferred unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred } from "effect"
  *
  * const deferred = Deferred.makeUnsafe<number>()
- * console.log(deferred)
+ * Deferred.isDoneUnsafe(deferred) // => false
  * ```
  *
  * @category unsafe
@@ -141,15 +128,16 @@ export declare const makeUnsafe: <A, E = never>() => Deferred<A, E>;
  *
  * **Example** (Creating a Deferred)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   yield* Deferred.succeed(deferred, 42)
- *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return yield* Deferred.await(deferred)
  * })
+ *
+ * await Effect.runPromise(program) // => 42
  * ```
  *
  * @category constructors
@@ -173,16 +161,17 @@ export {
  *
  * **Example** (Awaiting a Deferred value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   yield* Deferred.succeed(deferred, 42)
  *
- *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return yield* Deferred.await(deferred)
  * })
+ *
+ * await Effect.runPromise(program) // => 42
  * ```
  *
  * @see {@link complete} for completing from an effect and memoizing its result
@@ -208,17 +197,17 @@ _await as await };
  *
  * **Example** (Completing a Deferred from an effect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const completed = yield* Deferred.complete(deferred, Effect.succeed(42))
- *   console.log(completed) // true
- *
  *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return [completed, value]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, 42]
  * ```
  *
  * @see {@link completeWith} for storing an effect directly without memoizing its result
@@ -243,17 +232,17 @@ export declare const complete: {
      *
      * **Example** (Completing a Deferred from an effect)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const completed = yield* Deferred.complete(deferred, Effect.succeed(42))
-     *   console.log(completed) // true
-     *
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return [completed, value]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
      * @see {@link completeWith} for storing an effect directly without memoizing its result
@@ -278,17 +267,17 @@ export declare const complete: {
      *
      * **Example** (Completing a Deferred from an effect)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const completed = yield* Deferred.complete(deferred, Effect.succeed(42))
-     *   console.log(completed) // true
-     *
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return [completed, value]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
      * @see {@link completeWith} for storing an effect directly without memoizing its result
@@ -318,17 +307,17 @@ export declare const complete: {
  *
  * **Example** (Completing a Deferred with an effect)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const completed = yield* Deferred.completeWith(deferred, Effect.succeed(42))
- *   console.log(completed) // true
- *
  *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return [completed, value]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, 42]
  * ```
  *
  * @see {@link complete} for running an effect once and sharing its result
@@ -358,17 +347,17 @@ export declare const completeWith: {
      *
      * **Example** (Completing a Deferred with an effect)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const completed = yield* Deferred.completeWith(deferred, Effect.succeed(42))
-     *   console.log(completed) // true
-     *
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return [completed, value]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
      * @see {@link complete} for running an effect once and sharing its result
@@ -398,17 +387,17 @@ export declare const completeWith: {
      *
      * **Example** (Completing a Deferred with an effect)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const completed = yield* Deferred.completeWith(deferred, Effect.succeed(42))
-     *   console.log(completed) // true
-     *
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return [completed, value]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
      * @see {@link complete} for running an effect once and sharing its result
@@ -434,16 +423,16 @@ export declare const completeWith: {
  *
  * **Example** (Completing a Deferred with an Exit)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   yield* Deferred.done(deferred, Exit.succeed(42))
- *
- *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return yield* Effect.exit(Deferred.await(deferred))
  * })
+ *
+ * await Effect.runPromise(program) // => Exit.succeed(42)
  * ```
  *
  * @see {@link complete} for completing from an effect and memoizing its result
@@ -470,16 +459,16 @@ export declare const done: {
      *
      * **Example** (Completing a Deferred with an Exit)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.done(deferred, Exit.succeed(42))
-     *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Effect.exit(Deferred.await(deferred))
      * })
+     *
+     * await Effect.runPromise(program) // => Exit.succeed(42)
      * ```
      *
      * @see {@link complete} for completing from an effect and memoizing its result
@@ -506,16 +495,16 @@ export declare const done: {
      *
      * **Example** (Completing a Deferred with an Exit)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.done(deferred, Exit.succeed(42))
-     *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Effect.exit(Deferred.await(deferred))
      * })
+     *
+     * await Effect.runPromise(program) // => Exit.succeed(42)
      * ```
      *
      * @see {@link complete} for completing from an effect and memoizing its result
@@ -543,14 +532,17 @@ export declare const done: {
  *
  * **Example** (Failing a Deferred with an error)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number, string>()
  *   const success = yield* Deferred.fail(deferred, "Operation failed")
- *   console.log(success) // true
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.fail("Operation failed")]
  * ```
  *
  * @category completion
@@ -572,14 +564,17 @@ export declare const fail: {
      *
      * **Example** (Failing a Deferred with an error)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
      *   const success = yield* Deferred.fail(deferred, "Operation failed")
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.fail("Operation failed")]
      * ```
      *
      * @category completion
@@ -601,14 +596,17 @@ export declare const fail: {
      *
      * **Example** (Failing a Deferred with an error)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
      *   const success = yield* Deferred.fail(deferred, "Operation failed")
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.fail("Operation failed")]
      * ```
      *
      * @category completion
@@ -633,14 +631,17 @@ export declare const fail: {
  *
  * **Example** (Failing a Deferred with a lazy error)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number, string>()
  *   const success = yield* Deferred.failSync(deferred, () => "Lazy error")
- *   console.log(success) // true
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.fail("Lazy error")]
  * ```
  *
  * @category completion
@@ -664,14 +665,17 @@ export declare const failSync: {
      *
      * **Example** (Failing a Deferred with a lazy error)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
      *   const success = yield* Deferred.failSync(deferred, () => "Lazy error")
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.fail("Lazy error")]
      * ```
      *
      * @category completion
@@ -695,14 +699,17 @@ export declare const failSync: {
      *
      * **Example** (Failing a Deferred with a lazy error)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
      *   const success = yield* Deferred.failSync(deferred, () => "Lazy error")
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.fail("Lazy error")]
      * ```
      *
      * @category completion
@@ -725,17 +732,17 @@ export declare const failSync: {
  *
  * **Example** (Failing a Deferred with a Cause)
  *
- * ```ts
- * import { Cause, Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number, string>()
- *   const success = yield* Deferred.failCause(
- *     deferred,
- *     Cause.fail("Operation failed")
- *   )
- *   console.log(success) // true
+ *   const success = yield* Deferred.failCause(deferred, Cause.fail("Operation failed"))
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Operation failed"))]
  * ```
  *
  * @category completion
@@ -757,17 +764,17 @@ export declare const failCause: {
      *
      * **Example** (Failing a Deferred with a Cause)
      *
-     * ```ts
-     * import { Cause, Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Cause, Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
-     *   const success = yield* Deferred.failCause(
-     *     deferred,
-     *     Cause.fail("Operation failed")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.failCause(deferred, Cause.fail("Operation failed"))
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Operation failed"))]
      * ```
      *
      * @category completion
@@ -789,17 +796,17 @@ export declare const failCause: {
      *
      * **Example** (Failing a Deferred with a Cause)
      *
-     * ```ts
-     * import { Cause, Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Cause, Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
-     *   const success = yield* Deferred.failCause(
-     *     deferred,
-     *     Cause.fail("Operation failed")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.failCause(deferred, Cause.fail("Operation failed"))
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Operation failed"))]
      * ```
      *
      * @category completion
@@ -824,17 +831,17 @@ export declare const failCause: {
  *
  * **Example** (Failing a Deferred with a lazy Cause)
  *
- * ```ts
- * import { Cause, Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number, string>()
- *   const success = yield* Deferred.failCauseSync(
- *     deferred,
- *     () => Cause.fail("Lazy error")
- *   )
- *   console.log(success) // true
+ *   const success = yield* Deferred.failCauseSync(deferred, () => Cause.fail("Lazy error"))
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Lazy error"))]
  * ```
  *
  * @category completion
@@ -858,17 +865,17 @@ export declare const failCauseSync: {
      *
      * **Example** (Failing a Deferred with a lazy Cause)
      *
-     * ```ts
-     * import { Cause, Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Cause, Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
-     *   const success = yield* Deferred.failCauseSync(
-     *     deferred,
-     *     () => Cause.fail("Lazy error")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.failCauseSync(deferred, () => Cause.fail("Lazy error"))
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Lazy error"))]
      * ```
      *
      * @category completion
@@ -892,17 +899,17 @@ export declare const failCauseSync: {
      *
      * **Example** (Failing a Deferred with a lazy Cause)
      *
-     * ```ts
-     * import { Cause, Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Cause, Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number, string>()
-     *   const success = yield* Deferred.failCauseSync(
-     *     deferred,
-     *     () => Cause.fail("Lazy error")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.failCauseSync(deferred, () => Cause.fail("Lazy error"))
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Lazy error"))]
      * ```
      *
      * @category completion
@@ -925,17 +932,18 @@ export declare const failCauseSync: {
  *
  * **Example** (Killing a Deferred with a defect)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
+ * const defect = new Error("Something went wrong")
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
- *   const success = yield* Deferred.die(
- *     deferred,
- *     new Error("Something went wrong")
- *   )
- *   console.log(success) // true
+ *   const success = yield* Deferred.die(deferred, defect)
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.die(defect)]
  * ```
  *
  * @category completion
@@ -957,17 +965,18 @@ export declare const die: {
      *
      * **Example** (Killing a Deferred with a defect)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
+     * const defect = new Error("Something went wrong")
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
-     *   const success = yield* Deferred.die(
-     *     deferred,
-     *     new Error("Something went wrong")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.die(deferred, defect)
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.die(defect)]
      * ```
      *
      * @category completion
@@ -989,17 +998,18 @@ export declare const die: {
      *
      * **Example** (Killing a Deferred with a defect)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
+     * const defect = new Error("Something went wrong")
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
-     *   const success = yield* Deferred.die(
-     *     deferred,
-     *     new Error("Something went wrong")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.die(deferred, defect)
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.die(defect)]
      * ```
      *
      * @category completion
@@ -1023,17 +1033,18 @@ export declare const die: {
  *
  * **Example** (Killing a Deferred with a lazy defect)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
+ * const defect = new Error("Lazy error")
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
- *   const success = yield* Deferred.dieSync(
- *     deferred,
- *     () => new Error("Lazy error")
- *   )
- *   console.log(success) // true
+ *   const success = yield* Deferred.dieSync(deferred, () => defect)
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.die(defect)]
  * ```
  *
  * @category completion
@@ -1056,17 +1067,18 @@ export declare const dieSync: {
      *
      * **Example** (Killing a Deferred with a lazy defect)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
+     * const defect = new Error("Lazy error")
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
-     *   const success = yield* Deferred.dieSync(
-     *     deferred,
-     *     () => new Error("Lazy error")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.dieSync(deferred, () => defect)
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.die(defect)]
      * ```
      *
      * @category completion
@@ -1089,17 +1101,18 @@ export declare const dieSync: {
      *
      * **Example** (Killing a Deferred with a lazy defect)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
+     * const defect = new Error("Lazy error")
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
-     *   const success = yield* Deferred.dieSync(
-     *     deferred,
-     *     () => new Error("Lazy error")
-     *   )
-     *   console.log(success) // true
+     *   const success = yield* Deferred.dieSync(deferred, () => defect)
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.die(defect)]
      * ```
      *
      * @category completion
@@ -1123,14 +1136,19 @@ export declare const dieSync: {
  *
  * **Example** (Interrupting a Deferred)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const success = yield* Deferred.interrupt(deferred)
- *   console.log(success) // true
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit] as const
  * })
+ *
+ * const [success, exit] = await Effect.runPromise(program)
+ * success // => true
+ * Exit.hasInterrupts(exit) // => true
  * ```
  *
  * @category completion
@@ -1153,14 +1171,17 @@ export declare const interrupt: <A, E>(self: Deferred<A, E>) => Effect<boolean>;
  *
  * **Example** (Interrupting a Deferred with a fiber id)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Exit } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const success = yield* Deferred.interruptWith(deferred, 42)
- *   console.log(success) // true
+ *   const exit = yield* Effect.exit(Deferred.await(deferred))
+ *   return [success, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.interrupt(42)]
  * ```
  *
  * @category completion
@@ -1183,14 +1204,17 @@ export declare const interruptWith: {
      *
      * **Example** (Interrupting a Deferred with a fiber id)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const success = yield* Deferred.interruptWith(deferred, 42)
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.interrupt(42)]
      * ```
      *
      * @category completion
@@ -1213,14 +1237,17 @@ export declare const interruptWith: {
      *
      * **Example** (Interrupting a Deferred with a fiber id)
      *
-     * ```ts
-     * import { Deferred, Effect } from "effect"
+     * ```ts import.meta.vitest
+     * import { Deferred, Effect, Exit } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   const success = yield* Deferred.interruptWith(deferred, 42)
-     *   console.log(success) // true
+     *   const exit = yield* Effect.exit(Deferred.await(deferred))
+     *   return [success, exit]
      * })
+     *
+     * await Effect.runPromise(program) // => [true, Exit.interrupt(42)]
      * ```
      *
      * @category completion
@@ -1238,21 +1265,21 @@ export declare const interruptWith: {
  *
  * **Example** (Checking Deferred completion)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const beforeCompletion = yield* Deferred.isDone(deferred)
- *   console.log(beforeCompletion) // false
- *
  *   yield* Deferred.succeed(deferred, 42)
  *   const afterCompletion = yield* Deferred.isDone(deferred)
- *   console.log(afterCompletion) // true
+ *   return [beforeCompletion, afterCompletion]
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category getters
+ * @category predicates
  * @since 2.0.0
  */
 export declare const isDone: <A, E>(self: Deferred<A, E>) => Effect<boolean>;
@@ -1267,7 +1294,7 @@ export declare const isDone: <A, E>(self: Deferred<A, E>) => Effect<boolean>;
  * @see {@link isDone} for checking completion inside `Effect`
  * @see {@link poll} for reading the completed effect when available
  *
- * @category getters
+ * @category predicates
  * @since 4.0.0
  */
 export declare const isDoneUnsafe: <A, E>(self: Deferred<A, E>) => boolean;
@@ -1283,18 +1310,19 @@ export declare const isDoneUnsafe: <A, E>(self: Deferred<A, E>) => boolean;
  *
  * **Example** (Polling Deferred completion)
  *
- * ```ts
- * import { Deferred, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Deferred, Effect, Option } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const beforeCompletion = yield* Deferred.poll(deferred)
- *   console.log(beforeCompletion._tag === "None") // true
- *
  *   yield* Deferred.succeed(deferred, 42)
  *   const afterCompletion = yield* Deferred.poll(deferred)
- *   console.log(afterCompletion._tag === "Some") // true
+ *   const afterValue = yield* Effect.transposeOption(afterCompletion)
+ *   return [beforeCompletion, afterValue]
  * })
+ *
+ * await Effect.runPromise(program) // => [Option.none(), Option.some(42)]
  * ```
  *
  * @category getters
@@ -1316,16 +1344,17 @@ export declare function poll<A, E>(self: Deferred<A, E>): Effect<Option.Option<E
  *
  * **Example** (Completing a Deferred with a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   yield* Deferred.succeed(deferred, 42)
  *
- *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return yield* Deferred.await(deferred)
  * })
+ *
+ * await Effect.runPromise(program) // => 42
  * ```
  *
  * @category completion
@@ -1347,16 +1376,17 @@ export declare const succeed: {
      *
      * **Example** (Completing a Deferred with a value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.succeed(deferred, 42)
      *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Deferred.await(deferred)
      * })
+     *
+     * await Effect.runPromise(program) // => 42
      * ```
      *
      * @category completion
@@ -1378,16 +1408,17 @@ export declare const succeed: {
      *
      * **Example** (Completing a Deferred with a value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.succeed(deferred, 42)
      *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Deferred.await(deferred)
      * })
+     *
+     * await Effect.runPromise(program) // => 42
      * ```
      *
      * @category completion
@@ -1412,16 +1443,16 @@ export declare const succeed: {
  *
  * **Example** (Completing a Deferred with a lazy value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   yield* Deferred.sync(deferred, () => 42)
- *
- *   const value = yield* Deferred.await(deferred)
- *   console.log(value) // 42
+ *   return yield* Deferred.await(deferred)
  * })
+ *
+ * await Effect.runPromise(program) // => 42
  * ```
  *
  * @category completion
@@ -1445,16 +1476,16 @@ export declare const sync: {
      *
      * **Example** (Completing a Deferred with a lazy value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.sync(deferred, () => 42)
-     *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Deferred.await(deferred)
      * })
+     *
+     * await Effect.runPromise(program) // => 42
      * ```
      *
      * @category completion
@@ -1478,16 +1509,16 @@ export declare const sync: {
      *
      * **Example** (Completing a Deferred with a lazy value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const deferred = yield* Deferred.make<number>()
      *   yield* Deferred.sync(deferred, () => 42)
-     *
-     *   const value = yield* Deferred.await(deferred)
-     *   console.log(value) // 42
+     *   return yield* Deferred.await(deferred)
      * })
+     *
+     * await Effect.runPromise(program) // => 42
      * ```
      *
      * @category completion
@@ -1512,12 +1543,11 @@ export declare const sync: {
  *
  * **Example** (Completing a Deferred unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
  * const deferred = Deferred.makeUnsafe<number>()
- * const success = Deferred.doneUnsafe(deferred, Effect.succeed(42))
- * console.log(success) // true
+ * Deferred.doneUnsafe(deferred, Effect.succeed(42)) // => true
  * ```
  *
  * @category unsafe
@@ -1542,33 +1572,22 @@ export declare const doneUnsafe: <A, E>(self: Deferred<A, E>, effect: Effect<A,
  *
  * **Example** (Completing a Deferred from an effect result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Deferred, Effect } from "effect"
  *
- * // Define an effect that succeeds
  * const successEffect = Effect.succeed(42)
  *
  * const program = Effect.gen(function*() {
- *   // Create a deferred
  *   const deferred = yield* Deferred.make<number, string>()
- *
- *   // Complete the deferred using the successEffect
  *   const isCompleted = yield* Deferred.into(successEffect, deferred)
- *
- *   // Access the value of the deferred
  *   const value = yield* Deferred.await(deferred)
- *   console.log(value)
- *
- *   return isCompleted
+ *   return [isCompleted, value]
  * })
  *
- * Effect.runPromise(program).then(console.log)
- * // Output:
- * // 42
- * // true
+ * await Effect.runPromise(program) // => [true, 42]
  * ```
  *
- * @category Synchronization Utilities
+ * @category completion
  * @since 4.0.0
  */
 export declare const into: {
@@ -1590,33 +1609,22 @@ export declare const into: {
      *
      * **Example** (Completing a Deferred from an effect result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
-     * // Define an effect that succeeds
      * const successEffect = Effect.succeed(42)
      *
      * const program = Effect.gen(function*() {
-     *   // Create a deferred
      *   const deferred = yield* Deferred.make<number, string>()
-     *
-     *   // Complete the deferred using the successEffect
      *   const isCompleted = yield* Deferred.into(successEffect, deferred)
-     *
-     *   // Access the value of the deferred
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value)
-     *
-     *   return isCompleted
+     *   return [isCompleted, value]
      * })
      *
-     * Effect.runPromise(program).then(console.log)
-     * // Output:
-     * // 42
-     * // true
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
-     * @category Synchronization Utilities
+     * @category completion
      * @since 4.0.0
      */
     <A, E>(deferred: Deferred<A, E>): <R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
@@ -1638,33 +1646,22 @@ export declare const into: {
      *
      * **Example** (Completing a Deferred from an effect result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Deferred, Effect } from "effect"
      *
-     * // Define an effect that succeeds
      * const successEffect = Effect.succeed(42)
      *
      * const program = Effect.gen(function*() {
-     *   // Create a deferred
      *   const deferred = yield* Deferred.make<number, string>()
-     *
-     *   // Complete the deferred using the successEffect
      *   const isCompleted = yield* Deferred.into(successEffect, deferred)
-     *
-     *   // Access the value of the deferred
      *   const value = yield* Deferred.await(deferred)
-     *   console.log(value)
-     *
-     *   return isCompleted
+     *   return [isCompleted, value]
      * })
      *
-     * Effect.runPromise(program).then(console.log)
-     * // Output:
-     * // 42
-     * // true
+     * await Effect.runPromise(program) // => [true, 42]
      * ```
      *
-     * @category Synchronization Utilities
+     * @category completion
      * @since 4.0.0
      */
     <A, E, R>(self: Effect<A, E, R>, deferred: Deferred<A, E>): Effect<boolean, never, R>;