effect 4.0.0-beta.101 → 4.0.0-beta.103

package/dist/TxQueue.d.ts

@@ -31,19 +31,11 @@ import type * as Types from "./Types.ts";
  *
  * **Example** (Inspecting queue lifecycle states)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { TxQueue } from "effect"
  *
- * // State progression example
- * declare const state: TxQueue.State<string, Error>
- *
- * if (state._tag === "Open") {
- *   console.log("Queue is accepting new items")
- * } else if (state._tag === "Closing") {
- *   console.log("Queue is draining, cause:", state.cause)
- * } else {
- *   console.log("Queue is done, cause:", state.cause)
- * }
+ * const state: TxQueue.State<string, Error> = { _tag: "Open" }
+ * state._tag // => "Open"
  * ```
  *
  * @category models
@@ -132,7 +124,7 @@ export interface TxQueueState extends Inspectable {
  *
  * **Example** (Offering values through enqueue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  * import type { Cause } from "effect"
  *
@@ -153,7 +145,11 @@ export interface TxQueueState extends Inspectable {
  *   >(5)
  *   yield* TxQueue.offer(completableQueue, "task")
  *   yield* TxQueue.end(completableQueue)
+ *
+ *   return accepted
  * })
+ *
+ * await Effect.runPromise(program) // => true
  * ```
  *
  * @category models
@@ -168,7 +164,7 @@ export interface TxEnqueue<in A, in E = never> extends TxQueueState {
  *
  * **Example** (Taking values through dequeue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -176,7 +172,6 @@ export interface TxEnqueue<in A, in E = never> extends TxQueueState {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *   yield* TxQueue.offer(queue, 42)
  *   const item = yield* TxQueue.take(queue)
- *   console.log(item) // 42
  *
  *   // Queue with error channel - errors propagate through E-channel
  *   const faultTolerantQueue = yield* TxQueue.bounded<number, string>(10)
@@ -185,7 +180,10 @@ export interface TxEnqueue<in A, in E = never> extends TxQueueState {
  *   // All dequeue operations now fail with the error directly
  *   const takeResult = yield* Effect.flip(TxQueue.take(faultTolerantQueue)) // "processing failed"
  *   const peekResult = yield* Effect.flip(TxQueue.peek(faultTolerantQueue)) // "processing failed"
+ *   return [item, takeResult, peekResult] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [42, "processing failed", "processing failed"]
  * ```
  *
  * @category models
@@ -200,7 +198,7 @@ export interface TxDequeue<out A, out E = never> extends TxQueueState {
  *
  * **Example** (Combining enqueue and dequeue operations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -210,7 +208,6 @@ export interface TxDequeue<out A, out E = never> extends TxQueueState {
  *   // Single operations - automatically transactional
  *   const accepted = yield* TxQueue.offer(queue, 42)
  *   const item = yield* TxQueue.take(queue) // Effect<number, never>
- *   console.log(item) // 42
  *
  *   // Queue with error channel
  *   const faultTolerantQueue = yield* TxQueue.bounded<number, string>(10)
@@ -218,8 +215,10 @@ export interface TxDequeue<out A, out E = never> extends TxQueueState {
  *   // Operations can handle queue-level failures
  *   yield* TxQueue.fail(faultTolerantQueue, "queue failed")
  *   const result = yield* Effect.flip(TxQueue.take(faultTolerantQueue))
- *   console.log(result) // "queue failed"
+ *   return [accepted, item, result] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [true, 42, "queue failed"]
  * ```
  *
  * @category models
@@ -233,15 +232,11 @@ export interface TxQueue<in out A, in out E = never> extends TxEnqueue<A, E>, Tx
  *
  * **Example** (Checking enqueue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { TxQueue } from "effect"
  *
- * declare const someValue: unknown
- *
- * if (TxQueue.isTxEnqueue(someValue)) {
- *   // someValue is now typed as TxEnqueue<unknown, unknown>
- *   console.log("This is a TxEnqueue")
- * }
+ * const someValue: unknown = {}
+ * TxQueue.isTxEnqueue(someValue) // => false
  * ```
  *
  * @category guards
@@ -253,15 +248,11 @@ export declare const isTxEnqueue: <A = unknown, E = unknown>(u: unknown) => u is
  *
  * **Example** (Checking dequeue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { TxQueue } from "effect"
  *
- * declare const someValue: unknown
- *
- * if (TxQueue.isTxDequeue(someValue)) {
- *   // someValue is now typed as TxDequeue<unknown, unknown>
- *   console.log("This is a TxDequeue")
- * }
+ * const someValue: unknown = {}
+ * TxQueue.isTxDequeue(someValue) // => false
  * ```
  *
  * @category guards
@@ -273,15 +264,11 @@ export declare const isTxDequeue: <A = unknown, E = unknown>(u: unknown) => u is
  *
  * **Example** (Checking queue handles)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { TxQueue } from "effect"
  *
- * declare const someValue: unknown
- *
- * if (TxQueue.isTxQueue(someValue)) {
- *   // someValue is now typed as TxQueue<unknown, unknown>
- *   console.log("This is a TxQueue")
- * }
+ * const someValue: unknown = {}
+ * TxQueue.isTxQueue(someValue) // => false
  * ```
  *
  * @category guards
@@ -297,7 +284,7 @@ export declare const isTxQueue: <A = unknown, E = unknown>(u: unknown) => u is T
  *
  * **Example** (Creating bounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -311,9 +298,10 @@ export declare const isTxQueue: <A = unknown, E = unknown>(u: unknown) => u is T
  *   yield* TxQueue.offer(queue, 1)
  *   yield* TxQueue.offer(queue, 2)
  *
- *   const item = yield* TxQueue.take(queue)
- *   console.log(item) // 1
+ *   return yield* TxQueue.take(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => 1
  * ```
  *
  * @category constructors
@@ -329,7 +317,7 @@ export declare const bounded: <A = never, E = never>(capacity: number) => Effect
  *
  * **Example** (Creating unbounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -343,9 +331,10 @@ export declare const bounded: <A = never, E = never>(capacity: number) => Effect
  *   yield* TxQueue.offer(queue, "hello")
  *   yield* TxQueue.offer(queue, "world")
  *
- *   const size = yield* TxQueue.size(queue)
- *   console.log(size) // 2
+ *   return yield* TxQueue.size(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => 2
  * ```
  *
  * @category constructors
@@ -361,7 +350,7 @@ export declare const unbounded: <A = never, E = never>() => Effect.Effect<TxQueu
  *
  * **Example** (Creating dropping queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -373,9 +362,10 @@ export declare const unbounded: <A = never, E = never>() => Effect.Effect<TxQueu
  *   yield* TxQueue.offer(queue, 2)
  *
  *   // This will be dropped (returns false)
- *   const accepted = yield* TxQueue.offer(queue, 3)
- *   console.log(accepted) // false
+ *   return yield* TxQueue.offer(queue, 3)
  * })
+ *
+ * await Effect.runPromise(program) // => false
  * ```
  *
  * @category constructors
@@ -391,7 +381,7 @@ export declare const dropping: <A = never, E = never>(capacity: number) => Effec
  *
  * **Example** (Creating sliding queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -405,9 +395,10 @@ export declare const dropping: <A = never, E = never>(capacity: number) => Effec
  *   // This will evict item 1 and add 3
  *   yield* TxQueue.offer(queue, 3)
  *
- *   const item = yield* TxQueue.take(queue)
- *   console.log(item) // 2 (item 1 was evicted)
+ *   return yield* TxQueue.take(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => 2
  * ```
  *
  * @category constructors
@@ -423,16 +414,17 @@ export declare const sliding: <A = never, E = never>(capacity: number) => Effect
  *
  * **Example** (Offering a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   // Offer an item - returns true if accepted
- *   const accepted = yield* TxQueue.offer(queue, 42)
- *   console.log(accepted) // true
+ *   return yield* TxQueue.offer(queue, 42)
  * })
+ *
+ * await Effect.runPromise(program) // => true
  * ```
  *
  * @category combinators
@@ -448,16 +440,17 @@ export declare const offer: {
      *
      * **Example** (Offering a value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number>(10)
      *
      *   // Offer an item - returns true if accepted
-     *   const accepted = yield* TxQueue.offer(queue, 42)
-     *   console.log(accepted) // true
+     *   return yield* TxQueue.offer(queue, 42)
      * })
+     *
+     * await Effect.runPromise(program) // => true
      * ```
      *
      * @category combinators
@@ -473,16 +466,17 @@ export declare const offer: {
      *
      * **Example** (Offering a value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number>(10)
      *
      *   // Offer an item - returns true if accepted
-     *   const accepted = yield* TxQueue.offer(queue, 42)
-     *   console.log(accepted) // true
+     *   return yield* TxQueue.offer(queue, 42)
      * })
+     *
+     * await Effect.runPromise(program) // => true
      * ```
      *
      * @category combinators
@@ -500,17 +494,17 @@ export declare const offer: {
  *
  * **Example** (Offering multiple values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   // Offer multiple items - returns rejected items as array
- *   const rejected = yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
- *   console.log(rejected) // [] if all accepted
- *   console.log(rejected.length) // 0
+ *   return yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
  * })
+ *
+ * await Effect.runPromise(program) // => []
  * ```
  *
  * @category combinators
@@ -527,17 +521,17 @@ export declare const offerAll: {
      *
      * **Example** (Offering multiple values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number>(10)
      *
      *   // Offer multiple items - returns rejected items as array
-     *   const rejected = yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
-     *   console.log(rejected) // [] if all accepted
-     *   console.log(rejected.length) // 0
+     *   return yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
      * })
+     *
+     * await Effect.runPromise(program) // => []
      * ```
      *
      * @category combinators
@@ -554,17 +548,17 @@ export declare const offerAll: {
      *
      * **Example** (Offering multiple values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number>(10)
      *
      *   // Offer multiple items - returns rejected items as array
-     *   const rejected = yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
-     *   console.log(rejected) // [] if all accepted
-     *   console.log(rejected.length) // 0
+     *   return yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
      * })
+     *
+     * await Effect.runPromise(program) // => []
      * ```
      *
      * @category combinators
@@ -582,8 +576,8 @@ export declare const offerAll: {
  *
  * **Example** (Taking a value)
  *
- * ```ts
- * import { Effect, TxQueue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, string>(10)
@@ -591,13 +585,14 @@ export declare const offerAll: {
  *
  *   // Take an item - blocks if empty
  *   const item = yield* TxQueue.take(queue)
- *   console.log(item) // 42
  *
  *   // When queue fails, take fails with the same error
  *   yield* TxQueue.fail(queue, "queue error")
- *   const result = yield* Effect.flip(TxQueue.take(queue))
- *   console.log(result) // "queue error"
+ *   const result = yield* Effect.exit(TxQueue.take(queue))
+ *   return [item, result] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [42, Exit.fail("queue error")]
  * ```
  *
  * @category combinators
@@ -609,7 +604,7 @@ export declare const take: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<A, E>;
  *
  * **Example** (Polling without blocking)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -617,12 +612,13 @@ export declare const take: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<A, E>;
  *
  *   // Poll returns Option.none if empty
  *   const maybe = yield* TxQueue.poll(queue)
- *   console.log(Option.isNone(maybe)) // true
  *
  *   yield* TxQueue.offer(queue, 42)
  *   const item = yield* TxQueue.poll(queue)
- *   console.log(Option.getOrNull(item)) // 42
+ *   return [maybe, item] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [Option.none(), Option.some(42)]
  * ```
  *
  * @category combinators
@@ -638,17 +634,15 @@ export declare const poll: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Option
  *
  * **Example** (Taking all queued values)
  *
- * ```ts
- * import { Array, Effect, TxQueue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, string>(10)
  *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
  *
  *   // Take all items atomically - returns NonEmptyArray
- *   const items = yield* TxQueue.takeAll(queue)
- *   console.log(items) // [1, 2, 3, 4, 5]
- *   console.log(Array.isArrayNonEmpty(items)) // true
+ *   return yield* TxQueue.takeAll(queue)
  * })
  *
  * // Error propagation example
@@ -658,9 +652,11 @@ export declare const poll: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Option
  *   yield* TxQueue.fail(queue, "processing error")
  *
  *   // takeAll() propagates the queue error through E-channel
- *   const result = yield* Effect.flip(TxQueue.takeAll(queue))
- *   console.log(result) // "processing error"
+ *   return yield* Effect.exit(TxQueue.takeAll(queue))
  * })
+ *
+ * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
+ * await Effect.runPromise(errorExample) // => Exit.fail("processing error")
  * ```
  *
  * @category combinators
@@ -676,7 +672,7 @@ export declare const takeAll: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Arr
  *
  * **Example** (Taking a fixed number of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -684,13 +680,14 @@ export declare const takeAll: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<Arr
  *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4])
  *
  *   const items = yield* TxQueue.takeN(queue, 4)
- *   console.log(items) // [1, 2, 3, 4]
  *
  *   // This requests more than capacity (5), so takes all available (up to 5)
  *   yield* TxQueue.offerAll(queue, [5, 6, 7, 8, 9])
  *   const all = yield* TxQueue.takeN(queue, 10)
- *   console.log(all) // [5, 6, 7, 8, 9]
+ *   return [items, all] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [[1, 2, 3, 4], [5, 6, 7, 8, 9]]
  * ```
  *
  * @category combinators
@@ -706,7 +703,7 @@ export declare const takeN: {
      *
      * **Example** (Taking a fixed number of values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -714,13 +711,14 @@ export declare const takeN: {
      *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4])
      *
      *   const items = yield* TxQueue.takeN(queue, 4)
-     *   console.log(items) // [1, 2, 3, 4]
      *
      *   // This requests more than capacity (5), so takes all available (up to 5)
      *   yield* TxQueue.offerAll(queue, [5, 6, 7, 8, 9])
      *   const all = yield* TxQueue.takeN(queue, 10)
-     *   console.log(all) // [5, 6, 7, 8, 9]
+     *   return [items, all] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [[1, 2, 3, 4], [5, 6, 7, 8, 9]]
      * ```
      *
      * @category combinators
@@ -736,7 +734,7 @@ export declare const takeN: {
      *
      * **Example** (Taking a fixed number of values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -744,13 +742,14 @@ export declare const takeN: {
      *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4])
      *
      *   const items = yield* TxQueue.takeN(queue, 4)
-     *   console.log(items) // [1, 2, 3, 4]
      *
      *   // This requests more than capacity (5), so takes all available (up to 5)
      *   yield* TxQueue.offerAll(queue, [5, 6, 7, 8, 9])
      *   const all = yield* TxQueue.takeN(queue, 10)
-     *   console.log(all) // [5, 6, 7, 8, 9]
+     *   return [items, all] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [[1, 2, 3, 4], [5, 6, 7, 8, 9]]
      * ```
      *
      * @category combinators
@@ -768,7 +767,7 @@ export declare const takeN: {
  *
  * **Example** (Taking batches within bounds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -777,15 +776,16 @@ export declare const takeN: {
  *
  *   // Take between 2 and 5 items
  *   const batch1 = yield* TxQueue.takeBetween(queue, 2, 5)
- *   console.log(batch1) // [1, 2, 3, 4, 5] - took 5 (up to max)
  *
  *   // Take between 1 and 10 items (but only 3 remain)
  *   const batch2 = yield* TxQueue.takeBetween(queue, 1, 10)
- *   console.log(batch2) // [6, 7, 8] - took 3 (all remaining)
  *
  *   // Would wait for at least 1 item to be available
  *   // const batch3 = yield* TxQueue.takeBetween(queue, 1, 3)
+ *   return [batch1, batch2] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]
  * ```
  *
  * @category taking
@@ -802,7 +802,7 @@ export declare const takeBetween: {
      *
      * **Example** (Taking batches within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -811,15 +811,16 @@ export declare const takeBetween: {
      *
      *   // Take between 2 and 5 items
      *   const batch1 = yield* TxQueue.takeBetween(queue, 2, 5)
-     *   console.log(batch1) // [1, 2, 3, 4, 5] - took 5 (up to max)
      *
      *   // Take between 1 and 10 items (but only 3 remain)
      *   const batch2 = yield* TxQueue.takeBetween(queue, 1, 10)
-     *   console.log(batch2) // [6, 7, 8] - took 3 (all remaining)
      *
      *   // Would wait for at least 1 item to be available
      *   // const batch3 = yield* TxQueue.takeBetween(queue, 1, 3)
+     *   return [batch1, batch2] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]
      * ```
      *
      * @category taking
@@ -836,7 +837,7 @@ export declare const takeBetween: {
      *
      * **Example** (Taking batches within bounds)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -845,15 +846,16 @@ export declare const takeBetween: {
      *
      *   // Take between 2 and 5 items
      *   const batch1 = yield* TxQueue.takeBetween(queue, 2, 5)
-     *   console.log(batch1) // [1, 2, 3, 4, 5] - took 5 (up to max)
      *
      *   // Take between 1 and 10 items (but only 3 remain)
      *   const batch2 = yield* TxQueue.takeBetween(queue, 1, 10)
-     *   console.log(batch2) // [6, 7, 8] - took 3 (all remaining)
      *
      *   // Would wait for at least 1 item to be available
      *   // const batch3 = yield* TxQueue.takeBetween(queue, 1, 3)
+     *   return [batch1, batch2] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]
      * ```
      *
      * @category taking
@@ -870,8 +872,8 @@ export declare const takeBetween: {
  *
  * **Example** (Peeking without removing values)
  *
- * ```ts
- * import { Effect, TxQueue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Exit, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, string>(10)
@@ -879,11 +881,10 @@ export declare const takeBetween: {
  *
  *   // Peek at the next item without removing it
  *   const item = yield* TxQueue.peek(queue)
- *   console.log(item) // 42
  *
  *   // Item is still in the queue
  *   const size = yield* TxQueue.size(queue)
- *   console.log(size) // 1
+ *   return [item, size] as const
  * })
  *
  * // Error handling example
@@ -892,9 +893,11 @@ export declare const takeBetween: {
  *   yield* TxQueue.fail(queue, "queue failed")
  *
  *   // peek() propagates the queue error through E-channel
- *   const result = yield* Effect.flip(TxQueue.peek(queue))
- *   console.log(result) // "queue failed"
+ *   return yield* Effect.exit(TxQueue.peek(queue))
  * })
+ *
+ * await Effect.runPromise(program) // => [42, 1]
+ * await Effect.runPromise(errorExample) // => Exit.fail("queue failed")
  * ```
  *
  * @category combinators
@@ -906,16 +909,17 @@ export declare const peek: <A, E>(self: TxDequeue<A, E>) => Effect.Effect<A, E>;
  *
  * **Example** (Reading queue size)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *   yield* TxQueue.offerAll(queue, [1, 2, 3])
  *
- *   const size = yield* TxQueue.size(queue)
- *   console.log(size) // 3
+ *   return yield* TxQueue.size(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => 3
  * ```
  *
  * @category combinators
@@ -927,22 +931,23 @@ export declare const size: (self: TxQueueState) => Effect.Effect<number>;
  *
  * **Example** (Checking whether a queue is empty)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   const empty = yield* TxQueue.isEmpty(queue)
- *   console.log(empty) // true
  *
  *   yield* TxQueue.offer(queue, 42)
  *   const stillEmpty = yield* TxQueue.isEmpty(queue)
- *   console.log(stillEmpty) // false
+ *   return [empty, stillEmpty] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [true, false]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 2.0.0
  */
 export declare const isEmpty: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -951,22 +956,23 @@ export declare const isEmpty: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Checking whether a queue is full)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(2)
  *
  *   const full = yield* TxQueue.isFull(queue)
- *   console.log(full) // false
  *
  *   yield* TxQueue.offerAll(queue, [1, 2])
  *   const nowFull = yield* TxQueue.isFull(queue)
- *   console.log(nowFull) // true
+ *   return [full, nowFull] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 2.0.0
  */
 export declare const isFull: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -979,7 +985,7 @@ export declare const isFull: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Interrupting queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -987,9 +993,10 @@ export declare const isFull: (self: TxQueueState) => Effect.Effect<boolean>;
  *   yield* TxQueue.offer(queue, 42)
  *
  *   // Interrupt gracefully - allows remaining items to be consumed
- *   const result = yield* TxQueue.interrupt(queue)
- *   console.log(result) // true
+ *   return yield* TxQueue.interrupt(queue)
  * })
+ *
+ * await Effect.runPromise(program) // => true
  * ```
  *
  * @category combinators
@@ -1005,16 +1012,17 @@ export declare const interrupt: <A, E>(self: TxEnqueue<A, E>) => Effect.Effect<b
  *
  * **Example** (Failing queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, string>(10)
  *
  *   // Fail the queue with an error
- *   const result = yield* TxQueue.fail(queue, "connection lost")
- *   console.log(result) // true
+ *   return yield* TxQueue.fail(queue, "connection lost")
  * })
+ *
+ * await Effect.runPromise(program) // => true
  * ```
  *
  * @category combinators
@@ -1030,16 +1038,17 @@ export declare const fail: {
      *
      * **Example** (Failing queues)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number, string>(10)
      *
      *   // Fail the queue with an error
-     *   const result = yield* TxQueue.fail(queue, "connection lost")
-     *   console.log(result) // true
+     *   return yield* TxQueue.fail(queue, "connection lost")
      * })
+     *
+     * await Effect.runPromise(program) // => true
      * ```
      *
      * @category combinators
@@ -1055,16 +1064,17 @@ export declare const fail: {
      *
      * **Example** (Failing queues)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const queue = yield* TxQueue.bounded<number, string>(10)
      *
      *   // Fail the queue with an error
-     *   const result = yield* TxQueue.fail(queue, "connection lost")
-     *   console.log(result) // true
+     *   return yield* TxQueue.fail(queue, "connection lost")
      * })
+     *
+     * await Effect.runPromise(program) // => true
      * ```
      *
      * @category combinators
@@ -1081,7 +1091,7 @@ export declare const fail: {
  *
  * **Example** (Failing queues with causes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1090,8 +1100,10 @@ export declare const fail: {
  *   // Complete with specific cause
  *   const cause = Cause.interrupt()
  *   const result = yield* TxQueue.failCause(queue, cause)
- *   console.log(result) // true
+ *   return [cause, result] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [Cause.interrupt(), true]
  * ```
  *
  * @category combinators
@@ -1107,7 +1119,7 @@ export declare const failCause: {
      *
      * **Example** (Failing queues with causes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause, Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -1116,8 +1128,10 @@ export declare const failCause: {
      *   // Complete with specific cause
      *   const cause = Cause.interrupt()
      *   const result = yield* TxQueue.failCause(queue, cause)
-     *   console.log(result) // true
+     *   return [cause, result] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [Cause.interrupt(), true]
      * ```
      *
      * @category combinators
@@ -1133,7 +1147,7 @@ export declare const failCause: {
      *
      * **Example** (Failing queues with causes)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Cause, Effect, TxQueue } from "effect"
      *
      * const program = Effect.gen(function*() {
@@ -1142,8 +1156,10 @@ export declare const failCause: {
      *   // Complete with specific cause
      *   const cause = Cause.interrupt()
      *   const result = yield* TxQueue.failCause(queue, cause)
-     *   console.log(result) // true
+     *   return [cause, result] as const
      * })
+     *
+     * await Effect.runPromise(program) // => [Cause.interrupt(), true]
      * ```
      *
      * @category combinators
@@ -1160,23 +1176,23 @@ export declare const failCause: {
  *
  * **Example** (Ending queues)
  *
- * ```ts
- * import { Cause, Effect, TxQueue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Effect, Exit, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, Cause.Done>(10)
  *
  *   // Signal the end of the queue
  *   const result = yield* TxQueue.end(queue)
- *   console.log(result) // true
  *
  *   // All operations will now fail with Done
- *   const takeResult = yield* Effect.flip(TxQueue.take(queue))
- *   console.log(Cause.isDone(takeResult)) // true
+ *   const takeResult = yield* Effect.exit(TxQueue.take(queue))
  *
- *   const peekResult = yield* Effect.flip(TxQueue.peek(queue))
- *   console.log(Cause.isDone(peekResult)) // true
+ *   const peekResult = yield* Effect.exit(TxQueue.peek(queue))
+ *   return [result, takeResult, peekResult] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [true, Exit.fail(Cause.Done()), Exit.fail(Cause.Done())]
  * ```
  *
  * @category combinators
@@ -1184,16 +1200,15 @@ export declare const failCause: {
  */
 export declare const end: <A, E>(self: TxEnqueue<A, E | Cause.Done>) => Effect.Effect<boolean>;
 /**
- * Removes and returns all currently buffered elements without changing the
- * queue state.
+ * Removes and returns all currently buffered elements.
  *
  * **Details**
  *
- * If the queue is already done with a `Cause.Done` error, returns an empty array. If the queue is done for any other cause, including interruption or failure, that cause is propagated.
+ * If the queue is closing, draining its buffered elements transitions it to done. If the queue is already done with a `Cause.Done` error, returns an empty array. If the queue is done for any other cause, including interruption or failure, that cause is propagated.
  *
  * **Example** (Clearing queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1201,14 +1216,14 @@ export declare const end: <A, E>(self: TxEnqueue<A, E | Cause.Done>) => Effect.E
  *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
  *
  *   const sizeBefore = yield* TxQueue.size(queue)
- *   console.log(sizeBefore) // 5
  *
  *   const cleared = yield* TxQueue.clear(queue)
- *   console.log(cleared) // [1, 2, 3, 4, 5]
  *
  *   const sizeAfter = yield* TxQueue.size(queue)
- *   console.log(sizeAfter) // 0
+ *   return [sizeBefore, cleared, sizeAfter] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [5, [1, 2, 3, 4, 5], 0]
  * ```
  *
  * @category combinators
@@ -1224,7 +1239,7 @@ export declare const clear: <A, E>(self: TxEnqueue<A, E>) => Effect.Effect<Array
  *
  * **Example** (Shutting down queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1232,16 +1247,16 @@ export declare const clear: <A, E>(self: TxEnqueue<A, E>) => Effect.Effect<Array
  *   yield* TxQueue.offerAll(queue, [1, 2, 3, 4, 5])
  *
  *   const sizeBefore = yield* TxQueue.size(queue)
- *   console.log(sizeBefore) // 5
  *
  *   yield* TxQueue.shutdown(queue)
  *
  *   const sizeAfter = yield* TxQueue.size(queue)
- *   console.log(sizeAfter) // 0 (cleared)
  *
  *   const isShutdown = yield* TxQueue.isShutdown(queue)
- *   console.log(isShutdown) // true (interrupted)
+ *   return [sizeBefore, sizeAfter, isShutdown] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [5, 0, true]
  * ```
  *
  * @category combinators
@@ -1253,22 +1268,23 @@ export declare const shutdown: <A, E>(self: TxEnqueue<A, E>) => Effect.Effect<bo
  *
  * **Example** (Checking open state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   const open = yield* TxQueue.isOpen(queue)
- *   console.log(open) // true
  *
  *   yield* TxQueue.interrupt(queue)
  *   const stillOpen = yield* TxQueue.isOpen(queue)
- *   console.log(stillOpen) // false
+ *   return [open, stillOpen] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [true, false]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 4.0.0
  */
 export declare const isOpen: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -1277,7 +1293,7 @@ export declare const isOpen: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Checking closing state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1285,15 +1301,16 @@ export declare const isOpen: (self: TxQueueState) => Effect.Effect<boolean>;
  *   yield* TxQueue.offer(queue, 42)
  *
  *   const closing = yield* TxQueue.isClosing(queue)
- *   console.log(closing) // false
  *
  *   yield* TxQueue.interrupt(queue)
  *   const nowClosing = yield* TxQueue.isClosing(queue)
- *   console.log(nowClosing) // true
+ *   return [closing, nowClosing] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 4.0.0
  */
 export declare const isClosing: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -1302,22 +1319,23 @@ export declare const isClosing: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Checking done state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   const done = yield* TxQueue.isDone(queue)
- *   console.log(done) // false
  *
  *   yield* TxQueue.interrupt(queue)
  *   const nowDone = yield* TxQueue.isDone(queue)
- *   console.log(nowDone) // true
+ *   return [done, nowDone] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 4.0.0
  */
 export declare const isDone: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -1326,22 +1344,23 @@ export declare const isDone: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Checking shutdown state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number>(10)
  *
  *   const isShutdown = yield* TxQueue.isShutdown(queue)
- *   console.log(isShutdown) // false
  *
  *   yield* TxQueue.shutdown(queue)
  *   const nowShutdown = yield* TxQueue.isShutdown(queue)
- *   console.log(nowShutdown) // true
+ *   return [isShutdown, nowShutdown] as const
  * })
+ *
+ * await Effect.runPromise(program) // => [false, true]
  * ```
  *
- * @category combinators
+ * @category predicates
  * @since 2.0.0
  */
 export declare const isShutdown: (self: TxQueueState) => Effect.Effect<boolean>;
@@ -1350,19 +1369,20 @@ export declare const isShutdown: (self: TxQueueState) => Effect.Effect<boolean>;
  *
  * **Example** (Awaiting queue completion)
  *
- * ```ts
- * import { Effect, TxQueue } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Fiber, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const queue = yield* TxQueue.bounded<number, string>(10)
  *
- *   // In another fiber, end the queue
- *   yield* Effect.forkChild(Effect.delay(TxQueue.interrupt(queue), "100 millis"))
+ *   const waiter = yield* Effect.forkChild(TxQueue.awaitCompletion(queue))
+ *   yield* TxQueue.interrupt(queue)
  *
- *   // Wait for completion - succeeds when queue ends
- *   yield* TxQueue.awaitCompletion(queue)
- *   console.log("Queue completed successfully")
+ *   yield* Fiber.join(waiter)
+ *   return "Queue completed successfully"
  * })
+ *
+ * await Effect.runPromise(program) // => "Queue completed successfully"
  * ```
  *
  * @category combinators