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

package/dist/TxQueue.js

@@ -16,15 +16,11 @@ const TypeId = "~effect/transactions/TxQueue";
  *
  * **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
@@ -36,15 +32,11 @@ export const isTxEnqueue = u => hasProperty(u, EnqueueTypeId);
  *
  * **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
@@ -56,15 +48,11 @@ export const isTxDequeue = u => hasProperty(u, DequeueTypeId);
  *
  * **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
@@ -113,7 +101,7 @@ const TxQueueProto = {
  *
  * **Example** (Creating bounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -127,9 +115,10 @@ const TxQueueProto = {
  *   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
@@ -156,7 +145,7 @@ export const bounded = capacity => Effect.gen(function* () {
  *
  * **Example** (Creating unbounded queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -170,9 +159,10 @@ export const bounded = capacity => Effect.gen(function* () {
  *   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
@@ -199,7 +189,7 @@ export const unbounded = () => Effect.gen(function* () {
  *
  * **Example** (Creating dropping queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -211,9 +201,10 @@ export const unbounded = () => Effect.gen(function* () {
  *   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
@@ -240,7 +231,7 @@ export const dropping = capacity => Effect.gen(function* () {
  *
  * **Example** (Creating sliding queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -254,9 +245,10 @@ export const dropping = capacity => Effect.gen(function* () {
  *   // 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
@@ -286,16 +278,17 @@ export const sliding = capacity => Effect.gen(function* () {
  *
  * **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
@@ -339,32 +332,35 @@ export const offer = /*#__PURE__*/dual(2, (self, value) => Effect.gen(function*
  *
  * **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
  * @since 2.0.0
  */
-export const offerAll = /*#__PURE__*/dual(2, (self, values) => Effect.gen(function* () {
-  const rejected = [];
-  for (const value of values) {
-    const accepted = yield* offer(self, value);
-    if (!accepted) {
-      rejected.push(value);
+export const offerAll = /*#__PURE__*/dual(2, (self, values) => {
+  const valuesArray = Array.from(values);
+  return Effect.gen(function* () {
+    const rejected = [];
+    for (const value of valuesArray) {
+      const accepted = yield* offer(self, value);
+      if (!accepted) {
+        rejected.push(value);
+      }
     }
-  }
-  return rejected;
-}).pipe(Effect.tx));
+    return rejected;
+  }).pipe(Effect.tx);
+});
 /**
  * Takes the next item from the queue, retrying the transaction while the queue
  * is empty.
@@ -375,8 +371,8 @@ export const offerAll = /*#__PURE__*/dual(2, (self, values) => Effect.gen(functi
  *
  * **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)
@@ -384,13 +380,14 @@ export const offerAll = /*#__PURE__*/dual(2, (self, values) => Effect.gen(functi
  *
  *   // 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
@@ -427,7 +424,7 @@ export const take = self => Effect.gen(function* () {
  *
  * **Example** (Polling without blocking)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -435,12 +432,13 @@ export const take = self => Effect.gen(function* () {
  *
  *   // 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
@@ -457,6 +455,12 @@ export const poll = self => Effect.gen(function* () {
     return Option.none();
   }
   yield* TxChunk.drop(self.items, 1);
+  if (state._tag === "Closing" && (yield* isEmpty(self))) {
+    yield* TxRef.set(self.stateRef, {
+      _tag: "Done",
+      cause: state.cause
+    });
+  }
   return Option.some(head.value);
 }).pipe(Effect.tx);
 /**
@@ -468,17 +472,15 @@ export const poll = self => Effect.gen(function* () {
  *
  * **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
@@ -488,9 +490,11 @@ export const poll = self => Effect.gen(function* () {
  *   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
@@ -528,7 +532,7 @@ export const takeAll = self => Effect.gen(function* () {
  *
  * **Example** (Taking a fixed number of values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -536,13 +540,14 @@ export const takeAll = self => Effect.gen(function* () {
  *   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
@@ -610,7 +615,7 @@ export const takeN = /*#__PURE__*/dual(2, (self, n) => Effect.gen(function* () {
  *
  * **Example** (Taking batches within bounds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -619,15 +624,16 @@ export const takeN = /*#__PURE__*/dual(2, (self, n) => Effect.gen(function* () {
  *
  *   // 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
@@ -691,8 +697,8 @@ export const takeBetween = /*#__PURE__*/dual(3, (self, min, max) => Effect.gen(f
  *
  * **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)
@@ -700,11 +706,10 @@ export const takeBetween = /*#__PURE__*/dual(3, (self, min, max) => Effect.gen(f
  *
  *   // 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
@@ -713,9 +718,11 @@ export const takeBetween = /*#__PURE__*/dual(3, (self, min, max) => Effect.gen(f
  *   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
@@ -738,16 +745,17 @@ export const peek = self => Effect.gen(function* () {
  *
  * **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
@@ -759,22 +767,23 @@ export const size = self => TxChunk.size(self.items);
  *
  * **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 const isEmpty = self => TxChunk.isEmpty(self.items);
@@ -783,22 +792,23 @@ export const isEmpty = self => TxChunk.isEmpty(self.items);
  *
  * **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 const isFull = self => self.capacity === Number.POSITIVE_INFINITY ? Effect.succeed(false) : Effect.map(size(self), currentSize => currentSize >= self.capacity);
@@ -811,7 +821,7 @@ export const isFull = self => self.capacity === Number.POSITIVE_INFINITY ? Effec
  *
  * **Example** (Interrupting queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -819,9 +829,10 @@ export const isFull = self => self.capacity === Number.POSITIVE_INFINITY ? Effec
  *   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
@@ -837,16 +848,17 @@ export const interrupt = self => Effect.withFiber(fiber => failCause(self, Cause
  *
  * **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
@@ -874,7 +886,7 @@ export const fail = /*#__PURE__*/dual(2, (self, error) => Effect.gen(function* (
  *
  * **Example** (Failing queues with causes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Cause, Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -883,8 +895,10 @@ export const fail = /*#__PURE__*/dual(2, (self, error) => Effect.gen(function* (
  *   // 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
@@ -919,23 +933,23 @@ export const failCause = /*#__PURE__*/dual(2, (self, cause) => Effect.gen(functi
  *
  * **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
@@ -943,16 +957,15 @@ export const failCause = /*#__PURE__*/dual(2, (self, cause) => Effect.gen(functi
  */
 export const end = self => failCause(self, Cause.fail(Cause.Done()));
 /**
- * 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*() {
@@ -960,14 +973,14 @@ export const end = self => failCause(self, Cause.fail(Cause.Done()));
  *   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
@@ -984,6 +997,12 @@ export const clear = self => Effect.gen(function* () {
   }
   const chunk = yield* TxChunk.get(self.items);
   yield* TxChunk.set(self.items, Chunk.empty());
+  if (state._tag === "Closing") {
+    yield* TxRef.set(self.stateRef, {
+      _tag: "Done",
+      cause: state.cause
+    });
+  }
   return Chunk.toArray(chunk);
 }).pipe(Effect.tx);
 /**
@@ -995,7 +1014,7 @@ export const clear = self => Effect.gen(function* () {
  *
  * **Example** (Shutting down queues)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1003,23 +1022,23 @@ export const clear = self => Effect.gen(function* () {
  *   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
  * @since 2.0.0
  */
 export const shutdown = self => Effect.gen(function* () {
-  yield* Effect.ignore(clear(self));
+  yield* Effect.ignoreCause(clear(self));
   return yield* interrupt(self);
 }).pipe(Effect.tx);
 /**
@@ -1027,22 +1046,23 @@ export const shutdown = self => Effect.gen(function* () {
  *
  * **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 const isOpen = self => Effect.map(TxRef.get(self.stateRef), state => state._tag === "Open");
@@ -1051,7 +1071,7 @@ export const isOpen = self => Effect.map(TxRef.get(self.stateRef), state => stat
  *
  * **Example** (Checking closing state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, TxQueue } from "effect"
  *
  * const program = Effect.gen(function*() {
@@ -1059,15 +1079,16 @@ export const isOpen = self => Effect.map(TxRef.get(self.stateRef), state => stat
  *   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 const isClosing = self => Effect.map(TxRef.get(self.stateRef), state => state._tag === "Closing");
@@ -1076,22 +1097,23 @@ export const isClosing = self => Effect.map(TxRef.get(self.stateRef), state => s
  *
  * **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 const isDone = self => Effect.map(TxRef.get(self.stateRef), state => state._tag === "Done");
@@ -1100,22 +1122,23 @@ export const isDone = self => Effect.map(TxRef.get(self.stateRef), state => stat
  *
  * **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 const isShutdown = self => isDone(self);
@@ -1124,19 +1147,20 @@ export const isShutdown = self => isDone(self);
  *
  * **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