effect 4.0.0-beta.99 → 4.0.0-rc.108

package/dist/PubSub.js

@@ -30,7 +30,7 @@ const SubscriptionTypeId = "~effect/PubSub/Subscription";
  *
  * **Example** (Creating a PubSub with a custom strategy)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -41,8 +41,13 @@ const SubscriptionTypeId = "~effect/PubSub/Subscription";
  *   })
  *
  *   // 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
@@ -62,7 +67,7 @@ export const make = options => Effect.sync(() => makePubSubUnsafe(options.atomic
  *
  * **Example** (Creating a bounded PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -74,7 +79,15 @@ export const make = options => Effect.sync(() => makePubSubUnsafe(options.atomic
  *     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
@@ -94,33 +107,27 @@ export const bounded = capacity => make({
  *
  * **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
@@ -140,32 +147,26 @@ export const dropping = capacity => make({
  *
  * **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
@@ -180,30 +181,25 @@ export const sliding = capacity => make({
  *
  * **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
@@ -281,18 +277,17 @@ export const makeAtomicUnbounded = options => new UnboundedPubSub(options?.repla
  *
  * **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
@@ -310,29 +305,28 @@ export const capacity = self => 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
@@ -355,14 +349,16 @@ export const size = self => Effect.sync(() => sizeUnsafe(self));
  *
  * **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
@@ -383,29 +379,28 @@ export const sizeUnsafe = self => {
  *
  * **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
@@ -417,28 +412,27 @@ export const isFull = self => Effect.map(size(self), size => size === self.pubsu
  *
  * **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
@@ -457,7 +451,7 @@ export const isEmpty = self => Effect.map(size(self), size => size === 0);
  *
  * **Example** (Shutting down a PubSub)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -467,12 +461,14 @@ export const isEmpty = self => Effect.map(size(self), size => size === 0);
  *   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
@@ -488,7 +484,7 @@ export const shutdown = self => Effect.uninterruptible(Effect.withFiber(fiber =>
  *
  * **Example** (Checking whether a PubSub is shut down)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -496,14 +492,16 @@ export const shutdown = self => Effect.uninterruptible(Effect.withFiber(fiber =>
  *
  *   // 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
@@ -521,18 +519,18 @@ export const isShutdown = self => Effect.sync(() => isShutdownUnsafe(self));
  *
  * **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
@@ -546,7 +544,7 @@ export const isShutdownUnsafe = self => self.shutdownFlag.current;
  *
  * **Example** (Waiting for shutdown)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Fiber, PubSub } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -556,19 +554,19 @@ export const isShutdownUnsafe = self => self.shutdownFlag.current;
  *   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
@@ -592,24 +590,24 @@ export const awaitShutdown = self => self.shutdownHook.await;
  *
  * **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
@@ -644,24 +642,16 @@ export const publish = /*#__PURE__*/dual(2, (self, value) => Effect.suspend(() =
  *
  * **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
@@ -683,37 +673,30 @@ export const publishUnsafe = /*#__PURE__*/dual(2, (self, value) => {
  *
  * **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)
+ *   const subscription = yield* PubSub.subscribe(smallPubsub)
  *
- *     // Will suspend until space becomes available for all messages
- *     const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, manyMessages))
+ *   // Will suspend until space becomes available for all messages
+ *   const fiber = yield* Effect.forkChild(PubSub.publishAll(smallPubsub, ["msg1", "msg2", "msg3", "msg4"]))
  *
- *     const firstBatch = yield* PubSub.takeBetween(subscription, 2, 2)
- *     console.log("First batch:", firstBatch) // ["msg1", "msg2"]
+ *   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 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
@@ -737,14 +720,14 @@ export const publishAll = /*#__PURE__*/dual(2, (self, elements) => Effect.suspen
  *
  * **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
@@ -754,25 +737,28 @@ export const publishAll = /*#__PURE__*/dual(2, (self, elements) => Effect.suspen
  *     // 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
@@ -792,6 +778,7 @@ const unsubscribe = self => Effect.uninterruptible(Effect.withFiber(state => {
   }).pipe(Effect.tap(() => Effect.sync(() => {
     self.subscribers.delete(self.subscription);
     self.subscription.unsubscribe();
+    self.replayWindow.close();
     self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
   })), Effect.when(self.shutdownHook.open), Effect.asVoid);
 }));
@@ -801,28 +788,26 @@ const unsubscribe = self => Effect.uninterruptible(Effect.withFiber(state => {
  *
  * **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
@@ -850,23 +835,23 @@ export const take = self => Effect.suspend(() => {
  *
  * **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
@@ -908,31 +893,30 @@ const pollForItem = self => {
  *
  * **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
@@ -957,28 +941,26 @@ export const takeUpTo = /*#__PURE__*/dual(2, (self, max) => Effect.suspend(() =>
  *
  * **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
@@ -1023,29 +1005,29 @@ const takeRemainderLoop = (self, min, max, acc) => {
  *
  * **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()`
@@ -1065,23 +1047,17 @@ export const remaining = self => Effect.suspend(() => self.shutdownFlag.current
  *
  * **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
@@ -1119,6 +1095,7 @@ const removeSubscribers = (subscribers, subscription, pollers) => {
 const makeSubscriptionUnsafe = (pubsub, subscribers, strategy) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), MutableList.make(), Latch.makeUnsafe(false), MutableRef.make(false), strategy, pubsub.replayWindow());
 class BoundedPubSubArb {
   array;
+  replayIndices;
   publisherIndex = 0;
   subscribers;
   subscriberCount = 0;
@@ -1131,6 +1108,9 @@ class BoundedPubSubArb {
     this.array = Array.from({
       length: capacity
     });
+    this.replayIndices = replayBuffer ? Array.from({
+      length: capacity
+    }) : [];
     this.subscribers = Array.from({
       length: capacity
     });
@@ -1151,15 +1131,16 @@ class BoundedPubSubArb {
     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;
   }
   publishAll(elements) {
@@ -1183,23 +1164,23 @@ class BoundedPubSubArb {
       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);
   }
   slide() {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex % this.capacity;
+      const value = this.array[index];
       this.array[index] = AbsentValue;
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide();
+      this.replayBuffer?.slide(value, this.replayIndices[index]);
     }
   }
   subscribe() {
@@ -1287,6 +1268,7 @@ class BoundedPubSubArbSubscription {
 }
 class BoundedPubSubPow2 {
   array;
+  replayIndices;
   mask;
   publisherIndex = 0;
   subscribers;
@@ -1300,6 +1282,9 @@ class BoundedPubSubPow2 {
     this.array = Array.from({
       length: capacity
     });
+    this.replayIndices = replayBuffer ? Array.from({
+      length: capacity
+    }) : [];
     this.mask = capacity - 1;
     this.subscribers = Array.from({
       length: capacity
@@ -1321,15 +1306,16 @@ class BoundedPubSubPow2 {
     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;
   }
   publishAll(elements) {
@@ -1353,23 +1339,23 @@ class BoundedPubSubPow2 {
       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);
   }
   slide() {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex & this.mask;
+      const value = this.array[index];
       this.array[index] = AbsentValue;
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide();
+      this.replayBuffer?.slide(value, this.replayIndices[index]);
     }
   }
   subscribe() {
@@ -1460,6 +1446,7 @@ class BoundedPubSubSingle {
   subscriberCount = 0;
   subscribers = 0;
   value = AbsentValue;
+  replayIndex = 0;
   capacity = 1;
   replayBuffer;
   constructor(replayBuffer) {
@@ -1484,14 +1471,15 @@ class BoundedPubSubSingle {
     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;
   }
   publishAll(elements) {
@@ -1513,11 +1501,10 @@ class BoundedPubSubSingle {
   }
   slide() {
     if (this.isFull()) {
+      const value = this.value;
       this.subscribers = 0;
       this.value = AbsentValue;
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide();
+      this.replayBuffer?.slide(value, this.replayIndex);
     }
   }
   subscribe() {
@@ -1580,6 +1567,7 @@ class BoundedPubSubSingleSubscription {
 class UnboundedPubSub {
   publisherHead = {
     value: AbsentValue,
+    replayIndex: undefined,
     subscribers: 0,
     next: null
   };
@@ -1604,19 +1592,19 @@ class UnboundedPubSub {
     return this.publisherIndex - this.subscribersIndex;
   }
   publish(value) {
+    const replayIndex = this.replayBuffer?.offer(value);
     const subscribers = this.publisherTail.subscribers;
     if (subscribers !== 0) {
-      this.publisherTail.next = {
+      const node = {
         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;
   }
   publishAll(elements) {
@@ -1631,12 +1619,12 @@ class UnboundedPubSub {
   }
   slide() {
     if (this.publisherHead !== this.publisherTail) {
+      const node = this.publisherHead.next;
+      const value = node.value;
       this.publisherHead = this.publisherHead.next;
       this.publisherHead.value = AbsentValue;
       this.subscribersIndex += 1;
-    }
-    if (this.replayBuffer) {
-      this.replayBuffer.slide();
+      this.replayBuffer?.slide(value, node.replayIndex);
     }
   }
   subscribe() {
@@ -1906,34 +1894,30 @@ export class BackPressureStrategy {
  *
  * **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
@@ -1975,33 +1959,30 @@ export class DroppingStrategy {
  *
  * **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
@@ -2078,21 +2059,31 @@ class ReplayBuffer {
   capacity;
   head = {
     value: AbsentValue,
+    index: 0,
     next: null
   };
   tail = this.head;
+  slideValues = [];
   size = 0;
   index = 0;
+  publisherIndex = 0;
   constructor(capacity) {
     this.capacity = capacity;
   }
-  slide() {
+  slide(value, publisherIndex) {
+    this.slideValues[this.index % this.capacity] = {
+      value,
+      index: publisherIndex
+    };
     this.index++;
   }
   offer(a) {
+    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;
@@ -2101,6 +2092,7 @@ class ReplayBuffer {
     } else {
       this.size += 1;
     }
+    return index;
   }
   offerAll(as) {
     for (const a of as) {
@@ -2109,47 +2101,65 @@ class ReplayBuffer {
   }
 }
 class ReplayWindowImpl {
-  head;
-  index;
-  remaining;
   buffer;
+  values;
+  index = 0;
+  remaining;
+  slideIndex;
+  newestIndex = -1;
   constructor(buffer) {
     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;
+      this.newestIndex = node.index;
+      node = node.next;
+    }
+  }
+  close() {
+    this.values.length = 0;
+    this.remaining = 0;
+  }
+  sync() {
+    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() {
     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;
+    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;
   }
   takeN(n) {
-    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;
-      this.head = this.head.next;
-      items[i] = value;
+      items[i] = this.take();
     }
-    this.remaining -= len;
     return items;
   }
   takeAll() {
@@ -2160,6 +2170,7 @@ const emptyReplayWindow = {
   remaining: 0,
   take: () => undefined,
   takeN: () => [],
-  takeAll: () => []
+  takeAll: () => [],
+  close: () => void 0
 };
 //# sourceMappingURL=PubSub.js.map