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

package/dist/Queue.js

@@ -142,10 +142,10 @@ const QueueProto = {
  *
  * **Example** (Creating queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
- * Effect.gen(function*() {
+ * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.make<number, string | Cause.Done>()
  *
  *   // add messages to the queue
@@ -155,18 +155,18 @@ const QueueProto = {
  *
  *   // take messages from the queue
  *   const messages = yield* Queue.takeAll(queue)
- *   console.log(messages) // [1, 2, 3, 4, 5]
  *
  *   // signal that the queue is done
  *   yield* Queue.end(queue)
  *   const done = yield* Effect.flip(Queue.take(queue))
- *   console.log(Cause.isDone(done)) // true
  *
  *   // signal that another queue has failed
  *   const failedQueue = yield* Queue.make<number, string>()
  *   const failed = yield* Queue.fail(failedQueue, "boom")
- *   console.log(failed) // true
+ *   return { messages, done, failed }
  * })
+ *
+ * await Effect.runPromise(program) // => { messages: [1, 2, 3, 4, 5], done: Cause.Done(), failed: true }
  * ```
  *
  * @category constructors
@@ -197,7 +197,7 @@ export const make = options => core.withFiber(fiber => {
  *
  * **Example** (Creating bounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -208,8 +208,10 @@ export const make = options => core.withFiber(fiber => {
  *   yield* Queue.offer(queue, "second")
  *
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 2
+ *   return size
  * })
+ *
+ * await Effect.runPromise(program) // => 2
  * ```
  *
  * @category constructors
@@ -229,7 +231,7 @@ export const bounded = capacity => make({
  *
  * **Example** (Creating sliding queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -244,8 +246,10 @@ export const bounded = capacity => make({
  *   yield* Queue.offer(queue, 4)
  *
  *   const all = yield* Queue.takeAll(queue)
- *   console.log(all) // [2, 3, 4] - oldest element (1) was dropped
+ *   return all
  * })
+ *
+ * await Effect.runPromise(program) // => [2, 3, 4]
  * ```
  *
  * @category constructors
@@ -266,7 +270,7 @@ export const sliding = capacity => make({
  *
  * **Example** (Creating dropping queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -275,15 +279,15 @@ export const sliding = capacity => make({
  *   // Fill the queue to capacity
  *   const success1 = yield* Queue.offer(queue, 1)
  *   const success2 = yield* Queue.offer(queue, 2)
- *   console.log(success1, success2) // true, true
  *
  *   // This will be dropped
  *   const success3 = yield* Queue.offer(queue, 3)
- *   console.log(success3) // false
  *
  *   const all = yield* Queue.takeAll(queue)
- *   console.log(all) // [1, 2] - element 3 was dropped
+ *   return [success1, success2, success3, all]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, true, false, [1, 2]]
  * ```
  *
  * @category constructors
@@ -303,7 +307,7 @@ export const dropping = capacity => make({
  *
  * **Example** (Creating unbounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -316,12 +320,13 @@ export const dropping = capacity => make({
  *
  *   // Check current size
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 5
  *
  *   // Take all messages
  *   const messages = yield* Queue.takeAll(queue)
- *   console.log(messages) // ["message1", "message2", "message3", "message4", "message5"]
+ *   return { size, messages }
  * })
+ *
+ * await Effect.runPromise(program) // => { size: 5, messages: ["message1", "message2", "message3", "message4", "message5"] }
  * ```
  *
  * @category constructors
@@ -339,7 +344,7 @@ export const unbounded = () => make();
  *
  * **Example** (Offering a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -348,15 +353,16 @@ export const unbounded = () => make();
  *   // Successfully add messages to queue
  *   const success1 = yield* Queue.offer(queue, 1)
  *   const success2 = yield* Queue.offer(queue, 2)
- *   console.log(success1, success2) // true, true
  *
  *   // Queue state
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 2
+ *   return { offered: [success1, success2], size }
  * })
+ *
+ * await Effect.runPromise(program) // => { offered: [true, true], size: 2 }
  * ```
  *
- * @category Offering
+ * @category offering
  * @since 2.0.0
  */
 export const offer = (self, message) => internalEffect.suspend(() => {
@@ -398,8 +404,8 @@ export const offer = (self, message) => internalEffect.suspend(() => {
  *
  * **Example** (Offering a value synchronously)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Queue } from "effect"
  *
  * // Create a queue effect and extract the queue for unsafe operations
  * const program = Effect.gen(function*() {
@@ -408,15 +414,16 @@ export const offer = (self, message) => internalEffect.suspend(() => {
  *   // Add messages synchronously using unsafe API
  *   const success1 = Queue.offerUnsafe(queue, 1)
  *   const success2 = Queue.offerUnsafe(queue, 2)
- *   console.log(success1, success2) // true, true
  *
  *   // Check current size
  *   const size = Queue.sizeUnsafe(queue)
- *   console.log(size) // 2
+ *   return { offered: [success1, success2], size }
  * })
+ *
+ * await Effect.runPromise(program) // => { offered: [true, true], size: 2 }
  * ```
  *
- * @category Offering
+ * @category offering
  * @since 4.0.0
  */
 export const offerUnsafe = (self, message) => {
@@ -455,7 +462,7 @@ export const offerUnsafe = (self, message) => {
  *
  * **Example** (Offering multiple values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -463,11 +470,13 @@ export const offerUnsafe = (self, message) => {
  *
  *   // Try to add more messages than capacity without suspending
  *   const remaining1 = yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
- *   console.log(remaining1) // [4, 5] - couldn't fit the last 2
+ *   return remaining1
  * })
+ *
+ * await Effect.runPromise(program) // => [4, 5]
  * ```
  *
- * @category Offering
+ * @category offering
  * @since 2.0.0
  */
 export const offerAll = (self, messages) => internalEffect.suspend(() => {
@@ -497,8 +506,8 @@ export const offerAll = (self, messages) => internalEffect.suspend(() => {
  *
  * **Example** (Offering multiple values synchronously)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Queue } from "effect"
  *
  * // Create a bounded queue and use unsafe API
  * const program = Effect.gen(function*() {
@@ -506,15 +515,16 @@ export const offerAll = (self, messages) => internalEffect.suspend(() => {
  *
  *   // Try to add 5 messages to capacity-3 queue using unsafe API
  *   const remaining = Queue.offerAllUnsafe(queue, [1, 2, 3, 4, 5])
- *   console.log(remaining) // [4, 5] - couldn't fit the last 2
  *
  *   // Check what's in the queue
  *   const size = Queue.sizeUnsafe(queue)
- *   console.log(size) // 3
+ *   return { remaining, size }
  * })
+ *
+ * await Effect.runPromise(program) // => { remaining: [4, 5], size: 3 }
  * ```
  *
- * @category Offering
+ * @category offering
  * @since 4.0.0
  */
 export const offerAllUnsafe = (self, messages) => {
@@ -551,20 +561,21 @@ export const offerAllUnsafe = (self, messages) => {
  *
  * **Example** (Failing queues with an error)
  *
- * ```ts
- * import { Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, string>(10)
  *
  *   // Fail the queue with an error
  *   const failed = yield* Queue.fail(queue, "Something went wrong")
- *   console.log(failed) // true
  *
  *   // Taking from the failed queue fails with the error
- *   const error = yield* Effect.flip(Queue.take(queue))
- *   console.log(error) // "Something went wrong"
+ *   const exit = yield* Effect.exit(Queue.take(queue))
+ *   return [failed, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.fail("Something went wrong")]
  * ```
  *
  * @category completion
@@ -577,8 +588,8 @@ export const fail = (self, error) => failCause(self, core.causeFail(error));
  *
  * **Example** (Failing queues with a cause)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, string>(10)
@@ -586,11 +597,13 @@ export const fail = (self, error) => failCause(self, core.causeFail(error));
  *   // Create a cause and fail the queue
  *   const cause = Cause.fail("Queue processing failed")
  *   const failed = yield* Queue.failCause(queue, cause)
- *   console.log(failed) // true
  *
  *   // The queue is now done with the specified failure cause
- *   console.log(queue.state._tag) // "Done"
+ *   const exit = yield* Effect.exit(Queue.take(queue))
+ *   return [failed, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Queue processing failed"))]
  * ```
  *
  * @category completion
@@ -612,8 +625,8 @@ export const failCause = /*#__PURE__*/dual(2, (self, cause) => internalEffect.sy
  *
  * **Example** (Failing queues with a cause synchronously)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, string>(10)
@@ -621,11 +634,13 @@ export const failCause = /*#__PURE__*/dual(2, (self, cause) => internalEffect.sy
  *   // Create a cause and fail the queue synchronously
  *   const cause = Cause.fail("Processing error")
  *   const failed = Queue.failCauseUnsafe(queue, cause)
- *   console.log(failed) // true
  *
  *   // The queue is now done with the specified failure cause
- *   console.log(queue.state._tag) // "Done"
+ *   const exit = Queue.takeUnsafe(queue)
+ *   return [failed, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Processing error"))]
  * ```
  *
  * @category completion
@@ -662,7 +677,7 @@ export const failCauseUnsafe = (self, cause) => {
  *
  * **Example** (Ending queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -674,16 +689,16 @@ export const failCauseUnsafe = (self, cause) => {
  *
  *   // Signal completion - no more messages will be accepted
  *   const ended = yield* Queue.end(queue)
- *   console.log(ended) // true
  *
  *   // Trying to offer more messages will return false
  *   const offerResult = yield* Queue.offer(queue, 3)
- *   console.log(offerResult) // false
  *
  *   // But we can still take existing messages
  *   const message = yield* Queue.take(queue)
- *   console.log(message) // 1
+ *   return [ended, offerResult, message]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, false, 1]
  * ```
  *
  * @category completion
@@ -708,7 +723,7 @@ export const end = self => failCause(self, core.causeFail(core.Done()));
  *
  * **Example** (Ending queues synchronously)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * // Create a queue and use unsafe operations
@@ -721,17 +736,19 @@ export const end = self => failCause(self, core.causeFail(core.Done()));
  *
  *   // End the queue synchronously
  *   const ended = Queue.endUnsafe(queue)
- *   console.log(ended) // true
  *
  *   // Existing messages can still be consumed while the queue is closing
- *   console.log(queue.state._tag) // "Closing"
+ *   const states = [queue.state._tag]
  *
  *   Queue.takeUnsafe(queue)
  *   Queue.takeUnsafe(queue)
  *
  *   // After buffered messages are consumed, the queue is done
- *   console.log(queue.state._tag) // "Done"
+ *   states.push(queue.state._tag)
+ *   return { ended, states }
  * })
+ *
+ * await Effect.runPromise(program) // => { ended: true, states: ["Closing", "Done"] }
  * ```
  *
  * @category completion
@@ -748,7 +765,7 @@ export const endUnsafe = self => failCauseUnsafe(self, core.causeFail(core.Done(
  *
  * **Example** (Interrupting queues gracefully)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -760,23 +777,21 @@ export const endUnsafe = self => failCauseUnsafe(self, core.causeFail(core.Done(
  *
  *   // Interrupt gracefully - no more offers accepted, but messages can be consumed
  *   const interrupted = yield* Queue.interrupt(queue)
- *   console.log(interrupted) // true
  *
  *   // Trying to offer more messages will return false
  *   const offerResult = yield* Queue.offer(queue, 3)
- *   console.log(offerResult) // false
  *
  *   // But we can still take existing messages
  *   const message1 = yield* Queue.take(queue)
- *   console.log(message1) // 1
  *
  *   const message2 = yield* Queue.take(queue)
- *   console.log(message2) // 2
  *
  *   // After all messages are consumed, queue is done
  *   const isDone = queue.state._tag === "Done"
- *   console.log(isDone) // true
+ *   return { interrupted, offerResult, messages: [message1, message2], isDone }
  * })
+ *
+ * await Effect.runPromise(program) // => { interrupted: true, offerResult: false, messages: [1, 2], isDone: true }
  * ```
  *
  * @category completion
@@ -794,7 +809,7 @@ export const interrupt = self => core.withFiber(fiber => failCause(self, interna
  *
  * **Example** (Shutting down queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -806,12 +821,13 @@ export const interrupt = self => core.withFiber(fiber => failCause(self, interna
  *
  *   // Shutdown clears buffered messages and prevents further offers
  *   const wasShutdown = yield* Queue.shutdown(queue)
- *   console.log(wasShutdown) // true
  *
  *   // Queue is now done and cleared
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 0
+ *   return { wasShutdown, size }
  * })
+ *
+ * await Effect.runPromise(program) // => { wasShutdown: true, size: 0 }
  * ```
  *
  * @category completion
@@ -846,8 +862,8 @@ export const shutdown = self => internalEffect.sync(() => {
  *
  * **Example** (Clearing queued values)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number>(10)
@@ -857,16 +873,16 @@ export const shutdown = self => internalEffect.sync(() => {
  *
  *   // Clear all messages from the queue
  *   const messages = yield* Queue.clear(queue)
- *   console.log(messages) // [1, 2, 3, 4, 5]
  *
  *   // Queue is now empty
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 0
  *
  *   // Clearing empty queue returns empty array
  *   const empty = yield* Queue.clear(queue)
- *   console.log(empty) // []
+ *   return { messages, size, empty }
  * })
+ *
+ * await Effect.runPromise(program) // => { messages: [1, 2, 3, 4, 5], size: 0, empty: [] }
  * ```
  *
  * @category taking
@@ -899,7 +915,7 @@ export const clear = self => internalEffect.suspend(() => {
  *
  * **Example** (Taking all available values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -910,8 +926,10 @@ export const clear = self => internalEffect.suspend(() => {
  *
  *   // Take all available messages
  *   const messages1 = yield* Queue.takeAll(queue)
- *   console.log(messages1) // [1, 2, 3, 4, 5]
+ *   return messages1
  * })
+ *
+ * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category taking
@@ -923,7 +941,7 @@ export const takeAll = self => takeBetween(self, 1, Number.POSITIVE_INFINITY);
  *
  * **Example** (Collecting values until completion)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -931,13 +949,13 @@ export const takeAll = self => takeBetween(self, 1, Number.POSITIVE_INFINITY);
  *
  *   // Add several messages
  *   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
- *   // Some time later, end the queue
- *   yield* Effect.forkChild(Queue.end(queue))
+ *   yield* Queue.end(queue)
  *
  *   // Collect all available messages
- *   const messages = yield* Queue.collect(queue)
- *   console.log(messages) // [1, 2, 3, 4, 5]
+ *   return yield* Queue.collect(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category taking
@@ -967,7 +985,7 @@ export const collect = self => internalEffect.suspend(() => {
  *
  * **Example** (Taking a fixed number of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -978,16 +996,16 @@ export const collect = self => internalEffect.suspend(() => {
  *
  *   // Take exactly 3 messages
  *   const first3 = yield* Queue.takeN(queue, 3)
- *   console.log(first3) // [1, 2, 3]
  *
  *   // Take exactly 2 more messages
  *   const next2 = yield* Queue.takeN(queue, 2)
- *   console.log(next2) // [4, 5]
  *
  *   // Take remaining messages
  *   const remaining = yield* Queue.takeN(queue, 2)
- *   console.log(remaining) // [6, 7]
+ *   return [first3, next2, remaining]
  * })
+ *
+ * await Effect.runPromise(program) // => [[1, 2, 3], [4, 5], [6, 7]]
  * ```
  *
  * @category taking
@@ -1006,7 +1024,7 @@ export const takeN = (self, n) => takeBetween(self, n, n);
  *
  * **Example** (Taking a bounded batch of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1017,15 +1035,16 @@ export const takeN = (self, n) => takeBetween(self, n, n);
  *
  *   // Take between 2 and 5 messages
  *   const batch1 = yield* Queue.takeBetween(queue, 2, 5)
- *   console.log(batch1) // [1, 2, 3, 4, 5] - took 5 (up to max)
  *
  *   // Take between 1 and 10 messages (but only 3 remain)
  *   const batch2 = yield* Queue.takeBetween(queue, 1, 10)
- *   console.log(batch2) // [6, 7, 8] - took 3 (all remaining)
  *
  *   // No more messages available, will wait or return done
  *   // const batch3 = yield* Queue.takeBetween(queue, 1, 3)
+ *   return [batch1, batch2]
  * })
+ *
+ * await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]
  * ```
  *
  * @category taking
@@ -1043,8 +1062,8 @@ export const takeBetween = (self, min, max) => internalEffect.suspend(() => take
  *
  * **Example** (Taking one value)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<string, Cause.Done>(3)
@@ -1056,18 +1075,16 @@ export const takeBetween = (self, min, max) => internalEffect.suspend(() => take
  *   // Take messages one by one
  *   const msg1 = yield* Queue.take(queue)
  *   const msg2 = yield* Queue.take(queue)
- *   console.log(msg1, msg2) // "first", "second"
  *
  *   // End the queue
  *   yield* Queue.end(queue)
  *
  *   // Taking from an ended queue fails with Done
- *   const result = yield* Effect.match(Queue.take(queue), {
- *     onFailure: (error: Cause.Done) => true,
- *     onSuccess: (value: string) => false
- *   })
- *   console.log("Queue ended:", result) // true
+ *   const result = yield* Effect.exit(Queue.take(queue))
+ *   return [[msg1, msg2], result]
  * })
+ *
+ * await Effect.runPromise(program) // => [["first", "second"], Exit.fail(Cause.Done())]
  * ```
  *
  * @category taking
@@ -1085,7 +1102,7 @@ export const take = self => internalEffect.suspend(() => takeUnsafe(self) ?? int
  *
  * **Example** (Polling without blocking)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1093,15 +1110,16 @@ export const take = self => internalEffect.suspend(() => takeUnsafe(self) ?? int
  *
  *   // Poll returns Option.none if empty
  *   const maybe1 = yield* Queue.poll(queue)
- *   console.log(Option.isNone(maybe1)) // true
  *
  *   // Add an item
  *   yield* Queue.offer(queue, 42)
  *
  *   // Poll returns Option.some with the item
  *   const maybe2 = yield* Queue.poll(queue)
- *   console.log(Option.getOrNull(maybe2)) // 42
+ *   return [maybe1, maybe2]
  * })
+ *
+ * await Effect.runPromise(program) // => [Option.none(), Option.some(42)]
  * ```
  *
  * @category taking
@@ -1126,7 +1144,7 @@ export const poll = self => internalEffect.suspend(() => {
  *
  * **Example** (Peeking at the next value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1135,8 +1153,10 @@ export const poll = self => internalEffect.suspend(() => {
  *
  *   // Peek at the next item without removing it
  *   const item = yield* Queue.peek(queue)
- *   console.log(item) // 42
+ *   return item
  * })
+ *
+ * await Effect.runPromise(program) // => 42
  * ```
  *
  * @category taking
@@ -1167,8 +1187,8 @@ export const peek = self => internalEffect.suspend(() => {
  *
  * **Example** (Taking one value synchronously)
  *
- * ```ts
- * import { Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, Queue } from "effect"
  *
  * // Create a queue and use unsafe operations
  * const program = Effect.gen(function*() {
@@ -1180,15 +1200,15 @@ export const peek = self => internalEffect.suspend(() => {
  *
  *   // Take a message synchronously
  *   const result1 = Queue.takeUnsafe(queue)
- *   console.log(result1) // Success(1) or Exit containing value 1
  *
  *   const result2 = Queue.takeUnsafe(queue)
- *   console.log(result2) // Success(2)
  *
  *   // No more messages - returns undefined
  *   const result3 = Queue.takeUnsafe(queue)
- *   console.log(result3) // undefined
+ *   return [result1, result2, result3]
  * })
+ *
+ * await Effect.runPromise(program) // => [Exit.succeed(1), Exit.succeed(2), undefined]
  * ```
  *
  * @category taking
@@ -1261,34 +1281,36 @@ await_ as await };
  *
  * **Details**
  *
- * Completed queues report a size of `0`.
+ * After `end`, a queue remains `Closing` while buffered messages are drained,
+ * and its size continues to include those messages. A `Done` queue reports a
+ * size of `0`.
  *
  * **Example** (Checking queue size)
  *
- * ```ts
- * import { Cause, Effect, Option, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, Cause.Done>(10)
  *
  *   // Check size of empty queue
  *   const size1 = yield* Queue.size(queue)
- *   console.log(size1) // 0
  *
  *   // Add some messages
  *   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
  *
  *   // Check size after adding messages
  *   const size2 = yield* Queue.size(queue)
- *   console.log(size2) // 5
  *
  *   // End the queue
  *   yield* Queue.end(queue)
  *
- *   // Size of ended queue is 0
+ *   // Ending retains the buffered size while the queue is Closing
  *   const size3 = yield* Queue.size(queue)
- *   console.log(size3) // 0
+ *   return [size1, size2, size3]
  * })
+ *
+ * await Effect.runPromise(program) // => [0, 5, 5]
  * ```
  *
  * @category sizes
@@ -1300,22 +1322,25 @@ export const size = self => internalEffect.sync(() => sizeUnsafe(self));
  *
  * **Example** (Checking if queues are full)
  *
- * ```ts
- * import { Cause, Effect, Option, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, Cause.Done>(3)
  *
- *   console.log(yield* Queue.isFull(queue)) // false
+ *   const before = yield* Queue.isFull(queue)
  *
  *   // Add some messages
  *   yield* Queue.offerAll(queue, [1, 2, 3])
  *
- *   console.log(yield* Queue.isFull(queue)) // true
+ *   const after = yield* Queue.isFull(queue)
+ *   return [before, after]
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category sizes
+ * @category predicates
  * @since 2.0.0
  */
 export const isFull = self => internalEffect.sync(() => isFullUnsafe(self));
@@ -1329,20 +1354,21 @@ export const isFull = self => internalEffect.sync(() => isFullUnsafe(self));
  *
  * **Details**
  *
- * Completed queues report a size of `0`. This unsafe operation reads the queue
- * state directly without Effect wrapping.
+ * After `endUnsafe`, a queue remains `Closing` while buffered messages are
+ * drained, and its size continues to include those messages. A `Done` queue
+ * reports a size of `0`. This unsafe operation reads the queue state directly
+ * without Effect wrapping.
  *
  * **Example** (Checking queue size synchronously)
  *
- * ```ts
- * import { Cause, Effect, Option, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, Cause.Done>(10)
  *
  *   // Check size of empty queue
  *   const size1 = Queue.sizeUnsafe(queue)
- *   console.log(size1) // 0
  *
  *   // Add some messages
  *   Queue.offerUnsafe(queue, 1)
@@ -1351,15 +1377,16 @@ export const isFull = self => internalEffect.sync(() => isFullUnsafe(self));
  *
  *   // Check size after adding messages
  *   const size2 = Queue.sizeUnsafe(queue)
- *   console.log(size2) // 3
  *
  *   // End the queue
  *   Queue.endUnsafe(queue)
  *
- *   // Size of ended queue is 0
+ *   // Ending retains the buffered size while the queue is Closing
  *   const size3 = Queue.sizeUnsafe(queue)
- *   console.log(size3) // 0
+ *   return [size1, size2, size3]
  * })
+ *
+ * await Effect.runPromise(program) // => [0, 3, 3]
  * ```
  *
  * @category sizes
@@ -1376,22 +1403,25 @@ export const sizeUnsafe = self => self.state._tag === "Done" ? 0 : self.messages
  *
  * **Example** (Checking fullness synchronously)
  *
- * ```ts
- * import { Cause, Effect, Option, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, Cause.Done>(3)
  *
- *   console.log(Queue.isFullUnsafe(queue)) // false
+ *   const before = Queue.isFullUnsafe(queue)
  *
  *   // Add some messages
  *   yield* Queue.offerAll(queue, [1, 2, 3])
  *
- *   console.log(Queue.isFullUnsafe(queue)) // true
+ *   const after = Queue.isFullUnsafe(queue)
+ *   return [before, after]
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category sizes
+ * @category predicates
  * @since 4.0.0
  */
 export const isFullUnsafe = self => sizeUnsafe(self) === self.capacity;
@@ -1401,15 +1431,15 @@ export const isFullUnsafe = self => sizeUnsafe(self) === self.capacity;
  *
  * **Example** (Running effects into queues)
  *
- * ```ts
- * import { Cause, Effect, Queue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<number, Cause.Done>(10)
  *
  *   // Create an effect that succeeds
  *   const dataProcessing = Effect.gen(function*() {
- *     yield* Effect.sleep("100 millis")
+ *     yield* Effect.yieldNow
  *     return "Processing completed successfully"
  *   })
  *
@@ -1419,11 +1449,11 @@ export const isFullUnsafe = self => sizeUnsafe(self) === self.capacity;
  *   const effectIntoQueue = Queue.into(queue)(dataProcessing)
  *
  *   const wasCompleted = yield* effectIntoQueue
- *   console.log("Queue operation completed:", wasCompleted) // true
- *
- *   // Queue state now reflects the effect's outcome
- *   console.log("Queue state:", queue.state._tag) // "Done"
+ *   const exit = yield* Effect.exit(Queue.take(queue))
+ *   return [wasCompleted, exit]
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.fail(Cause.Done())]
  * ```
  *
  * @category completion