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

package/dist/PubSub.d.ts

@@ -29,26 +29,27 @@ declare const TypeId = "~effect/PubSub";
  *
  * **Example** (Publishing and subscribing to messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   // Create a bounded PubSub with capacity 10
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Subscribe and consume messages
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish messages
- *     yield* PubSub.publish(pubsub, "Hello")
- *     yield* PubSub.publish(pubsub, "World")
+ *   // Publish messages
+ *   yield* PubSub.publish(pubsub, "Hello")
+ *   yield* PubSub.publish(pubsub, "World")
  *
- *     const message1 = yield* PubSub.take(subscription)
- *     const message2 = yield* PubSub.take(subscription)
- *     console.log(message1, message2) // "Hello", "World"
- *   }))
- * })
+ *   const message1 = yield* PubSub.take(subscription)
+ *   const message2 = yield* PubSub.take(subscription)
+ *   return [message1, message2]
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["Hello", "World"]
  * ```
  *
  * @category models
@@ -126,6 +127,7 @@ export declare namespace PubSub {
         take(): A | undefined;
         takeN(n: number): Array<A>;
         takeAll(): Array<A>;
+        close(): void;
         readonly remaining: number;
     }
     /**
@@ -168,31 +170,28 @@ declare const SubscriptionTypeId = "~effect/PubSub/Subscription";
  *
  * **Example** (Taking messages from a subscription)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Subscribe within a scope for automatic cleanup
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription: PubSub.Subscription<string> = yield* PubSub.subscribe(
- *       pubsub
- *     )
- *
- *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
- *
- *     // Take individual messages
- *     const message = yield* PubSub.take(subscription)
- *     console.log(message) // "msg1"
- *
- *     // Take multiple messages
- *     const messages = yield* PubSub.takeUpTo(subscription, 1)
- *     console.log(messages) // ["msg2"]
- *     const allMessages = yield* PubSub.takeAll(subscription)
- *     console.log(allMessages) // ["msg3"]
- *   }))
- * })
+ *   const subscription: PubSub.Subscription<string> = yield* PubSub.subscribe(pubsub)
+ *
+ *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+ *
+ *   // Take individual messages
+ *   const message = yield* PubSub.take(subscription)
+ *
+ *   // Take multiple messages
+ *   const messages = yield* PubSub.takeUpTo(subscription, 1)
+ *   const allMessages = yield* PubSub.takeAll(subscription)
+ *   return { message, messages, allMessages }
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => { message: "msg1", messages: ["msg2"], allMessages: ["msg3"] }
  * ```
  *
  * @category models
@@ -216,7 +215,7 @@ export interface Subscription<out A> extends Pipeable {
  *
  * **Example** (Creating a PubSub with a custom strategy)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -227,8 +226,13 @@ export interface Subscription<out A> extends Pipeable {
  *   })
  *
  *   // Use the created PubSub
- *   yield* PubSub.publish(pubsub, "Hello")
+ *   const published = yield* PubSub.publish(pubsub, "Hello")
+ *   yield* PubSub.shutdown(pubsub)
+ *   return published
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => true
  * ```
  *
  * @category constructors
@@ -251,7 +255,7 @@ export declare const make: <A>(options: {
  *
  * **Example** (Creating a bounded PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -263,7 +267,15 @@ export declare const make: <A>(options: {
  *     capacity: 100,
  *     replay: 10 // Last 10 messages replayed to new subscribers
  *   })
+ *
+ *   const capacities = [PubSub.capacity(pubsub), PubSub.capacity(pubsubWithReplay)]
+ *   yield* PubSub.shutdown(pubsub)
+ *   yield* PubSub.shutdown(pubsubWithReplay)
+ *   return capacities
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => [100, 100]
  * ```
  *
  * @category constructors
@@ -283,33 +295,27 @@ export declare const bounded: <A>(capacity: number | {
  *
  * **Example** (Dropping messages when full)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   // Create dropping PubSub that drops new messages when full
  *   const pubsub = yield* PubSub.dropping<string>(3)
  *
- *   // With replay buffer for late subscribers
- *   const pubsubWithReplay = yield* PubSub.dropping<string>({
- *     capacity: 3,
- *     replay: 5
- *   })
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   // Fill the PubSub and see dropping behavior
+ *   yield* PubSub.publish(pubsub, "msg1") // succeeds
+ *   yield* PubSub.publish(pubsub, "msg2") // succeeds
+ *   yield* PubSub.publish(pubsub, "msg3") // succeeds
+ *   const dropped = yield* PubSub.publish(pubsub, "msg4") // returns false (dropped)
  *
- *     // Fill the PubSub and see dropping behavior
- *     yield* PubSub.publish(pubsub, "msg1") // succeeds
- *     yield* PubSub.publish(pubsub, "msg2") // succeeds
- *     yield* PubSub.publish(pubsub, "msg3") // succeeds
- *     const dropped = yield* PubSub.publish(pubsub, "msg4") // returns false (dropped)
- *     console.log("Message dropped:", !dropped) // true
+ *   const messages = yield* PubSub.takeAll(subscription)
+ *   return { dropped: !dropped, messages }
+ * }))
  *
- *     const messages = yield* PubSub.takeAll(subscription)
- *     console.log(messages) // ["msg1", "msg2", "msg3"]
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { dropped: true, messages: ["msg1", "msg2", "msg3"] }
  * ```
  *
  * @category constructors
@@ -329,32 +335,26 @@ export declare const dropping: <A>(capacity: number | {
  *
  * **Example** (Sliding old messages when full)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   // Create sliding PubSub that evicts old messages when full
  *   const pubsub = yield* PubSub.sliding<string>(3)
  *
- *   // With replay buffer
- *   const pubsubWithReplay = yield* PubSub.sliding<string>({
- *     capacity: 3,
- *     replay: 2
- *   })
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   // Fill and overflow the PubSub
+ *   yield* PubSub.publish(pubsub, "msg1")
+ *   yield* PubSub.publish(pubsub, "msg2")
+ *   yield* PubSub.publish(pubsub, "msg3")
+ *   yield* PubSub.publish(pubsub, "msg4") // "msg1" is evicted
  *
- *     // Fill and overflow the PubSub
- *     yield* PubSub.publish(pubsub, "msg1")
- *     yield* PubSub.publish(pubsub, "msg2")
- *     yield* PubSub.publish(pubsub, "msg3")
- *     yield* PubSub.publish(pubsub, "msg4") // "msg1" is evicted
+ *   return yield* PubSub.takeAll(subscription)
+ * }))
  *
- *     const messages = yield* PubSub.takeAll(subscription)
- *     console.log(messages) // ["msg2", "msg3", "msg4"]
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["msg2", "msg3", "msg4"]
  * ```
  *
  * @category constructors
@@ -369,30 +369,25 @@ export declare const sliding: <A>(capacity: number | {
  *
  * **Example** (Creating an unbounded PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   // Create unbounded PubSub
  *   const pubsub = yield* PubSub.unbounded<string>()
  *
- *   // With replay buffer for late subscribers
- *   const pubsubWithReplay = yield* PubSub.unbounded<string>({
- *     replay: 10
- *   })
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   // Can publish unlimited messages
+ *   for (let i = 0; i < 3; i++) {
+ *     yield* PubSub.publish(pubsub, `message-${i}`)
+ *   }
  *
- *     // Can publish unlimited messages
- *     for (let i = 0; i < 3; i++) {
- *       yield* PubSub.publish(pubsub, `message-${i}`)
- *     }
+ *   return yield* PubSub.takeAll(subscription)
+ * }))
  *
- *     const message = yield* PubSub.take(subscription)
- *     console.log("First message:", message) // "message-0"
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["message-0", "message-1", "message-2"]
  * ```
  *
  * @category constructors
@@ -461,18 +456,17 @@ export declare const makeAtomicUnbounded: <A>(options?: {
  *
  * **Example** (Getting PubSub capacity)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(100)
- *   const cap = PubSub.capacity(pubsub)
- *   console.log("PubSub capacity:", cap) // 100
- *
  *   const unboundedPubsub = yield* PubSub.unbounded<string>()
- *   const unboundedCap = PubSub.capacity(unboundedPubsub)
- *   console.log("Unbounded capacity:", unboundedCap) // Number.MAX_SAFE_INTEGER
+ *   return [PubSub.capacity(pubsub), PubSub.capacity(unboundedPubsub)]
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => [100, Number.MAX_SAFE_INTEGER]
  * ```
  *
  * @category getters
@@ -490,29 +484,28 @@ export declare const capacity: <A>(self: PubSub<A>) => number;
  *
  * **Example** (Getting PubSub size)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Initially empty
  *   const initialSize = yield* PubSub.size(pubsub)
- *   console.log("Initial size:", initialSize) // 0
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish some messages for the active subscription
- *     yield* PubSub.publish(pubsub, "msg1")
- *     yield* PubSub.publish(pubsub, "msg2")
+ *   // Publish some messages for the active subscription
+ *   yield* PubSub.publish(pubsub, "msg1")
+ *   yield* PubSub.publish(pubsub, "msg2")
  *
- *     const afterPublish = yield* PubSub.size(pubsub)
- *     console.log("After publishing:", afterPublish) // 2
+ *   const afterPublish = yield* PubSub.size(pubsub)
+ *   const messages = yield* PubSub.takeAll(subscription)
+ *   return { initialSize, afterPublish, messages }
+ * }))
  *
- *     yield* PubSub.takeAll(subscription)
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { initialSize: 0, afterPublish: 2, messages: ["msg1", "msg2"] }
  * ```
  *
  * @category getters
@@ -535,14 +528,16 @@ export declare const size: <A>(self: PubSub<A>) => Effect.Effect<number>;
  *
  * **Example** (Reading size synchronously)
  *
- * ```ts
- * import { PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, PubSub } from "effect"
  *
- * // Unsafe synchronous size check
- * declare const pubsub: PubSub.PubSub<string>
+ * const program = Effect.gen(function*() {
+ *   const pubsub = yield* PubSub.bounded<string>(2)
+ *   return PubSub.sizeUnsafe(pubsub)
+ * })
  *
- * const size = PubSub.sizeUnsafe(pubsub)
- * console.log("Current size:", size)
+ * const actual = await Effect.runPromise(program)
+ * actual // => 0
  * ```
  *
  * @category getters
@@ -558,29 +553,28 @@ export declare const sizeUnsafe: <A>(self: PubSub<A>) => number;
  *
  * **Example** (Checking whether a PubSub is full)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(2)
  *
  *   // Initially not full
  *   const initiallyFull = yield* PubSub.isFull(pubsub)
- *   console.log("Initially full:", initiallyFull) // false
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Fill the PubSub for the active subscription
- *     yield* PubSub.publish(pubsub, "msg1")
- *     yield* PubSub.publish(pubsub, "msg2")
+ *   // Fill the PubSub for the active subscription
+ *   yield* PubSub.publish(pubsub, "msg1")
+ *   yield* PubSub.publish(pubsub, "msg2")
  *
- *     const nowFull = yield* PubSub.isFull(pubsub)
- *     console.log("Now full:", nowFull) // true
+ *   const nowFull = yield* PubSub.isFull(pubsub)
+ *   const messages = yield* PubSub.takeAll(subscription)
+ *   return { initiallyFull, nowFull, messages }
+ * }))
  *
- *     yield* PubSub.takeAll(subscription)
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { initiallyFull: false, nowFull: true, messages: ["msg1", "msg2"] }
  * ```
  *
  * @category predicates
@@ -592,28 +586,27 @@ export declare const isFull: <A>(self: PubSub<A>) => Effect.Effect<boolean>;
  *
  * **Example** (Checking whether a PubSub is empty)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Initially empty
  *   const initiallyEmpty = yield* PubSub.isEmpty(pubsub)
- *   console.log("Initially empty:", initiallyEmpty) // true
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish a message for the active subscription
- *     yield* PubSub.publish(pubsub, "Hello")
+ *   // Publish a message for the active subscription
+ *   yield* PubSub.publish(pubsub, "Hello")
  *
- *     const nowEmpty = yield* PubSub.isEmpty(pubsub)
- *     console.log("Now empty:", nowEmpty) // false
+ *   const nowEmpty = yield* PubSub.isEmpty(pubsub)
+ *   const message = yield* PubSub.take(subscription)
+ *   return { initiallyEmpty, nowEmpty, message }
+ * }))
  *
- *     yield* PubSub.take(subscription)
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { initiallyEmpty: true, nowEmpty: false, message: "Hello" }
  * ```
  *
  * @category predicates
@@ -632,7 +625,7 @@ export declare const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<boolean>;
  *
  * **Example** (Shutting down a PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -642,12 +635,14 @@ export declare const isEmpty: <A>(self: PubSub<A>) => Effect.Effect<boolean>;
  *   yield* PubSub.shutdown(pubsub)
  *
  *   const isShutdown = yield* PubSub.isShutdown(pubsub)
- *   console.log("Is shutdown:", isShutdown) // true
  *
  *   // Publishing after shutdown returns false
  *   const published = yield* PubSub.publish(pubsub, "msg1")
- *   console.log("Published after shutdown:", published) // false
+ *   return { isShutdown, published }
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => { isShutdown: true, published: false }
  * ```
  *
  * @category lifecycle
@@ -660,7 +655,7 @@ export declare const shutdown: <A>(self: PubSub<A>) => Effect.Effect<void>;
  *
  * **Example** (Checking whether a PubSub is shut down)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -668,14 +663,16 @@ export declare const shutdown: <A>(self: PubSub<A>) => Effect.Effect<void>;
  *
  *   // Initially not shutdown
  *   const initiallyShutdown = yield* PubSub.isShutdown(pubsub)
- *   console.log("Initially shutdown:", initiallyShutdown) // false
  *
  *   // Shutdown the PubSub
  *   yield* PubSub.shutdown(pubsub)
  *
  *   const nowShutdown = yield* PubSub.isShutdown(pubsub)
- *   console.log("Now shutdown:", nowShutdown) // true
+ *   return [initiallyShutdown, nowShutdown]
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => [false, true]
  * ```
  *
  * @category predicates
@@ -693,18 +690,18 @@ export declare const isShutdown: <A>(self: PubSub<A>) => Effect.Effect<boolean>;
  *
  * **Example** (Checking shutdown synchronously)
  *
- * ```ts
- * import { PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, PubSub } from "effect"
  *
- * declare const pubsub: PubSub.PubSub<string>
+ * const program = Effect.gen(function*() {
+ *   const pubsub = yield* PubSub.bounded<string>(2)
+ *   const initiallyShutdown = PubSub.isShutdownUnsafe(pubsub)
+ *   yield* PubSub.shutdown(pubsub)
+ *   return [initiallyShutdown, PubSub.isShutdownUnsafe(pubsub)]
+ * })
  *
- * // Unsafe synchronous shutdown check
- * const isDown = PubSub.isShutdownUnsafe(pubsub)
- * if (isDown) {
- *   console.log("PubSub is shutdown, cannot publish")
- * } else {
- *   console.log("PubSub is active")
- * }
+ * const actual = await Effect.runPromise(program)
+ * actual // => [false, true]
  * ```
  *
  * @category predicates
@@ -718,7 +715,7 @@ export declare const isShutdownUnsafe: <A>(self: PubSub<A>) => boolean;
  *
  * **Example** (Waiting for shutdown)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -728,19 +725,19 @@ export declare const isShutdownUnsafe: <A>(self: PubSub<A>) => boolean;
  *   const waiterFiber = yield* Effect.forkChild(
  *     Effect.gen(function*() {
  *       yield* PubSub.awaitShutdown(pubsub)
- *       console.log("PubSub has been shutdown!")
+ *       return "PubSub has been shutdown!"
  *     })
  *   )
  *
- *   // Do some work...
- *   yield* Effect.sleep("100 millis")
- *
  *   // Shutdown the PubSub
  *   yield* PubSub.shutdown(pubsub)
  *
  *   // The waiter will now complete
- *   yield* Fiber.join(waiterFiber)
+ *   return yield* Fiber.join(waiterFiber)
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => "PubSub has been shutdown!"
  * ```
  *
  * @category lifecycle
@@ -764,24 +761,24 @@ export declare const awaitShutdown: <A>(self: PubSub<A>) => Effect.Effect<void>;
  *
  * **Example** (Publishing a message)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Publish a message
  *   const published = yield* PubSub.publish(pubsub, "Hello World")
- *   console.log("Message published:", published) // true
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     yield* PubSub.publish(pubsub, "Hello")
- *     const message = yield* PubSub.take(subscription)
- *     console.log("Received:", message) // "Hello"
- *   }))
- * })
+ *   yield* PubSub.publish(pubsub, "Hello")
+ *   const message = yield* PubSub.take(subscription)
+ *   return { published, message }
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => { published: true, message: "Hello" }
  * ```
  *
  * @see {@link publishUnsafe} for a synchronous non-blocking attempt that does not run effectful surplus handling
@@ -807,24 +804,24 @@ export declare const publish: {
      *
      * **Example** (Publishing a message)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
      *   // Publish a message
      *   const published = yield* PubSub.publish(pubsub, "Hello World")
-     *   console.log("Message published:", published) // true
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     yield* PubSub.publish(pubsub, "Hello")
-     *     const message = yield* PubSub.take(subscription)
-     *     console.log("Received:", message) // "Hello"
-     *   }))
-     * })
+     *   yield* PubSub.publish(pubsub, "Hello")
+     *   const message = yield* PubSub.take(subscription)
+     *   return { published, message }
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => { published: true, message: "Hello" }
      * ```
      *
      * @see {@link publishUnsafe} for a synchronous non-blocking attempt that does not run effectful surplus handling
@@ -850,24 +847,24 @@ export declare const publish: {
      *
      * **Example** (Publishing a message)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
      *   // Publish a message
      *   const published = yield* PubSub.publish(pubsub, "Hello World")
-     *   console.log("Message published:", published) // true
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     yield* PubSub.publish(pubsub, "Hello")
-     *     const message = yield* PubSub.take(subscription)
-     *     console.log("Received:", message) // "Hello"
-     *   }))
-     * })
+     *   yield* PubSub.publish(pubsub, "Hello")
+     *   const message = yield* PubSub.take(subscription)
+     *   return { published, message }
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => { published: true, message: "Hello" }
      * ```
      *
      * @see {@link publishUnsafe} for a synchronous non-blocking attempt that does not run effectful surplus handling
@@ -894,24 +891,16 @@ export declare const publish: {
  *
  * **Example** (Publishing without suspending)
  *
- * ```ts
- * import { PubSub } from "effect"
- *
- * declare const pubsub: PubSub.PubSub<string>
+ * ```ts import.meta.vitest
+ * import { Effect, PubSub } from "effect"
  *
- * // Unsafe synchronous publish (non-blocking)
- * const published = PubSub.publishUnsafe(pubsub, "Hello")
- * if (published) {
- *   console.log("Message published successfully")
- * } else {
- *   console.log("Message dropped (PubSub full or shutdown)")
- * }
+ * const program = Effect.gen(function*() {
+ *   const pubsub = yield* PubSub.bounded<string>(2)
+ *   return PubSub.publishUnsafe(pubsub, "Hello")
+ * })
  *
- * // Useful for scenarios where you don't want to suspend
- * const messages = ["msg1", "msg2", "msg3"]
- * const publishedCount =
- *   messages.filter((msg) => PubSub.publishUnsafe(pubsub, msg)).length
- * console.log(`Published ${publishedCount} out of ${messages.length} messages`)
+ * const actual = await Effect.runPromise(program)
+ * actual // => true
  * ```
  *
  * @see {@link publish} for effectful publishing that honors the configured surplus strategy
@@ -937,24 +926,16 @@ export declare const publishUnsafe: {
      *
      * **Example** (Publishing without suspending)
      *
-     * ```ts
-     * import { PubSub } from "effect"
-     *
-     * declare const pubsub: PubSub.PubSub<string>
+     * ```ts import.meta.vitest
+     * import { Effect, PubSub } from "effect"
      *
-     * // Unsafe synchronous publish (non-blocking)
-     * const published = PubSub.publishUnsafe(pubsub, "Hello")
-     * if (published) {
-     *   console.log("Message published successfully")
-     * } else {
-     *   console.log("Message dropped (PubSub full or shutdown)")
-     * }
+     * const program = Effect.gen(function*() {
+     *   const pubsub = yield* PubSub.bounded<string>(2)
+     *   return PubSub.publishUnsafe(pubsub, "Hello")
+     * })
      *
-     * // Useful for scenarios where you don't want to suspend
-     * const messages = ["msg1", "msg2", "msg3"]
-     * const publishedCount =
-     *   messages.filter((msg) => PubSub.publishUnsafe(pubsub, msg)).length
-     * console.log(`Published ${publishedCount} out of ${messages.length} messages`)
+     * const actual = await Effect.runPromise(program)
+     * actual // => true
      * ```
      *
      * @see {@link publish} for effectful publishing that honors the configured surplus strategy
@@ -980,24 +961,16 @@ export declare const publishUnsafe: {
      *
      * **Example** (Publishing without suspending)
      *
-     * ```ts
-     * import { PubSub } from "effect"
-     *
-     * declare const pubsub: PubSub.PubSub<string>
+     * ```ts import.meta.vitest
+     * import { Effect, PubSub } from "effect"
      *
-     * // Unsafe synchronous publish (non-blocking)
-     * const published = PubSub.publishUnsafe(pubsub, "Hello")
-     * if (published) {
-     *   console.log("Message published successfully")
-     * } else {
-     *   console.log("Message dropped (PubSub full or shutdown)")
-     * }
+     * const program = Effect.gen(function*() {
+     *   const pubsub = yield* PubSub.bounded<string>(2)
+     *   return PubSub.publishUnsafe(pubsub, "Hello")
+     * })
      *
-     * // Useful for scenarios where you don't want to suspend
-     * const messages = ["msg1", "msg2", "msg3"]
-     * const publishedCount =
-     *   messages.filter((msg) => PubSub.publishUnsafe(pubsub, msg)).length
-     * console.log(`Published ${publishedCount} out of ${messages.length} messages`)
+     * const actual = await Effect.runPromise(program)
+     * actual // => true
      * ```
      *
      * @see {@link publish} for effectful publishing that honors the configured surplus strategy
@@ -1013,37 +986,30 @@ export declare const publishUnsafe: {
  *
  * **Example** (Publishing multiple messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Publish multiple messages at once
- *   const messages = ["Hello", "World", "from", "Effect"]
- *   const allPublished = yield* PubSub.publishAll(pubsub, messages)
- *   console.log("All messages published:", allPublished) // true
+ *   const allPublished = yield* PubSub.publishAll(pubsub, ["Hello", "World", "from", "Effect"])
  *
  *   // With a smaller capacity and an active subscription
  *   const smallPubsub = yield* PubSub.bounded<string>(2)
- *   const manyMessages = ["msg1", "msg2", "msg3", "msg4"]
- *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(smallPubsub)
- *
- *     // Will suspend until space becomes available for all messages
- *     const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, manyMessages))
+ *   const subscription = yield* PubSub.subscribe(smallPubsub)
  *
- *     const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
- *     console.log("First batch:", firstBatch) // ["msg1", "msg2"]
+ *   // Will suspend until space becomes available for all messages
+ *   const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, ["msg1", "msg2", "msg3", "msg4"]))
  *
- *     const result = yield* Fiber.join(fiber)
- *     console.log("All messages eventually published:", result) // true
+ *   const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
+ *   const result = yield* Fiber.join(fiber)
+ *   const secondBatch = yield* PubSub.takeAll(subscription)
+ *   return { allPublished, firstBatch, result, secondBatch }
+ * }))
  *
- *     const secondBatch = yield* PubSub.takeAll(subscription)
- *     console.log("Second batch:", secondBatch) // ["msg3", "msg4"]
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { allPublished: true, firstBatch: ["msg1", "msg2"], result: true, secondBatch: ["msg3", "msg4"] }
  * ```
  *
  * @category publishing
@@ -1056,37 +1022,30 @@ export declare const publishAll: {
      *
      * **Example** (Publishing multiple messages)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Fiber, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
      *   // Publish multiple messages at once
-     *   const messages = ["Hello", "World", "from", "Effect"]
-     *   const allPublished = yield* PubSub.publishAll(pubsub, messages)
-     *   console.log("All messages published:", allPublished) // true
+     *   const allPublished = yield* PubSub.publishAll(pubsub, ["Hello", "World", "from", "Effect"])
      *
      *   // With a smaller capacity and an active subscription
      *   const smallPubsub = yield* PubSub.bounded<string>(2)
-     *   const manyMessages = ["msg1", "msg2", "msg3", "msg4"]
-     *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(smallPubsub)
-     *
-     *     // Will suspend until space becomes available for all messages
-     *     const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, manyMessages))
+     *   const subscription = yield* PubSub.subscribe(smallPubsub)
      *
-     *     const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
-     *     console.log("First batch:", firstBatch) // ["msg1", "msg2"]
+     *   // Will suspend until space becomes available for all messages
+     *   const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, ["msg1", "msg2", "msg3", "msg4"]))
      *
-     *     const result = yield* Fiber.join(fiber)
-     *     console.log("All messages eventually published:", result) // true
+     *   const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
+     *   const result = yield* Fiber.join(fiber)
+     *   const secondBatch = yield* PubSub.takeAll(subscription)
+     *   return { allPublished, firstBatch, result, secondBatch }
+     * }))
      *
-     *     const secondBatch = yield* PubSub.takeAll(subscription)
-     *     console.log("Second batch:", secondBatch) // ["msg3", "msg4"]
-     *   }))
-     * })
+     * const actual = await Effect.runPromise(program)
+     * actual // => { allPublished: true, firstBatch: ["msg1", "msg2"], result: true, secondBatch: ["msg3", "msg4"] }
      * ```
      *
      * @category publishing
@@ -1099,37 +1058,30 @@ export declare const publishAll: {
      *
      * **Example** (Publishing multiple messages)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Fiber, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
      *   // Publish multiple messages at once
-     *   const messages = ["Hello", "World", "from", "Effect"]
-     *   const allPublished = yield* PubSub.publishAll(pubsub, messages)
-     *   console.log("All messages published:", allPublished) // true
+     *   const allPublished = yield* PubSub.publishAll(pubsub, ["Hello", "World", "from", "Effect"])
      *
      *   // With a smaller capacity and an active subscription
      *   const smallPubsub = yield* PubSub.bounded<string>(2)
-     *   const manyMessages = ["msg1", "msg2", "msg3", "msg4"]
+     *   const subscription = yield* PubSub.subscribe(smallPubsub)
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(smallPubsub)
+     *   // Will suspend until space becomes available for all messages
+     *   const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, ["msg1", "msg2", "msg3", "msg4"]))
      *
-     *     // Will suspend until space becomes available for all messages
-     *     const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, manyMessages))
+     *   const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
+     *   const result = yield* Fiber.join(fiber)
+     *   const secondBatch = yield* PubSub.takeAll(subscription)
+     *   return { allPublished, firstBatch, result, secondBatch }
+     * }))
      *
-     *     const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
-     *     console.log("First batch:", firstBatch) // ["msg1", "msg2"]
-     *
-     *     const result = yield* Fiber.join(fiber)
-     *     console.log("All messages eventually published:", result) // true
-     *
-     *     const secondBatch = yield* PubSub.takeAll(subscription)
-     *     console.log("Second batch:", secondBatch) // ["msg3", "msg4"]
-     *   }))
-     * })
+     * const actual = await Effect.runPromise(program)
+     * actual // => { allPublished: true, firstBatch: ["msg1", "msg2"], result: true, secondBatch: ["msg3", "msg4"] }
      * ```
      *
      * @category publishing
@@ -1144,14 +1096,14 @@ export declare const publishAll: {
  *
  * **Example** (Subscribing to messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
  *   // Subscribe within a scope for automatic cleanup
- *   yield* Effect.scoped(Effect.gen(function*() {
+ *   const first = yield* Effect.scoped(Effect.gen(function*() {
  *     const subscription = yield* PubSub.subscribe(pubsub)
  *
  *     // Publish some messages
@@ -1161,25 +1113,28 @@ export declare const publishAll: {
  *     // Take messages one by one
  *     const msg1 = yield* PubSub.take(subscription)
  *     const msg2 = yield* PubSub.take(subscription)
- *     console.log(msg1, msg2) // "Hello", "World"
  *
  *     // Subscription is automatically cleaned up when scope exits
+ *     return [msg1, msg2]
  *   }))
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
+ *   const second = yield* Effect.scoped(Effect.gen(function*() {
  *     const sub1 = yield* PubSub.subscribe(pubsub)
  *     const sub2 = yield* PubSub.subscribe(pubsub)
  *
  *     // Multiple subscribers can receive the same messages
  *     yield* PubSub.publish(pubsub, "Broadcast")
  *
- *     const [msg1, msg2] = yield* Effect.all([
+ *     return yield* Effect.all([
  *       PubSub.take(sub1),
  *       PubSub.take(sub2)
  *     ])
- *     console.log("Both received:", msg1, msg2) // "Broadcast", "Broadcast"
  *   }))
+ *   return [first, second]
  * })
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => [["Hello", "World"], ["Broadcast", "Broadcast"]]
  * ```
  *
  * @category subscriptions
@@ -1192,28 +1147,26 @@ export declare const subscribe: <A>(self: PubSub<A>) => Effect.Effect<Subscripti
  *
  * **Example** (Taking a message)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Start a fiber to take a message (will suspend)
- *     const takeFiber = yield* Effect.forkChild(
- *       PubSub.take(subscription)
- *     )
+ *   // Start a fiber to take a message (will suspend)
+ *   const takeFiber = yield* Effect.forkChild(PubSub.take(subscription))
  *
- *     // Publish a message
- *     yield* PubSub.publish(pubsub, "Hello")
+ *   // Publish a message
+ *   yield* PubSub.publish(pubsub, "Hello")
  *
- *     // The take will now complete
- *     const message = yield* Fiber.join(takeFiber)
- *     console.log("Received:", message) // "Hello"
- *   }))
- * })
+ *   // The take will now complete
+ *   return yield* Fiber.join(takeFiber)
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => "Hello"
  * ```
  *
  * @category subscriptions
@@ -1226,23 +1179,23 @@ export declare const take: <A>(self: Subscription<A>) => Effect.Effect<A>;
  *
  * **Example** (Taking all available messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish multiple messages
- *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+ *   // Publish multiple messages
+ *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
  *
- *     // Take all available messages at once
- *     const allMessages = yield* PubSub.takeAll(subscription)
- *     console.log("All messages:", allMessages) // ["msg1", "msg2", "msg3"]
- *   }))
- * })
+ *   // Take all available messages at once
+ *   return yield* PubSub.takeAll(subscription)
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["msg1", "msg2", "msg3"]
  * ```
  *
  * @category subscriptions
@@ -1254,31 +1207,30 @@ export declare const takeAll: <A>(self: Subscription<A>) => Effect.Effect<Arr.No
  *
  * **Example** (Taking up to a maximum number of messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish multiple messages
- *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
+ *   // Publish multiple messages
+ *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
  *
- *     // Take up to 3 messages
- *     const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
- *     console.log("Up to 3:", upTo3) // ["msg1", "msg2", "msg3"]
+ *   // Take up to 3 messages
+ *   const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
  *
- *     // Take up to 5 more (only 2 remaining)
- *     const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
- *     console.log("Up to 5:", upTo5) // ["msg4", "msg5"]
+ *   // Take up to 5 more (only 2 remaining)
+ *   const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
  *
- *     // No more messages available
- *     const noMore = yield* PubSub.takeUpTo(subscription, 10)
- *     console.log("No more:", noMore) // []
- *   }))
- * })
+ *   // No more messages available
+ *   const noMore = yield* PubSub.takeUpTo(subscription, 10)
+ *   return [upTo3, upTo5, noMore]
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => [["msg1", "msg2", "msg3"], ["msg4", "msg5"], []]
  * ```
  *
  * @category subscriptions
@@ -1290,31 +1242,30 @@ export declare const takeUpTo: {
      *
      * **Example** (Taking up to a maximum number of messages)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     // Publish multiple messages
-     *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
+     *   // Publish multiple messages
+     *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
      *
-     *     // Take up to 3 messages
-     *     const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
-     *     console.log("Up to 3:", upTo3) // ["msg1", "msg2", "msg3"]
+     *   // Take up to 3 messages
+     *   const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
      *
-     *     // Take up to 5 more (only 2 remaining)
-     *     const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
-     *     console.log("Up to 5:", upTo5) // ["msg4", "msg5"]
+     *   // Take up to 5 more (only 2 remaining)
+     *   const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
      *
-     *     // No more messages available
-     *     const noMore = yield* PubSub.takeUpTo(subscription, 10)
-     *     console.log("No more:", noMore) // []
-     *   }))
-     * })
+     *   // No more messages available
+     *   const noMore = yield* PubSub.takeUpTo(subscription, 10)
+     *   return [upTo3, upTo5, noMore]
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => [["msg1", "msg2", "msg3"], ["msg4", "msg5"], []]
      * ```
      *
      * @category subscriptions
@@ -1326,31 +1277,30 @@ export declare const takeUpTo: {
      *
      * **Example** (Taking up to a maximum number of messages)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     // Publish multiple messages
-     *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
+     *   // Publish multiple messages
+     *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
      *
-     *     // Take up to 3 messages
-     *     const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
-     *     console.log("Up to 3:", upTo3) // ["msg1", "msg2", "msg3"]
+     *   // Take up to 3 messages
+     *   const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
      *
-     *     // Take up to 5 more (only 2 remaining)
-     *     const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
-     *     console.log("Up to 5:", upTo5) // ["msg4", "msg5"]
+     *   // Take up to 5 more (only 2 remaining)
+     *   const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
      *
-     *     // No more messages available
-     *     const noMore = yield* PubSub.takeUpTo(subscription, 10)
-     *     console.log("No more:", noMore) // []
-     *   }))
-     * })
+     *   // No more messages available
+     *   const noMore = yield* PubSub.takeUpTo(subscription, 10)
+     *   return [upTo3, upTo5, noMore]
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => [["msg1", "msg2", "msg3"], ["msg4", "msg5"], []]
      * ```
      *
      * @category subscriptions
@@ -1364,28 +1314,26 @@ export declare const takeUpTo: {
  *
  * **Example** (Taking between a minimum and maximum)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Start taking between 2 and 5 messages (will suspend)
- *     const takeFiber = yield* Effect.forkChild(
- *       PubSub.takeBetween(subscription, 2, 5)
- *     )
+ *   // Start taking between 2 and 5 messages (will suspend)
+ *   const takeFiber = yield* Effect.forkChild(PubSub.takeBetween(subscription, 2, 5))
  *
- *     // Publish 3 messages
- *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+ *   // Publish 3 messages
+ *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
  *
- *     // Now the take will complete with 3 messages
- *     const messages = yield* Fiber.join(takeFiber)
- *     console.log("Between 2-5:", messages) // ["msg1", "msg2", "msg3"]
- *   }))
- * })
+ *   // Now the take will complete with 3 messages
+ *   return yield* Fiber.join(takeFiber)
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["msg1", "msg2", "msg3"]
  * ```
  *
  * @category subscriptions
@@ -1398,28 +1346,26 @@ export declare const takeBetween: {
      *
      * **Example** (Taking between a minimum and maximum)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Fiber, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     // Start taking between 2 and 5 messages (will suspend)
-     *     const takeFiber = yield* Effect.forkChild(
-     *       PubSub.takeBetween(subscription, 2, 5)
-     *     )
+     *   // Start taking between 2 and 5 messages (will suspend)
+     *   const takeFiber = yield* Effect.forkChild(PubSub.takeBetween(subscription, 2, 5))
      *
-     *     // Publish 3 messages
-     *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+     *   // Publish 3 messages
+     *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
      *
-     *     // Now the take will complete with 3 messages
-     *     const messages = yield* Fiber.join(takeFiber)
-     *     console.log("Between 2-5:", messages) // ["msg1", "msg2", "msg3"]
-     *   }))
-     * })
+     *   // Now the take will complete with 3 messages
+     *   return yield* Fiber.join(takeFiber)
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => ["msg1", "msg2", "msg3"]
      * ```
      *
      * @category subscriptions
@@ -1432,28 +1378,26 @@ export declare const takeBetween: {
      *
      * **Example** (Taking between a minimum and maximum)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Fiber, PubSub } from "effect"
      *
-     * const program = Effect.gen(function*() {
+     * const program = Effect.scoped(Effect.gen(function*() {
      *   const pubsub = yield* PubSub.bounded<string>(10)
      *
-     *   yield* Effect.scoped(Effect.gen(function*() {
-     *     const subscription = yield* PubSub.subscribe(pubsub)
+     *   const subscription = yield* PubSub.subscribe(pubsub)
      *
-     *     // Start taking between 2 and 5 messages (will suspend)
-     *     const takeFiber = yield* Effect.forkChild(
-     *       PubSub.takeBetween(subscription, 2, 5)
-     *     )
+     *   // Start taking between 2 and 5 messages (will suspend)
+     *   const takeFiber = yield* Effect.forkChild(PubSub.takeBetween(subscription, 2, 5))
      *
-     *     // Publish 3 messages
-     *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+     *   // Publish 3 messages
+     *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
      *
-     *     // Now the take will complete with 3 messages
-     *     const messages = yield* Fiber.join(takeFiber)
-     *     console.log("Between 2-5:", messages) // ["msg1", "msg2", "msg3"]
-     *   }))
-     * })
+     *   // Now the take will complete with 3 messages
+     *   return yield* Fiber.join(takeFiber)
+     * }))
+     *
+     * const actual = await Effect.runPromise(program)
+     * actual // => ["msg1", "msg2", "msg3"]
      * ```
      *
      * @category subscriptions
@@ -1477,29 +1421,29 @@ export declare const takeBetween: {
  *
  * **Example** (Checking remaining messages)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
+ * const program = Effect.scoped(Effect.gen(function*() {
  *   const pubsub = yield* PubSub.bounded<string>(10)
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish some messages
- *     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
+ *   // Publish some messages
+ *   yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3"])
  *
- *     // Check how many messages are available
- *     const count = yield* PubSub.remaining(subscription)
- *     console.log("Messages available:", count) // 3
+ *   // Check how many messages are available
+ *   const count = yield* PubSub.remaining(subscription)
  *
- *     // Take one message
- *     yield* PubSub.take(subscription)
+ *   // Take one message
+ *   const message = yield* PubSub.take(subscription)
  *
- *     const remaining = yield* PubSub.remaining(subscription)
- *     console.log("Messages remaining:", remaining) // 2
- *   }))
- * })
+ *   const remaining = yield* PubSub.remaining(subscription)
+ *   return { count, message, remaining }
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => { count: 3, message: "msg1", remaining: 2 }
  * ```
  *
  * @see {@link remainingUnsafe} for a synchronous check that reports shutdown as `Option.none()`
@@ -1519,23 +1463,17 @@ export declare const remaining: <A>(self: Subscription<A>) => Effect.Effect<numb
  *
  * **Example** (Checking remaining messages synchronously)
  *
- * ```ts
- * import { PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Option, PubSub } from "effect"
  *
- * declare const subscription: PubSub.Subscription<string>
- *
- * // Unsafe synchronous check for remaining messages
- * const remainingOption = PubSub.remainingUnsafe(subscription)
- * if (remainingOption._tag === "Some") {
- *   console.log("Messages available:", remainingOption.value)
- * } else {
- *   console.log("Subscription is shutdown")
- * }
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   const pubsub = yield* PubSub.bounded<string>(2)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
+ *   return PubSub.remainingUnsafe(subscription)
+ * }))
  *
- * // Useful for polling or batching scenarios
- * if (remainingOption._tag === "Some" && remainingOption.value > 10) {
- *   // Process messages in batch
- * }
+ * const actual = await Effect.runPromise(program)
+ * actual // => Option.some(0)
  * ```
  *
  * @see {@link remaining} for the effectful variant that interrupts on shutdown
@@ -1598,34 +1536,30 @@ export declare class BackPressureStrategy<in out A> implements PubSub.Strategy<A
  *
  * **Example** (Applying a dropping strategy)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
- *   // Create PubSub with dropping strategy
- *   const pubsub = yield* PubSub.dropping<string>(2)
- *
- *   // Or explicitly create with dropping strategy
- *   const customPubsub = yield* PubSub.make<string>({
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   // Explicitly create a PubSub with a dropping strategy
+ *   const pubsub = yield* PubSub.make<string>({
  *     atomicPubSub: () => PubSub.makeAtomicBounded(2),
  *     strategy: () => new PubSub.DroppingStrategy()
  *   })
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Fill the PubSub
- *     const pub1 = yield* PubSub.publish(pubsub, "msg1") // true
- *     const pub2 = yield* PubSub.publish(pubsub, "msg2") // true
- *     const pub3 = yield* PubSub.publish(pubsub, "msg3") // false (dropped)
+ *   // Fill the PubSub
+ *   const pub1 = yield* PubSub.publish(pubsub, "msg1") // true
+ *   const pub2 = yield* PubSub.publish(pubsub, "msg2") // true
+ *   const pub3 = yield* PubSub.publish(pubsub, "msg3") // false (dropped)
  *
- *     console.log("Publication results:", [pub1, pub2, pub3]) // [true, true, false]
+ *   // Subscribers will only see the first two messages
+ *   const messages = yield* PubSub.takeAll(subscription)
+ *   return { published: [pub1, pub2, pub3], messages }
+ * }))
  *
- *     // Subscribers will only see the first two messages
- *     const messages = yield* PubSub.takeAll(subscription)
- *     console.log("Received messages:", messages) // ["msg1", "msg2"]
- *   }))
- * })
+ * const actual = await Effect.runPromise(program)
+ * actual // => { published: [true, true, false], messages: ["msg1", "msg2"] }
  * ```
  *
  * @category models
@@ -1657,33 +1591,30 @@ export declare class DroppingStrategy<in out A> implements PubSub.Strategy<A> {
  *
  * **Example** (Applying a sliding strategy)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
- * const program = Effect.gen(function*() {
- *   // Create PubSub with sliding strategy
- *   const pubsub = yield* PubSub.sliding<string>(2)
- *
- *   // Or explicitly create with sliding strategy
- *   const customPubsub = yield* PubSub.make<string>({
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   // Explicitly create a PubSub with a sliding strategy
+ *   const pubsub = yield* PubSub.make<string>({
  *     atomicPubSub: () => PubSub.makeAtomicBounded(2),
  *     strategy: () => new PubSub.SlidingStrategy()
  *   })
  *
- *   yield* Effect.scoped(Effect.gen(function*() {
- *     const subscription = yield* PubSub.subscribe(pubsub)
+ *   const subscription = yield* PubSub.subscribe(pubsub)
  *
- *     // Publish messages that exceed capacity
- *     yield* PubSub.publish(pubsub, "msg1") // stored
- *     yield* PubSub.publish(pubsub, "msg2") // stored
- *     yield* PubSub.publish(pubsub, "msg3") // "msg1" evicted, "msg3" stored
- *     yield* PubSub.publish(pubsub, "msg4") // "msg2" evicted, "msg4" stored
+ *   // Publish messages that exceed capacity
+ *   yield* PubSub.publish(pubsub, "msg1") // stored
+ *   yield* PubSub.publish(pubsub, "msg2") // stored
+ *   yield* PubSub.publish(pubsub, "msg3") // "msg1" evicted, "msg3" stored
+ *   yield* PubSub.publish(pubsub, "msg4") // "msg2" evicted, "msg4" stored
  *
- *     // Subscribers will see the most recent messages
- *     const messages = yield* PubSub.takeAll(subscription)
- *     console.log("Recent messages:", messages) // ["msg3", "msg4"]
- *   }))
- * })
+ *   // Subscribers will see the most recent messages
+ *   return yield* PubSub.takeAll(subscription)
+ * }))
+ *
+ * const actual = await Effect.runPromise(program)
+ * actual // => ["msg3", "msg4"]
  * ```
  *
  * @category models