effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/PubSub.ts

@@ -35,26 +35,27 @@ 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
@@ -139,6 +140,7 @@ export declare namespace PubSub {
     take(): A | undefined
     takeN(n: number): Array<A>
     takeAll(): Array<A>
+    close(): void
     readonly remaining: number
   }
 
@@ -204,31 +206,28 @@ 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
@@ -253,7 +252,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*() {
@@ -264,8 +263,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
@@ -301,7 +305,7 @@ export const make = <A>(
  *
  * **Example** (Creating a bounded PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -313,7 +317,15 @@ export const make = <A>(
  *     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
@@ -340,33 +352,27 @@ export const bounded = <A>(
  *
  * **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
@@ -393,32 +399,26 @@ export const dropping = <A>(
  *
  * **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
@@ -440,30 +440,25 @@ export const sliding = <A>(
  *
  * **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
@@ -552,18 +547,17 @@ export 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
@@ -582,29 +576,28 @@ export const capacity = <A>(self: PubSub<A>): number => self.pubsub.capacity
  *
  * **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
@@ -627,14 +620,16 @@ export const size = <A>(self: PubSub<A>): Effect.Effect<number> => Effect.sync((
  *
  * **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
@@ -656,29 +651,28 @@ export 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
@@ -692,28 +686,27 @@ export 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
@@ -733,7 +726,7 @@ export const isEmpty = <A>(self: PubSub<A>): Effect.Effect<boolean> => Effect.ma
  *
  * **Example** (Shutting down a PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -743,12 +736,14 @@ export const isEmpty = <A>(self: PubSub<A>): Effect.Effect<boolean> => Effect.ma
  *   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
@@ -770,7 +765,7 @@ export 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*() {
@@ -778,14 +773,16 @@ export 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
@@ -804,18 +801,18 @@ export const isShutdown = <A>(self: PubSub<A>): Effect.Effect<boolean> => Effect
  *
  * **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
@@ -830,7 +827,7 @@ export const isShutdownUnsafe = <A>(self: PubSub<A>): boolean => self.shutdownFl
  *
  * **Example** (Waiting for shutdown)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -840,19 +837,19 @@ export const isShutdownUnsafe = <A>(self: PubSub<A>): boolean => self.shutdownFl
  *   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
@@ -877,24 +874,24 @@ export const awaitShutdown = <A>(self: PubSub<A>): Effect.Effect<void> => self.s
  *
  * **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
@@ -920,24 +917,24 @@ export 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
@@ -963,24 +960,24 @@ export 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
@@ -1025,24 +1022,16 @@ export 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
@@ -1068,24 +1057,16 @@ export 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
@@ -1111,24 +1092,16 @@ export 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
@@ -1152,37 +1125,30 @@ export 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
@@ -1195,37 +1161,30 @@ export 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
@@ -1238,37 +1197,30 @@ export 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
@@ -1300,14 +1252,14 @@ export 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
@@ -1317,25 +1269,28 @@ export 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
@@ -1367,6 +1322,7 @@ const unsubscribe = <A>(self: Subscription<A>): Effect.Effect<void> =>
           Effect.sync(() => {
             self.subscribers.delete(self.subscription)
             self.subscription.unsubscribe()
+            self.replayWindow.close()
             self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers)
           })
         ),
@@ -1382,28 +1338,26 @@ const unsubscribe = <A>(self: Subscription<A>): Effect.Effect<void> =>
  *
  * **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
@@ -1435,23 +1389,23 @@ export 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
@@ -1506,31 +1460,30 @@ const pollForItem = <A>(self: Subscription<A>) => {
  *
  * **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
@@ -1542,31 +1495,30 @@ export 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
@@ -1578,31 +1530,30 @@ export 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
@@ -1632,28 +1583,26 @@ export 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
@@ -1666,28 +1615,26 @@ export 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
@@ -1700,28 +1647,26 @@ export 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
@@ -1783,29 +1728,29 @@ const takeRemainderLoop = <A>(
  *
  * **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()`
@@ -1831,23 +1776,17 @@ export const remaining = <A>(self: Subscription<A>): Effect.Effect<number> =>
  *
  * **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
@@ -1914,6 +1853,7 @@ const makeSubscriptionUnsafe = <A>(
 
 class BoundedPubSubArb<in out A> implements PubSub.Atomic<A> {
   array: Array<A>
+  replayIndices: Array<number>
   publisherIndex = 0
   subscribers: Array<number>
   subscriberCount = 0
@@ -1926,6 +1866,7 @@ class BoundedPubSubArb<in out A> implements PubSub.Atomic<A> {
     this.capacity = capacity
     this.replayBuffer = replayBuffer
     this.array = Array.from({ length: capacity })
+    this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : []
     this.subscribers = Array.from({ length: capacity })
   }
 
@@ -1949,15 +1890,16 @@ class BoundedPubSubArb<in out A> implements PubSub.Atomic<A> {
     if (this.isFull()) {
       return false
     }
+    const replayIndex = this.replayBuffer?.offer(value)
     if (this.subscriberCount !== 0) {
       const index = this.publisherIndex % this.capacity
       this.array[index] = value
+      if (replayIndex !== undefined) {
+        this.replayIndices[index] = replayIndex
+      }
       this.subscribers[index] = this.subscriberCount
       this.publisherIndex += 1
     }
-    if (this.replayBuffer) {
-      this.replayBuffer.offer(value)
-    }
     return true
   }
 
@@ -1982,11 +1924,12 @@ class BoundedPubSubArb<in out A> implements PubSub.Atomic<A> {
       const a = chunk[iteratorIndex++]
       const index = this.publisherIndex % this.capacity
       this.array[index] = a
+      const replayIndex = this.replayBuffer?.offer(a)
+      if (replayIndex !== undefined) {
+        this.replayIndices[index] = replayIndex
+      }
       this.subscribers[index] = this.subscriberCount
       this.publisherIndex += 1
-      if (this.replayBuffer) {
-        this.replayBuffer.offer(a)
-      }
     }
     return chunk.slice(iteratorIndex)
   }
@@ -1994,12 +1937,11 @@ class BoundedPubSubArb<in out A> implements PubSub.Atomic<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex % this.capacity
+      const value = this.array[index]
       this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide()
+      this.replayBuffer?.slide(value, this.replayIndices[index])
     }
   }
 
@@ -2105,6 +2047,7 @@ class BoundedPubSubArbSubscription<in out A> implements PubSub.BackingSubscripti
 
 class BoundedPubSubPow2<in out A> implements PubSub.Atomic<A> {
   array: Array<A>
+  replayIndices: Array<number>
   mask: number
   publisherIndex = 0
   subscribers: Array<number>
@@ -2118,6 +2061,7 @@ class BoundedPubSubPow2<in out A> implements PubSub.Atomic<A> {
     this.capacity = capacity
     this.replayBuffer = replayBuffer
     this.array = Array.from({ length: capacity })
+    this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : []
     this.mask = capacity - 1
     this.subscribers = Array.from({ length: capacity })
   }
@@ -2142,15 +2086,16 @@ class BoundedPubSubPow2<in out A> implements PubSub.Atomic<A> {
     if (this.isFull()) {
       return false
     }
+    const replayIndex = this.replayBuffer?.offer(value)
     if (this.subscriberCount !== 0) {
       const index = this.publisherIndex & this.mask
       this.array[index] = value
+      if (replayIndex !== undefined) {
+        this.replayIndices[index] = replayIndex
+      }
       this.subscribers[index] = this.subscriberCount
       this.publisherIndex += 1
     }
-    if (this.replayBuffer) {
-      this.replayBuffer.offer(value)
-    }
     return true
   }
 
@@ -2175,11 +2120,12 @@ class BoundedPubSubPow2<in out A> implements PubSub.Atomic<A> {
       const elem = chunk[iteratorIndex++]
       const index = this.publisherIndex & this.mask
       this.array[index] = elem
+      const replayIndex = this.replayBuffer?.offer(elem)
+      if (replayIndex !== undefined) {
+        this.replayIndices[index] = replayIndex
+      }
       this.subscribers[index] = this.subscriberCount
       this.publisherIndex += 1
-      if (this.replayBuffer) {
-        this.replayBuffer.offer(elem)
-      }
     }
     return chunk.slice(iteratorIndex)
   }
@@ -2187,12 +2133,11 @@ class BoundedPubSubPow2<in out A> implements PubSub.Atomic<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex & this.mask
+      const value = this.array[index]
       this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide()
+      this.replayBuffer?.slide(value, this.replayIndices[index])
     }
   }
 
@@ -2300,6 +2245,7 @@ class BoundedPubSubSingle<in out A> implements PubSub.Atomic<A> {
   subscriberCount = 0
   subscribers = 0
   value: A = AbsentValue as unknown as A
+  replayIndex = 0
 
   readonly capacity = 1
   readonly replayBuffer: ReplayBuffer<A> | undefined
@@ -2332,14 +2278,15 @@ class BoundedPubSubSingle<in out A> implements PubSub.Atomic<A> {
     if (this.isFull()) {
       return false
     }
+    const replayIndex = this.replayBuffer?.offer(value)
     if (this.subscriberCount !== 0) {
       this.value = value
+      if (replayIndex !== undefined) {
+        this.replayIndex = replayIndex
+      }
       this.subscribers = this.subscriberCount
       this.publisherIndex += 1
     }
-    if (this.replayBuffer) {
-      this.replayBuffer.offer(value)
-    }
     return true
   }
 
@@ -2363,11 +2310,10 @@ class BoundedPubSubSingle<in out A> implements PubSub.Atomic<A> {
 
   slide(): void {
     if (this.isFull()) {
+      const value = this.value
       this.subscribers = 0
       this.value = AbsentValue as unknown as A
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide()
+      this.replayBuffer?.slide(value, this.replayIndex)
     }
   }
 
@@ -2446,6 +2392,7 @@ class BoundedPubSubSingleSubscription<in out A> implements PubSub.BackingSubscri
 
 interface Node<out A> {
   value: A | AbsentValue
+  replayIndex: number | undefined
   subscribers: number
   next: Node<A> | null
 }
@@ -2453,6 +2400,7 @@ interface Node<out A> {
 class UnboundedPubSub<in out A> implements PubSub.Atomic<A> {
   publisherHead: Node<A> = {
     value: AbsentValue,
+    replayIndex: undefined,
     subscribers: 0,
     next: null
   }
@@ -2484,19 +2432,19 @@ class UnboundedPubSub<in out A> implements PubSub.Atomic<A> {
   }
 
   publish(value: A): boolean {
+    const replayIndex = this.replayBuffer?.offer(value)
     const subscribers = this.publisherTail.subscribers
     if (subscribers !== 0) {
-      this.publisherTail.next = {
+      const node: Node<A> = {
         value,
+        replayIndex,
         subscribers,
         next: null
       }
+      this.publisherTail.next = node
       this.publisherTail = this.publisherTail.next
       this.publisherIndex += 1
     }
-    if (this.replayBuffer) {
-      this.replayBuffer.offer(value)
-    }
     return true
   }
 
@@ -2513,12 +2461,12 @@ class UnboundedPubSub<in out A> implements PubSub.Atomic<A> {
 
   slide(): void {
     if (this.publisherHead !== this.publisherTail) {
+      const node = this.publisherHead.next!
+      const value = node.value as A
       this.publisherHead = this.publisherHead.next!
       this.publisherHead.value = AbsentValue
       this.subscribersIndex += 1
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide()
+      this.replayBuffer?.slide(value, node.replayIndex!)
     }
   }
 
@@ -2869,34 +2817,30 @@ export 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
@@ -2956,33 +2900,30 @@ export 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
@@ -3090,27 +3031,40 @@ const strategyCompleteSubscribersUnsafe = <A>(
 
 interface ReplayNode<A> {
   value: A | AbsentValue
+  index: number
   next: ReplayNode<A> | null
 }
 
 class ReplayBuffer<A> {
   readonly capacity: number
-  head: ReplayNode<A> = { value: AbsentValue, next: null }
+  head: ReplayNode<A> = { value: AbsentValue, index: 0, next: null }
   tail: ReplayNode<A> = this.head
+  readonly slideValues: Array<{
+    readonly value: A
+    readonly index: number
+  }> = []
   size = 0
   index = 0
+  publisherIndex = 0
 
   constructor(capacity: number) {
     this.capacity = capacity
   }
 
-  slide() {
+  slide(value: A, publisherIndex: number): void {
+    this.slideValues[this.index % this.capacity] = {
+      value,
+      index: publisherIndex
+    }
     this.index++
   }
-  offer(a: A): void {
+  offer(a: A): number {
+    const index = this.publisherIndex++
     this.tail.value = a
+    this.tail.index = index
     this.tail.next = {
       value: AbsentValue,
+      index: 0,
       next: null
     }
     this.tail = this.tail.next
@@ -3119,6 +3073,7 @@ class ReplayBuffer<A> {
     } else {
       this.size += 1
     }
+    return index
   }
   offerAll(as: Iterable<A>): void {
     for (const a of as) {
@@ -3128,48 +3083,66 @@ class ReplayBuffer<A> {
 }
 
 class ReplayWindowImpl<A> implements PubSub.ReplayWindow<A> {
-  head: ReplayNode<A>
-  index: number
-  remaining: number
   readonly buffer: ReplayBuffer<A>
+  readonly values: Array<A>
+  index = 0
+  remaining: number
+  slideIndex: number
+  newestIndex = -1
 
   constructor(buffer: ReplayBuffer<A>) {
     this.buffer = buffer
-    this.index = buffer.index
     this.remaining = buffer.size
-    this.head = buffer.head
-  }
-  fastForward() {
-    while (this.index < this.buffer.index) {
-      this.head = this.head.next!
-      this.index++
+    this.slideIndex = buffer.index
+    this.values = new Array(this.remaining)
+    let node = buffer.head
+    for (let i = 0; i < this.remaining; i++) {
+      this.values[i] = node.value as A
+      this.newestIndex = node.index
+      node = node.next!
+    }
+  }
+  close(): void {
+    this.values.length = 0
+    this.remaining = 0
+  }
+  sync(): void {
+    const slides = this.buffer.index - this.slideIndex
+    if (slides === 0 || this.remaining === 0) {
+      return
+    }
+    const count = Math.min(slides, this.buffer.capacity)
+    const start = this.buffer.index - count
+    for (let i = 0; i < count; i++) {
+      const entry = this.buffer.slideValues[(start + i) % this.buffer.capacity]
+      if (entry.index > this.newestIndex) {
+        this.index = (this.index + 1) % this.values.length
+        this.values[(this.index + this.remaining - 1) % this.values.length] = entry.value
+        this.newestIndex = entry.index
+      }
     }
+    this.slideIndex = this.buffer.index
   }
   take(): A | undefined {
     if (this.remaining === 0) {
       return undefined
-    } else if (this.index < this.buffer.index) {
-      this.fastForward()
     }
+    this.sync()
+    const value = this.values[this.index]
+    this.values[this.index] = AbsentValue as unknown as A
+    this.index = (this.index + 1) % this.values.length
     this.remaining--
-    const value = this.head.value
-    this.head = this.head.next!
+    if (this.remaining === 0) {
+      this.close()
+    }
     return value as A
   }
   takeN(n: number): Array<A> {
-    if (this.remaining === 0) {
-      return []
-    } else if (this.index < this.buffer.index) {
-      this.fastForward()
-    }
     const len = Math.min(n, this.remaining)
     const items = new Array(len)
     for (let i = 0; i < len; i++) {
-      const value = this.head.value as A
-      this.head = this.head.next!
-      items[i] = value
+      items[i] = this.take()!
     }
-    this.remaining -= len
     return items
   }
   takeAll(): Array<A> {
@@ -3181,5 +3154,6 @@ const emptyReplayWindow: PubSub.ReplayWindow<never> = {
   remaining: 0,
   take: () => undefined,
   takeN: () => [],
-  takeAll: () => []
+  takeAll: () => [],
+  close: () => void 0
 }