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

package/dist/Queue.d.ts

@@ -124,7 +124,7 @@ export declare const asDequeue: <A, E>(self: Queue<A, E>) => Dequeue<A, E>;
  *
  * **Example** (Offering through enqueue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * // Function that only needs write access to a queue
@@ -137,7 +137,10 @@ export declare const asDequeue: <A, E>(self: Queue<A, E>) => Dequeue<A, E>;
  * const program = Effect.gen(function*() {
  *   const queue = yield* Queue.bounded<string>(10)
  *   yield* producer(queue)
+ *   return yield* Queue.takeAll(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => ["hello", "world", "!"]
  * ```
  *
  * @category models
@@ -186,7 +189,7 @@ export declare namespace Enqueue {
  *
  * **Example** (Taking through dequeue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -200,8 +203,10 @@ export declare namespace Enqueue {
  *
  *   // Take elements using dequeue interface
  *   const item = yield* Queue.take(dequeue)
- *   console.log(item) // "a"
+ *   return item
  * })
+ *
+ * await Effect.runPromise(program) // => "a"
  * ```
  *
  * @category models
@@ -248,7 +253,7 @@ export declare namespace Dequeue {
  *
  * **Example** (Offering and taking queue values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -264,8 +269,10 @@ export declare namespace Dequeue {
  *   const item2 = yield* Queue.take(queue)
  *   const item3 = yield* Queue.take(queue)
  *
- *   console.log([item1, item2, item3]) // ["hello", "world", "!"]
+ *   return [item1, item2, item3]
  * })
+ *
+ * await Effect.runPromise(program) // => ["hello", "world", "!"]
  * ```
  *
  * @category models
@@ -359,10 +366,10 @@ export declare namespace Queue {
  *
  * **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
@@ -372,18 +379,18 @@ export declare namespace Queue {
  *
  *   // 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
@@ -403,7 +410,7 @@ export declare const make: <A, E = never>(options?: {
  *
  * **Example** (Creating bounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -414,8 +421,10 @@ export declare const make: <A, E = never>(options?: {
  *   yield* Queue.offer(queue, "second")
  *
  *   const size = yield* Queue.size(queue)
- *   console.log(size) // 2
+ *   return size
  * })
+ *
+ * await Effect.runPromise(program) // => 2
  * ```
  *
  * @category constructors
@@ -433,7 +442,7 @@ export declare const bounded: <A, E = never>(capacity: number) => Effect<Queue<A
  *
  * **Example** (Creating sliding queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -448,8 +457,10 @@ export declare const bounded: <A, E = never>(capacity: number) => Effect<Queue<A
  *   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
@@ -467,7 +478,7 @@ export declare const sliding: <A, E = never>(capacity: number) => Effect<Queue<A
  *
  * **Example** (Creating dropping queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -476,15 +487,15 @@ export declare const sliding: <A, E = never>(capacity: number) => Effect<Queue<A
  *   // 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
@@ -501,7 +512,7 @@ export declare const dropping: <A, E = never>(capacity: number) => Effect<Queue<
  *
  * **Example** (Creating unbounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -514,12 +525,13 @@ export declare const dropping: <A, E = never>(capacity: number) => Effect<Queue<
  *
  *   // 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
@@ -537,7 +549,7 @@ export declare const unbounded: <A, E = never>() => Effect<Queue<A, E>>;
  *
  * **Example** (Offering a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -546,15 +558,16 @@ export declare const unbounded: <A, E = never>() => Effect<Queue<A, E>>;
  *   // 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 declare const offer: <A, E>(self: Enqueue<A, E>, message: Types.NoInfer<A>) => Effect<boolean>;
@@ -573,8 +586,8 @@ export declare const offer: <A, E>(self: Enqueue<A, E>, message: Types.NoInfer<A
  *
  * **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*() {
@@ -583,15 +596,16 @@ export declare const offer: <A, E>(self: Enqueue<A, E>, message: Types.NoInfer<A
  *   // 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 declare const offerUnsafe: <A, E>(self: Enqueue<A, E>, message: Types.NoInfer<A>) => boolean;
@@ -612,7 +626,7 @@ export declare const offerUnsafe: <A, E>(self: Enqueue<A, E>, message: Types.NoI
  *
  * **Example** (Offering multiple values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -620,11 +634,13 @@ export declare const offerUnsafe: <A, E>(self: Enqueue<A, E>, message: Types.NoI
  *
  *   // 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 declare const offerAll: <A, E>(self: Enqueue<A, E>, messages: Iterable<A>) => Effect<Array<A>>;
@@ -643,8 +659,8 @@ export declare const offerAll: <A, E>(self: Enqueue<A, E>, messages: Iterable<A>
  *
  * **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*() {
@@ -652,15 +668,16 @@ export declare const offerAll: <A, E>(self: Enqueue<A, E>, messages: Iterable<A>
  *
  *   // 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 declare const offerAllUnsafe: <A, E>(self: Enqueue<A, E>, messages: Iterable<A>) => Array<A>;
@@ -670,20 +687,21 @@ export declare const offerAllUnsafe: <A, E>(self: Enqueue<A, E>, messages: Itera
  *
  * **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
@@ -696,8 +714,8 @@ export declare const fail: <A, E>(self: Enqueue<A, E>, error: E) => Effect<boole
  *
  * **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)
@@ -705,11 +723,13 @@ export declare const fail: <A, E>(self: Enqueue<A, E>, error: E) => Effect<boole
  *   // 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
@@ -722,8 +742,8 @@ export declare const failCause: {
      *
      * **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)
@@ -731,11 +751,13 @@ export declare const failCause: {
      *   // 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
@@ -748,8 +770,8 @@ export declare const failCause: {
      *
      * **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)
@@ -757,11 +779,13 @@ export declare const failCause: {
      *   // 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
@@ -784,8 +808,8 @@ export declare const failCause: {
  *
  * **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)
@@ -793,11 +817,13 @@ export declare const failCause: {
  *   // 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
@@ -818,7 +844,7 @@ export declare const failCauseUnsafe: <A, E>(self: Enqueue<A, E>, cause: Cause<E
  *
  * **Example** (Ending queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -830,16 +856,16 @@ export declare const failCauseUnsafe: <A, E>(self: Enqueue<A, E>, cause: Cause<E
  *
  *   // 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
@@ -864,7 +890,7 @@ export declare const end: <A, E>(self: Enqueue<A, E | Done>) => Effect<boolean>;
  *
  * **Example** (Ending queues synchronously)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * // Create a queue and use unsafe operations
@@ -877,17 +903,19 @@ export declare const end: <A, E>(self: Enqueue<A, E | Done>) => Effect<boolean>;
  *
  *   // 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
@@ -904,7 +932,7 @@ export declare const endUnsafe: <A, E>(self: Enqueue<A, E | Done>) => boolean;
  *
  * **Example** (Interrupting queues gracefully)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -916,23 +944,21 @@ export declare const endUnsafe: <A, E>(self: Enqueue<A, E | Done>) => boolean;
  *
  *   // 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
@@ -950,7 +976,7 @@ export declare const interrupt: <A, E>(self: Enqueue<A, E>) => Effect<boolean>;
  *
  * **Example** (Shutting down queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -962,12 +988,13 @@ export declare const interrupt: <A, E>(self: Enqueue<A, E>) => Effect<boolean>;
  *
  *   // 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
@@ -984,8 +1011,8 @@ export declare const shutdown: <A, E>(self: Enqueue<A, E>) => Effect<boolean>;
  *
  * **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)
@@ -995,16 +1022,16 @@ export declare const shutdown: <A, E>(self: Enqueue<A, E>) => Effect<boolean>;
  *
  *   // 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
@@ -1027,7 +1054,7 @@ export declare const clear: <A, E>(self: Dequeue<A, E>) => Effect<Array<A>, Pull
  *
  * **Example** (Taking all available values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1038,8 +1065,10 @@ export declare const clear: <A, E>(self: Dequeue<A, E>) => Effect<Array<A>, Pull
  *
  *   // 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
@@ -1051,7 +1080,7 @@ export declare const takeAll: <A, E>(self: Dequeue<A, E>) => Effect<Arr.NonEmpty
  *
  * **Example** (Collecting values until completion)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1059,13 +1088,13 @@ export declare const takeAll: <A, E>(self: Dequeue<A, E>) => Effect<Arr.NonEmpty
  *
  *   // 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
@@ -1084,7 +1113,7 @@ export declare const collect: <A, E>(self: Dequeue<A, E | Done>) => Effect<Array
  *
  * **Example** (Taking a fixed number of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1095,16 +1124,16 @@ export declare const collect: <A, E>(self: Dequeue<A, E | Done>) => Effect<Array
  *
  *   // 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
@@ -1123,7 +1152,7 @@ export declare const takeN: <A, E>(self: Dequeue<A, E>, n: number) => Effect<Arr
  *
  * **Example** (Taking a bounded batch of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1134,15 +1163,16 @@ export declare const takeN: <A, E>(self: Dequeue<A, E>, n: number) => Effect<Arr
  *
  *   // 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
@@ -1160,8 +1190,8 @@ export declare const takeBetween: <A, E>(self: Dequeue<A, E>, min: number, max:
  *
  * **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)
@@ -1173,18 +1203,16 @@ export declare const takeBetween: <A, E>(self: Dequeue<A, E>, min: number, max:
  *   // 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
@@ -1202,7 +1230,7 @@ export declare const take: <A, E>(self: Dequeue<A, E>) => Effect<A, E>;
  *
  * **Example** (Polling without blocking)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1210,15 +1238,16 @@ export declare const take: <A, E>(self: Dequeue<A, E>) => Effect<A, E>;
  *
  *   // 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
@@ -1234,7 +1263,7 @@ export declare const poll: <A, E>(self: Dequeue<A, E>) => Effect<Option.Option<A
  *
  * **Example** (Peeking at the next value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1243,8 +1272,10 @@ export declare const poll: <A, E>(self: Dequeue<A, E>) => Effect<Option.Option<A
  *
  *   // 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
@@ -1267,8 +1298,8 @@ export declare const peek: <A, E>(self: Dequeue<A, E>) => Effect<A, E>;
  *
  * **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*() {
@@ -1280,15 +1311,15 @@ export declare const peek: <A, E>(self: Dequeue<A, E>) => Effect<A, E>;
  *
  *   // 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
@@ -1331,34 +1362,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
@@ -1370,22 +1403,25 @@ export declare const size: <A, E>(self: Dequeue<A, E>) => Effect<number>;
  *
  * **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 declare const isFull: <A, E>(self: Dequeue<A, E>) => Effect<boolean>;
@@ -1399,20 +1435,21 @@ export declare const isFull: <A, E>(self: Dequeue<A, E>) => Effect<boolean>;
  *
  * **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)
@@ -1421,15 +1458,16 @@ export declare const isFull: <A, E>(self: Dequeue<A, E>) => Effect<boolean>;
  *
  *   // 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
@@ -1446,22 +1484,25 @@ export declare const sizeUnsafe: <A, E>(self: Dequeue<A, E>) => number;
  *
  * **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 declare const isFullUnsafe: <A, E>(self: Dequeue<A, E>) => boolean;
@@ -1471,15 +1512,15 @@ export declare const isFullUnsafe: <A, E>(self: Dequeue<A, E>) => boolean;
  *
  * **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"
  *   })
  *
@@ -1489,11 +1530,11 @@ export declare const isFullUnsafe: <A, E>(self: Dequeue<A, E>) => boolean;
  *   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
@@ -1506,15 +1547,15 @@ export declare const into: {
      *
      * **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"
      *   })
      *
@@ -1524,11 +1565,11 @@ export declare const into: {
      *   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
@@ -1541,15 +1582,15 @@ export declare const into: {
      *
      * **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"
      *   })
      *
@@ -1559,11 +1600,11 @@ export declare const into: {
      *   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