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

package/src/Channel.ts

@@ -26,6 +26,7 @@ import * as Iterable from "./Iterable.ts"
 import * as Latch from "./Latch.ts"
 import * as Layer from "./Layer.ts"
 import type { Severity } from "./LogLevel.ts"
+import * as MutableRef from "./MutableRef.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
@@ -67,12 +68,12 @@ export const TypeId: TypeId = "~effect/Channel"
  *
  * **Example** (Checking for channels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel } from "effect"
  *
  * const channel = Channel.succeed(42)
- * console.log(Channel.isChannel(channel)) // true
- * console.log(Channel.isChannel("not a channel")) // false
+ * Channel.isChannel(channel) // => true
+ * Channel.isChannel("not a channel") // => false
  * ```
  *
  * @category guards
@@ -109,8 +110,8 @@ export const isChannel = (
  *
  * **Example** (Typing channels)
  *
- * ```ts
- * import type { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // A channel that outputs numbers and requires no environment
  * type NumberChannel = Channel.Channel<number>
@@ -128,6 +129,9 @@ export const isChannel = (
  *   boolean, // InDone - input completion
  *   { db: string } // Env - required environment
  * >
+ *
+ * const channel: NumberChannel = Channel.succeed(1)
+ * Effect.runSync(Channel.runCollect(channel)) // => [1]
  * ```
  *
  * @category models
@@ -264,12 +268,13 @@ const ChannelProto = {
  *
  * **Example** (Creating channels from transforms)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.fromTransform((upstream, scope) =>
  *   Effect.succeed(upstream)
  * )
+ * await Effect.runPromise(Channel.runCollect(channel)) // => []
  * ```
  *
  * @category constructors
@@ -300,7 +305,7 @@ export const fromTransform = <OutElem, OutErr, OutDone, InElem, InErr, InDone, E
  *
  * **Example** (Transforming pull behavior)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Transform a channel by modifying its pull behavior
@@ -313,7 +318,7 @@ export const fromTransform = <OutElem, OutErr, OutDone, InElem, InErr, InDone, E
  *       Effect.map(pull, (value) => value * 2)
  *     )
  * )
- * // Outputs: 2, 4, 6
+ * await Effect.runPromise(Channel.runCollect(transformedChannel)) // => [2, 4, 6]
  * ```
  *
  * @category constructors
@@ -354,12 +359,18 @@ export const transformPull = <
  *
  * **Example** (Creating channels from pulls)
  *
- * ```ts
- * import { Channel, Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect } from "effect"
  *
- * const channel = Channel.fromPull(
- *   Effect.succeed(Effect.succeed(42))
- * )
+ * const channel = Channel.fromPull(Effect.sync(() => {
+ *   let emitted = false
+ *   return Effect.suspend(() => {
+ *     if (emitted) return Cause.done()
+ *     emitted = true
+ *     return Effect.succeed(42)
+ *   })
+ * }))
+ * await Effect.runPromise(Channel.runCollect(channel)) // => [42]
  * ```
  *
  * @category constructors
@@ -410,12 +421,13 @@ export const fromTransformBracket = <OutElem, OutErr, OutDone, InElem, InErr, In
  *
  * **Example** (Extracting channel transforms)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.succeed(42)
  * const transform = Channel.toTransform(channel)
- * // transform can now be used directly
+ * typeof transform // => "function"
+ * Effect.runSync(Channel.runCollect(channel)) // => [42]
  * ```
  *
  * @category destructors
@@ -433,10 +445,10 @@ export const toTransform = <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env
  *
  * **Example** (Reading the default chunk size)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel } from "effect"
  *
- * console.log(Channel.DefaultChunkSize) // 4096
+ * Channel.DefaultChunkSize // => 4096
  * ```
  *
  * @category constants
@@ -465,7 +477,7 @@ const asyncQueue = <A, E = never, R = never>(
  *
  * **Example** (Creating channels from callbacks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect, Queue } from "effect"
  *
  * const channel = Channel.callback<number>((queue) =>
@@ -473,8 +485,10 @@ const asyncQueue = <A, E = never, R = never>(
  *     yield* Queue.offer(queue, 1)
  *     yield* Queue.offer(queue, 2)
  *     yield* Queue.offer(queue, 3)
+ *     yield* Queue.end(queue)
  *   })
  * )
+ * await Effect.runPromise(Channel.runCollect(channel)) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -494,14 +508,15 @@ export const callback = <A, E = never, R = never>(
  *
  * **Example** (Creating array channels from callbacks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect, Queue } from "effect"
  *
  * const channel = Channel.callbackArray<number>(Effect.fn(function*(queue) {
  *   yield* Queue.offer(queue, 1)
  *   yield* Queue.offer(queue, 2)
+ *   yield* Queue.end(queue)
  * }))
- * // Emits arrays of numbers instead of individual numbers
+ * await Effect.runPromise(Channel.runCollect(channel)) // => [[1, 2]]
  * ```
  *
  * @category constructors
@@ -521,11 +536,11 @@ export const callbackArray = <A, E = never, R = never>(
  *
  * **Example** (Suspending channel creation)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.suspend(() => Channel.succeed(42))
- * // The inner channel is not created until the suspended channel is run
+ * Effect.runSync(Channel.runCollect(channel)) // => [42]
  * ```
  *
  * @category constructors
@@ -548,14 +563,16 @@ export const suspend = <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
  *
  * **Example** (Managing resources with acquire-use-release)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
+ * const released: Array<string> = []
  * const channel = Channel.acquireUseRelease(
  *   Effect.succeed("resource"),
  *   (resource) => Channel.succeed(resource.toUpperCase()),
- *   (resource, exit) => Effect.log(`Released: ${resource}`)
+ *   (resource, exit) => Effect.sync(() => released.push(resource))
  * )
+ * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [["RESOURCE"], ["resource"]]
  * ```
  *
  * @category constructors
@@ -591,13 +608,15 @@ export const acquireUseRelease = <A, E, R, OutElem, OutErr, OutDone, InElem, InE
  *
  * **Example** (Managing resources with acquire-release)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
+ * const released: Array<string> = []
  * const channel = Channel.acquireRelease(
  *   Effect.succeed("resource"),
- *   (resource, exit) => Effect.log(`Released: ${resource}`)
+ *   (resource, exit) => Effect.sync(() => released.push(resource))
  * )
+ * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [["resource"], ["resource"]]
  * ```
  *
  * @category constructors
@@ -616,13 +635,15 @@ export const acquireRelease: {
    *
    * **Example** (Managing resources with acquire-release)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
+   * const released: Array<string> = []
    * const channel = Channel.acquireRelease(
    *   Effect.succeed("resource"),
-   *   (resource, exit) => Effect.log(`Released: ${resource}`)
+   *   (resource, exit) => Effect.sync(() => released.push(resource))
    * )
+   * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [["resource"], ["resource"]]
    * ```
    *
    * @category constructors
@@ -641,13 +662,15 @@ export const acquireRelease: {
    *
    * **Example** (Managing resources with acquire-release)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
+   * const released: Array<string> = []
    * const channel = Channel.acquireRelease(
    *   Effect.succeed("resource"),
-   *   (resource, exit) => Effect.log(`Released: ${resource}`)
+   *   (resource, exit) => Effect.sync(() => released.push(resource))
    * )
+   * const observed = [await Effect.runPromise(Channel.runCollect(channel)), released] // => [["resource"], ["resource"]]
    * ```
    *
    * @category constructors
@@ -671,12 +694,12 @@ export const acquireRelease: {
  *
  * **Example** (Creating channels from iterators)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
  * const channel = Channel.fromIterator(() => numbers[Symbol.iterator]())
- * // Emits: 1, 2, 3, 4, 5
+ * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category constructors
@@ -698,11 +721,11 @@ export const fromIterator = <A, L>(iterator: LazyArg<Iterator<A, L>>): Channel<A
  *
  * **Example** (Creating channels from arrays)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.fromArray([1, 2, 3, 4, 5])
- * // Emits: 1, 2, 3, 4, 5
+ * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category constructors
@@ -719,12 +742,12 @@ export const fromArray = <A>(array: ReadonlyArray<A>): Channel<A> =>
  *
  * **Example** (Creating channels from chunks)
  *
- * ```ts
- * import { Channel, Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Chunk, Effect } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
  * const channel = Channel.fromChunk(chunk)
- * // Emits: 1, 2, 3
+ * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -737,8 +760,8 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Channel<A> => fromArray(Chu
  *
  * **Example** (Batching iterator output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create a channel from a simple iterator
  * const numberIterator = (): Iterator<number, string> => {
@@ -754,13 +777,13 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Channel<A> => fromArray(Chu
  * }
  *
  * const channel = Channel.fromIteratorArray(() => numberIterator(), 2)
- * // This will emit arrays: [0, 1], [2], then complete with "finished"
+ * Effect.runSync(Channel.runCollect(channel)) // => [[0, 1], [2]]
  * ```
  *
  * **Example** (Batching generator output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create channel from a generator function
  * function* fibonacci(): Generator<number, void, unknown> {
@@ -772,7 +795,7 @@ export const fromChunk = <A>(chunk: Chunk.Chunk<A>): Channel<A> => fromArray(Chu
  * }
  *
  * const fibChannel = Channel.fromIteratorArray(() => fibonacci(), 3)
- * // Emits: [0, 1, 1], [2, 3], then completes
+ * Effect.runSync(Channel.runCollect(fibChannel)) // => [[0, 1, 1], [2, 3]]
  * ```
  *
  * @category constructors
@@ -810,12 +833,12 @@ export const fromIteratorArray = <A, L>(
  *
  * **Example** (Creating channels from iterables)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const set = new Set([1, 2, 3])
  * const channel = Channel.fromIterable(set)
- * // Emits: 1, 2, 3
+ * Effect.runSync(Channel.runCollect(channel)) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -829,12 +852,12 @@ export const fromIterable = <A, L>(iterable: Iterable<A, L>): Channel<A, never,
  *
  * **Example** (Batching iterable output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
- * const channel = Channel.fromIterableArray(numbers)
- * // Emits arrays like: [1, 2, 3, 4], [5] (based on chunk size)
+ * const channel = Channel.fromIterableArray(numbers, 4)
+ * Effect.runSync(Channel.runCollect(channel)) // => [[1, 2, 3, 4], [5]]
  * ```
  *
  * @category constructors
@@ -850,11 +873,11 @@ export const fromIterableArray = <A, L>(
  *
  * **Example** (Creating channels that succeed)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.succeed(42)
- * // Emits: 42
+ * Effect.runSync(Channel.runCollect(channel)) // => [42]
  * ```
  *
  * @category constructors
@@ -867,11 +890,11 @@ export const succeed = <A>(value: A): Channel<A> => fromEffect(Effect.succeed(va
  *
  * **Example** (Ending with a value)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * const channel = Channel.end("done")
- * // Ends immediately with "done", emits nothing
+ * Effect.runSync(Channel.runCollect(channel)) // => []
  * ```
  *
  * @category constructors
@@ -893,8 +916,8 @@ export const endSync = <A>(evaluate: LazyArg<A>): Channel<never, never, A> =>
  *
  * **Example** (Computing values lazily)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * let requests = 0
  *
@@ -902,7 +925,7 @@ export const endSync = <A>(evaluate: LazyArg<A>): Channel<never, never, A> =>
  *   requests += 1
  *   return `request-${requests}`
  * })
- * // Emits "request-1" when the channel runs for the first time
+ * Effect.runSync(Channel.runCollect(channel)) // => ["request-1"]
  * ```
  *
  * @category constructors
@@ -915,8 +938,8 @@ export const sync = <A>(evaluate: LazyArg<A>): Channel<A> => fromEffect(Effect.s
  *
  * **Example** (Creating empty channels)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create an empty channel
  * const emptyChannel = Channel.empty
@@ -928,6 +951,8 @@ export const sync = <A>(evaluate: LazyArg<A>): Channel<A> => fromEffect(Effect.s
  * // Empty channel can be used as a no-op in conditional logic
  * const conditionalChannel = (shouldEmit: boolean) =>
  *   shouldEmit ? Channel.succeed("data") : Channel.empty
+ *
+ * Effect.runSync(Channel.runCollect(conditionalChannel(true))) // => ["data"]
  * ```
  *
  * @category constructors
@@ -940,7 +965,7 @@ export const empty: Channel<never> = fromPull(Effect.succeed(Cause.done()))
  *
  * **Example** (Creating non-terminating channels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel } from "effect"
  *
  * // Create a channel that never completes
@@ -955,6 +980,8 @@ export const empty: Channel<never> = fromPull(Effect.succeed(Cause.done()))
  * // Never channel is useful for testing or as a placeholder
  * const conditionalChannel = (shouldComplete: boolean) =>
  *   shouldComplete ? Channel.succeed("done") : Channel.never
+ *
+ * Channel.isChannel(conditionalChannel(false)) // => true
  * ```
  *
  * @category constructors
@@ -967,26 +994,11 @@ export const never: Channel<never, never, never> = fromPull(Effect.succeed(Effec
  *
  * **Example** (Failing with an error)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Exit } from "effect"
  *
- * // Create a channel that fails with a string error
  * const failedChannel = Channel.fail("Something went wrong")
- *
- * // Create a channel that fails with a custom error
- * class CustomError extends Error {
- *   constructor(message: string) {
- *     super(message)
- *     this.name = "CustomError"
- *   }
- * }
- * const customErrorChannel = Channel.fail(new CustomError("Custom error"))
- *
- * // Use in error handling by piping to another channel
- * const channelWithFallback = Channel.concatWith(
- *   failedChannel,
- *   () => Channel.succeed("fallback value")
- * )
+ * Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.fail("Something went wrong")
  * ```
  *
  * @category constructors
@@ -1005,27 +1017,18 @@ export const fail = <E>(error: E): Channel<never, E, never> => fromPull(Effect.s
  *
  * **Example** (Failing with a lazy error)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Exit } from "effect"
  *
- * // Create a channel that fails with a lazily computed error
- * const failedChannel = Channel.failSync(() => {
- *   console.log("Computing error...")
- *   return new Error("Computed at runtime")
- * })
- *
- * // The error computation is deferred until the channel runs
  * let attempts = 0
  * const conditionalError = Channel.failSync(() => {
  *   attempts += 1
  *   return `Error after attempt ${attempts}`
  * })
- *
- * // Use with expensive error construction
- * const expensiveError = Channel.failSync(() => {
- *   const requestId = "request-123"
- *   return new Error(`Failed while processing ${requestId}`)
- * })
+ * const observed = [
+ *   Effect.runSync(Effect.exit(Channel.runCollect(conditionalError))),
+ *   attempts
+ * ] // => [Exit.fail("Error after attempt 1"), 1]
  * ```
  *
  * @category constructors
@@ -1043,20 +1046,12 @@ export const failSync = <E>(evaluate: LazyArg<E>): Channel<never, E, never> => f
  *
  * **Example** (Failing with causes)
  *
- * ```ts
- * import { Cause, Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect, Exit } from "effect"
  *
- * // Create a channel that fails with a simple cause
  * const simpleCause = Cause.fail("Simple error")
  * const failedChannel = Channel.failCause(simpleCause)
- *
- * // Create a channel with a die cause
- * const dieCause = Cause.die(new Error("System error"))
- * const dieFailure = Channel.failCause(dieCause)
- *
- * // Create a channel with a simple fail cause
- * const failCause = Cause.fail("Simple error")
- * const simpleFail = Channel.failCause(failCause)
+ * Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))) // => Exit.failCause(simpleCause)
  * ```
  *
  * @category constructors
@@ -1070,8 +1065,8 @@ export const failCause = <E>(cause: Cause.Cause<E>): Channel<never, E, never> =>
  *
  * **Example** (Failing with lazy causes)
  *
- * ```ts
- * import { Cause, Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect, Exit } from "effect"
  *
  * // Create a channel that fails with a lazily computed cause
  * let attempts = 0
@@ -1080,11 +1075,10 @@ export const failCause = <E>(cause: Cause.Cause<E>): Channel<never, E, never> =>
  *   return Cause.fail(`Runtime error after attempt ${attempts}`)
  * })
  *
- * // Create a channel with die cause computation
- * const dieCauseChannel = Channel.failCauseSync(() => {
- *   const operation = "load-profile"
- *   return Cause.die(`Unexpected defect during ${operation}`)
- * })
+ * const observed = [
+ *   Effect.runSync(Effect.exit(Channel.runCollect(failedChannel))),
+ *   attempts
+ * ] // => [Exit.fail("Runtime error after attempt 1"), 1]
  * ```
  *
  * @category constructors
@@ -1099,20 +1093,12 @@ export const failCauseSync = <E>(
  *
  * **Example** (Dying with defects)
  *
- * ```ts
- * import { Channel } from "effect"
- *
- * // Create a channel that dies with a string defect
- * const diedChannel = Channel.die("Unrecoverable error")
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect, Exit } from "effect"
  *
- * // Create a channel that dies with an Error object
- * const errorDefect = Channel.die(new Error("System failure"))
- *
- * // Die with any value as a defect
- * const objectDefect = Channel.die({
- *   code: "SYSTEM_FAILURE",
- *   details: "Critical system component failed"
- * })
+ * const defect = "Unrecoverable error"
+ * const diedChannel = Channel.die(defect)
+ * Effect.runSync(Effect.exit(Channel.runCollect(diedChannel))) // => Exit.failCause(Cause.die(defect))
  * ```
  *
  * @category constructors
@@ -1125,33 +1111,13 @@ export const die = (defect: unknown): Channel<never, never, never> => failCause(
  *
  * **Example** (Creating channels from effects)
  *
- * ```ts
- * import { Channel, Data, Effect } from "effect"
- *
- * class DatabaseError extends Data.TaggedError("DatabaseError")<{
- *   readonly message: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
- * // Create a channel from a successful effect
  * const successChannel = Channel.fromEffect(
  *   Effect.succeed("Hello from effect!")
  * )
- *
- * // Create a channel from an effect that might fail
- * const fetchUserChannel = Channel.fromEffect(
- *   Effect.tryPromise({
- *     try: () => fetch("/api/user").then((res) => res.json()),
- *     catch: (error) => new DatabaseError({ message: String(error) })
- *   })
- * )
- *
- * // Channel from effect with async computation
- * const asyncChannel = Channel.fromEffect(
- *   Effect.gen(function*() {
- *     yield* Effect.sleep("100 millis")
- *     return "Async result"
- *   })
- * )
+ * Effect.runSync(Channel.runCollect(successChannel)) // => ["Hello from effect!"]
  * ```
  *
  * @category constructors
@@ -1219,35 +1185,17 @@ export const fromEffectTake = <A, E, Done, E2, R>(
  *
  * **Example** (Creating channels from queues)
  *
- * ```ts
- * import { Channel, Data, Effect, Queue } from "effect"
- *
- * class QueueError extends Data.TaggedError("QueueError")<{
- *   readonly reason: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Create a bounded queue
- *   const queue = yield* Queue.bounded<string, QueueError>(10)
- *
- *   // Add some items to the queue
- *   yield* Queue.offer(queue, "item1")
- *   yield* Queue.offer(queue, "item2")
- *   yield* Queue.offer(queue, "item3")
- *
- *   // Create a channel from the queue
+ *   const queue = yield* Queue.bounded<string, Cause.Done>(3)
+ *   yield* Queue.offerAll(queue, ["item1", "item2", "item3"])
+ *   yield* Queue.end(queue)
  *   const channel = Channel.fromQueue(queue)
- *
- *   // The channel will read items from the queue one by one
- *   return channel
- * })
- *
- * // Sliding queue example
- * const slidingProgram = Effect.gen(function*() {
- *   const slidingQueue = yield* Queue.sliding<number, QueueError>(5)
- *   yield* Queue.offerAll(slidingQueue, [1, 2, 3, 4, 5, 6])
- *   return Channel.fromQueue(slidingQueue)
+ *   return yield* Channel.runCollect(channel)
  * })
+ * await Effect.runPromise(program) // => ["item1", "item2", "item3"]
  * ```
  *
  * @category constructors
@@ -1262,39 +1210,17 @@ export const fromQueue = <A, E>(
  *
  * **Example** (Creating batched channels from queues)
  *
- * ```ts
- * import { Channel, Data, Effect, Queue } from "effect"
- *
- * class ProcessingError extends Data.TaggedError("ProcessingError")<{
- *   readonly stage: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Create a queue for batch processing
- *   const queue = yield* Queue.bounded<number, ProcessingError>(100)
- *
- *   // Fill queue with data
- *   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
- *
- *   // Create a channel that reads arrays from the queue
+ *   const queue = yield* Queue.bounded<number, Cause.Done>(4)
+ *   yield* Queue.offerAll(queue, [1, 2, 3, 4])
+ *   yield* Queue.end(queue)
  *   const arrayChannel = Channel.fromQueueArray(queue)
- *
- *   // This will emit non-empty arrays of elements instead of individual items
- *   // Useful for batch processing scenarios
- *   return arrayChannel
- * })
- *
- * // High-throughput processing example
- * const batchProcessor = Effect.gen(function*() {
- *   const dataQueue = yield* Queue.dropping<string, ProcessingError>(1000)
- *   const batchChannel = Channel.fromQueueArray(dataQueue)
- *
- *   // Process data in batches for better performance
- *   return Channel.map(
- *     batchChannel,
- *     (batch) => batch.map((item) => item.toUpperCase())
- *   )
+ *   return yield* Channel.runCollect(arrayChannel)
  * })
+ * await Effect.runPromise(program) // => [[1, 2, 3, 4]]
  * ```
  *
  * @category constructors
@@ -1319,8 +1245,8 @@ export const identity = <Elem, Err, Done>(): Channel<Elem, Err, Done, Elem, Err,
  *
  * **Example** (Creating channels from subscriptions)
  *
- * ```ts
- * import { Channel, Data, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Option, PubSub } from "effect"
  *
  * class SubscriptionError extends Data.TaggedError("SubscriptionError")<{
  *   readonly reason: string
@@ -1345,6 +1271,8 @@ export const identity = <Elem, Err, Done>(): Channel<Elem, Err, Done, Elem, Err,
  *   // The channel will receive all published messages
  *   return channel
  * })
+ * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))
+ * await Effect.runPromise(result) // => Option.some("Hello")
  *
  * // Real-time notifications example
  * const notificationChannel = Effect.gen(function*() {
@@ -1373,8 +1301,8 @@ export const fromSubscription = <A>(
  *
  * **Example** (Batching subscription values)
  *
- * ```ts
- * import { Channel, Data, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Option, PubSub } from "effect"
  *
  * class StreamError extends Data.TaggedError("StreamError")<{
  *   readonly message: string
@@ -1396,12 +1324,14 @@ export const fromSubscription = <A>(
  *   // The channel will output arrays like [1, 2, 3] and [4]
  *   return channel
  * })
+ * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))
+ * await Effect.runPromise(result) // => Option.some([1, 2, 3, 4])
  * ```
  *
  * **Example** (Processing subscription values in batches)
  *
- * ```ts
- * import { Channel, Data, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Option, PubSub } from "effect"
  *
  * class BatchProcessingError extends Data.TaggedError("BatchProcessingError")<{
  *   readonly reason: string
@@ -1415,19 +1345,21 @@ export const fromSubscription = <A>(
  *   const batchChannel = Channel.fromSubscriptionArray(subscription)
  *
  *   // Transform to process each batch
- *   const processedChannel = Channel.map(batchChannel, (batch) => {
- *     console.log(`Processing batch of ${batch.length} items:`, batch)
- *     return batch.map((item) => item.toUpperCase())
- *   })
+ *   const processedChannel = Channel.map(batchChannel, (batch) =>
+ *     batch.map((item) => item.toUpperCase())
+ *   )
  *
+ *   yield* PubSub.publishAll(pubsub, ["one", "two"])
  *   return processedChannel
  * })
+ * const batch = Effect.scoped(Effect.flatMap(batchProcessor, Channel.runHead))
+ * await Effect.runPromise(batch) // => Option.some(["ONE", "TWO"])
  * ```
  *
  * **Example** (Aggregating subscription metrics)
  *
- * ```ts
- * import { Channel, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Option, PubSub } from "effect"
  *
  * const metricsAggregator = Effect.gen(function*() {
  *   const metricsPubSub = yield* PubSub.bounded<
@@ -1457,8 +1389,12 @@ export const fromSubscription = <A>(
  *     }
  *   })
  *
+ *   yield* PubSub.publish(metricsPubSub, { timestamp: 1, value: 10 })
  *   return aggregatedChannel
  * })
+ * const metric = Effect.scoped(Effect.flatMap(metricsAggregator, Channel.runHead))
+ * const result = await Effect.runPromise(metric)
+ * Option.map(result, ({ count, sum, average, min, max }) => ({ count, sum, average, min, max })) // => Option.some({ count: 1, sum: 10, average: 10, min: 10, max: 10 })
  * ```
  *
  * @category constructors
@@ -1480,15 +1416,15 @@ export const fromSubscriptionArray = <A>(
  *
  * **Example** (Creating channels from PubSubs)
  *
- * ```ts
- * import { Channel, Data, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Option, PubSub } from "effect"
  *
  * class StreamError extends Data.TaggedError("StreamError")<{
  *   readonly message: string
  * }> {}
  *
  * const program = Effect.gen(function*() {
- *   const pubsub = yield* PubSub.bounded<number>(16)
+ *   const pubsub = yield* PubSub.unbounded<number>({ replay: 3 })
  *
  *   // Create a channel that reads individual values
  *   const channel = Channel.fromPubSub(pubsub)
@@ -1501,15 +1437,17 @@ export const fromSubscriptionArray = <A>(
  *   // The channel will output: 1, 2, 3 (individual values)
  *   return channel
  * })
+ * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))
+ * await Effect.runPromise(result) // => Option.some(1)
  * ```
  *
  * **Example** (Streaming PubSub notifications)
  *
- * ```ts
- * import { Channel, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Option, PubSub } from "effect"
  *
  * const notificationService = Effect.gen(function*() {
- *   const notificationPubSub = yield* PubSub.bounded<string>(50)
+ *   const notificationPubSub = yield* PubSub.unbounded<string>({ replay: 1 })
  *
  *   // Create a channel for real-time notifications
  *   const notificationChannel = Channel.fromPubSub(notificationPubSub)
@@ -1522,14 +1460,17 @@ export const fromSubscriptionArray = <A>(
  *     id: `notification:${message}`
  *   }))
  *
+ *   yield* PubSub.publish(notificationPubSub, "ready")
  *   return timestampedChannel
  * })
+ * const notification = Effect.scoped(Effect.flatMap(notificationService, Channel.runHead))
+ * await Effect.runPromise(notification) // => Option.some({ message: "ready", receivedAt: "2024-01-01T00:00:00.000Z", id: "notification:ready" })
  * ```
  *
  * **Example** (Processing PubSub events)
  *
- * ```ts
- * import { Channel, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Option, PubSub } from "effect"
  *
  * interface DomainEvent {
  *   readonly type: string
@@ -1538,7 +1479,7 @@ export const fromSubscriptionArray = <A>(
  * }
  *
  * const eventProcessor = Effect.gen(function*() {
- *   const eventPubSub = yield* PubSub.bounded<DomainEvent>(100)
+ *   const eventPubSub = yield* PubSub.unbounded<DomainEvent>({ replay: 1 })
  *
  *   // Create a channel for processing domain events
  *   const eventChannel = Channel.fromPubSub(eventPubSub)
@@ -1555,8 +1496,11 @@ export const fromSubscriptionArray = <A>(
  *     return event
  *   })
  *
+ *   yield* PubSub.publish(eventPubSub, { type: "user.created", payload: {}, timestamp: 1 })
  *   return processedChannel
  * })
+ * const event = Effect.scoped(Effect.flatMap(eventProcessor, Channel.runHead))
+ * const result = await Effect.runPromise(event) // => Option.some({ type: "user.created", payload: {}, timestamp: 1, processed: true, processedAt: 2 })
  * ```
  *
  * @category constructors
@@ -1577,15 +1521,15 @@ export const fromPubSub = <A>(
  *
  * **Example** (Batching PubSub values)
  *
- * ```ts
- * import { Channel, Data, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Option, PubSub } from "effect"
  *
  * class BatchError extends Data.TaggedError("BatchError")<{
  *   readonly message: string
  * }> {}
  *
  * const program = Effect.gen(function*() {
- *   const pubsub = yield* PubSub.bounded<number>(16)
+ *   const pubsub = yield* PubSub.unbounded<number>({ replay: 4 })
  *
  *   // Create a channel that reads arrays of values
  *   const channel = Channel.fromPubSubArray(pubsub)
@@ -1599,12 +1543,14 @@ export const fromPubSub = <A>(
  *   // The channel will output arrays like [1, 2, 3] and [4]
  *   return channel
  * })
+ * const result = Effect.scoped(Effect.flatMap(program, Channel.runHead))
+ * await Effect.runPromise(result) // => Option.some([1, 2, 3, 4])
  * ```
  *
  * **Example** (Processing PubSub orders in batches)
  *
- * ```ts
- * import { Channel, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Option, PubSub } from "effect"
  *
  * interface Order {
  *   readonly id: string
@@ -1615,7 +1561,7 @@ export const fromPubSub = <A>(
  * }
  *
  * const orderBatchProcessor = Effect.gen(function*() {
- *   const orderPubSub = yield* PubSub.bounded<Order>(100)
+ *   const orderPubSub = yield* PubSub.unbounded<Order>({ replay: 1 })
  *
  *   // Create a channel that processes orders in batches
  *   const orderChannel = Channel.fromPubSubArray(orderPubSub)
@@ -1636,14 +1582,20 @@ export const fromPubSub = <A>(
  *     }
  *   })
  *
+ *   yield* PubSub.publish(orderPubSub, {
+ *     id: "1", customerId: "a", items: ["book"], total: 10, submittedAt: 1
+ *   })
  *   return processedChannel
  * })
+ * const order = Effect.scoped(Effect.flatMap(orderBatchProcessor, Channel.runHead))
+ * const result = await Effect.runPromise(order)
+ * Option.map(result, (batch) => [batch.batchSize, batch.totalRevenue, batch.uniqueCustomers]) // => Option.some([1, 10, 1])
  * ```
  *
  * **Example** (Processing PubSub logs in batches)
  *
- * ```ts
- * import { Channel, Effect, PubSub } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Option, PubSub } from "effect"
  *
  * interface LogEntry {
  *   readonly timestamp: number
@@ -1653,7 +1605,7 @@ export const fromPubSub = <A>(
  * }
  *
  * const logAggregator = Effect.gen(function*() {
- *   const logPubSub = yield* PubSub.bounded<LogEntry>(500)
+ *   const logPubSub = yield* PubSub.unbounded<LogEntry>({ replay: 1 })
  *
  *   // Create a channel that collects logs in batches
  *   const logChannel = Channel.fromPubSubArray(logPubSub)
@@ -1680,8 +1632,17 @@ export const fromPubSub = <A>(
  *     }
  *   })
  *
+ *   yield* PubSub.publish(logPubSub, {
+ *     timestamp: 1,
+ *     level: "info",
+ *     message: "ready",
+ *     source: "app"
+ *   } satisfies LogEntry)
  *   return analysisChannel
  * })
+ * const log = Effect.scoped(Effect.flatMap(logAggregator, Channel.runHead))
+ * const result = await Effect.runPromise(log)
+ * Option.map(result, (batch) => [batch.batchId, batch.totalEntries, batch.infoCount]) // => Option.some(["1-1", 1, 1])
  * ```
  *
  * @category constructors
@@ -1717,6 +1678,229 @@ export const fromSchedule = <O, E, R>(
 ): Channel<O, E, O, unknown, unknown, unknown, R> =>
   fromPull(Effect.map(Schedule.toStepWithSleep(schedule), (step) => step(void 0)))
 
+/**
+ * Creates a channel from a lazily supplied Web `ReadableStream`.
+ *
+ * **Example** (Reading from a Web stream)
+ *
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
+ *
+ * const channel = Channel.fromReadableStream({
+ *   evaluate: () => new ReadableStream({
+ *     start(controller) {
+ *       controller.enqueue(1)
+ *       controller.close()
+ *     }
+ *   }),
+ *   onError: (cause) => new Error(String(cause))
+ * })
+ *
+ * await Effect.runPromise(Channel.runCollect(channel)) // => [[1]]
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const fromReadableStream = <A, E>(options: {
+  readonly evaluate: LazyArg<ReadableStream<A>>
+  readonly onError: (error: unknown) => E
+  readonly releaseLockOnEnd?: boolean | undefined
+}): Channel<Arr.NonEmptyReadonlyArray<A>, E> =>
+  fromTransform((_, scope) =>
+    readableStreamToPullUnsafe({
+      scope,
+      readable: options.evaluate(),
+      onError: options.onError,
+      releaseLockOnEnd: options.releaseLockOnEnd
+    })
+  )
+
+/** @internal */
+export const pullIntoWritableStream = <A, IE, E>(options: {
+  readonly pull: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, IE, unknown>
+  readonly writable: WritableStream<A>
+  readonly onError: (error: unknown) => E
+  readonly closeOnDone?: boolean | undefined
+}): Pull.Pull<never, IE | E, unknown> =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => options.writable.getWriter()),
+    (writer) => {
+      const loop = options.pull.pipe(
+        Effect.flatMap((chunk) =>
+          Effect.forEach(
+            chunk,
+            (value) =>
+              Effect.tryPromise({
+                try: () => writer.ready.then(() => writer.write(value)),
+                catch: options.onError
+              }),
+            { discard: true }
+          )
+        ),
+        Effect.forever({ disableYield: true })
+      )
+      const withClose = options.closeOnDone !== false
+        ? Pull.catchDone(loop, (done) =>
+          Effect.andThen(
+            Effect.tryPromise({
+              try: () => writer.close(),
+              catch: options.onError
+            }),
+            Cause.done(done)
+          ))
+        : loop
+      return Effect.onError(
+        withClose,
+        (cause) =>
+          Pull.isDoneCause(cause)
+            ? Effect.void
+            : Effect.promise(() => writer.abort(cause).catch(constVoid))
+      )
+    },
+    (writer) => Effect.sync(() => writer.releaseLock())
+  )
+
+/**
+ * Creates a channel that writes upstream values to a lazily supplied Web
+ * `WritableStream`.
+ *
+ * **Example** (Writing channel input)
+ *
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
+ *
+ * const written: Array<number> = []
+ * const sink = Channel.fromWritableStream<never, Error, number>({
+ *   evaluate: () => new WritableStream({
+ *     write(value) {
+ *       written.push(value)
+ *     }
+ *   }),
+ *   onError: (cause) => new Error(String(cause))
+ * })
+ *
+ * const program = Channel.fromArray([[1, 2] as [number, number]]).pipe(
+ *   Channel.pipeTo(sink),
+ *   Channel.runDrain
+ * )
+ *
+ * await Effect.runPromise(program)
+ * written // => [1, 2]
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const fromWritableStream = <IE, E, A>(options: {
+  readonly evaluate: LazyArg<WritableStream<A>>
+  readonly onError: (error: unknown) => E
+  readonly closeOnDone?: boolean | undefined
+}): Channel<never, IE | E, void, Arr.NonEmptyReadonlyArray<A>, IE> =>
+  fromTransform((pull: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, IE, unknown>) => {
+    const writable = options.evaluate()
+    return Effect.succeed(pullIntoWritableStream({ ...options, writable, pull }))
+  })
+
+/**
+ * Creates a channel backed by a Web `TransformStream`, writing upstream values
+ * while emitting transformed values from its readable side.
+ *
+ * **Example** (Transforming channel input)
+ *
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
+ *
+ * const transform = Channel.fromTransformStream<never, number, number, Error>({
+ *   evaluate: () => new TransformStream({
+ *     transform(value, controller) {
+ *       controller.enqueue(value * 2)
+ *     }
+ *   }),
+ *   onError: (cause) => new Error(String(cause))
+ * })
+ *
+ * const program = Channel.fromArray([[1, 2] as [number, number]]).pipe(
+ *   Channel.pipeTo(transform),
+ *   Channel.runCollect
+ * )
+ *
+ * await Effect.runPromise(program) // => [[2], [4]]
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const fromTransformStream = <IE, I, O, E>(options: {
+  readonly evaluate: LazyArg<TransformStream<I, O>>
+  readonly onError: (error: unknown) => E
+  readonly closeOnDone?: boolean | undefined
+  readonly releaseLockOnEnd?: boolean | undefined
+}): Channel<Arr.NonEmptyReadonlyArray<O>, IE | E, void, Arr.NonEmptyReadonlyArray<I>, IE> =>
+  fromTransform((upstream, scope) => {
+    const transform = options.evaluate()
+    const exit = MutableRef.make<Exit.Exit<never, IE | E | Cause.Done> | undefined>(undefined)
+    return pullIntoWritableStream({
+      pull: upstream,
+      writable: transform.writable,
+      onError: options.onError,
+      closeOnDone: options.closeOnDone
+    }).pipe(
+      Effect.catchCause((cause) => {
+        if (!Pull.isDoneCause(cause)) {
+          exit.current = Exit.failCause(cause as Cause.Cause<IE | E | Cause.Done>)
+        }
+        return Effect.void
+      }),
+      Effect.forkIn(scope),
+      Effect.flatMap(() =>
+        readableStreamToPullUnsafe({
+          scope,
+          exit,
+          readable: transform.readable,
+          onError: options.onError,
+          releaseLockOnEnd: options.releaseLockOnEnd
+        })
+      )
+    )
+  })
+
+const readableStreamToPullUnsafe = <A, E, E2 = never>(options: {
+  readonly scope: Scope.Scope
+  readonly exit?: MutableRef.MutableRef<Exit.Exit<never, E | E2 | Cause.Done> | undefined> | undefined
+  readonly readable: ReadableStream<A>
+  readonly onError: (error: unknown) => E
+  readonly releaseLockOnEnd?: boolean | undefined
+}): Effect.Effect<Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E | E2>, never> => {
+  const reader = options.readable.getReader()
+  const exit = options.exit ?? MutableRef.make(undefined)
+  const pull = Effect.suspend(() => {
+    if (exit.current) return exit.current
+    return Effect.matchCauseEffect(
+      Effect.tryPromise({
+        try: () => reader.read(),
+        catch: options.onError
+      }),
+      {
+        onFailure: (cause) => exit.current ?? Effect.failCause(cause),
+        onSuccess: ({ done, value }) => {
+          if (exit.current) return exit.current
+          return done ? Cause.done() : Effect.succeed(Arr.of(value))
+        }
+      }
+    )
+  })
+  return Effect.as(
+    Scope.addFinalizer(
+      options.scope,
+      options.releaseLockOnEnd
+        ? Effect.sync(() => reader.releaseLock())
+        : Effect.promise(() => reader.cancel().catch(constVoid))
+    ),
+    pull
+  )
+}
+
 /**
  * Creates a channel that pulls values from an `AsyncIterable`.
  *
@@ -1771,8 +1955,8 @@ export const fromAsyncIterableArray = <A, D, E>(
  *
  * **Example** (Mapping channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class TransformError extends Data.TaggedError("TransformError")<{
  *   readonly reason: string
@@ -1781,12 +1965,12 @@ export const fromAsyncIterableArray = <A, D, E>(
  * // Basic mapping of channel values
  * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
  * const doubledChannel = Channel.map(numbersChannel, (n) => n * 2)
- * // Outputs: 2, 4, 6, 8, 10
+ * Effect.runSync(Channel.runCollect(doubledChannel)) // => [2, 4, 6, 8, 10]
  *
  * // Transform string data
  * const wordsChannel = Channel.fromIterable(["hello", "world", "effect"])
  * const upperCaseChannel = Channel.map(wordsChannel, (word) => word.toUpperCase())
- * // Outputs: "HELLO", "WORLD", "EFFECT"
+ * Effect.runSync(Channel.runCollect(upperCaseChannel)) // => ["HELLO", "WORLD", "EFFECT"]
  *
  * // Complex object transformation
  * type User = { id: number; name: string }
@@ -1800,6 +1984,7 @@ export const fromAsyncIterableArray = <A, D, E>(
  *   displayName: `User: ${user.name}`,
  *   isActive: true
  * }))
+ * Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: "User: Alice", isActive: true }, { displayName: "User: Bob", isActive: true }]
  * ```
  *
  * @category sequencing
@@ -1811,8 +1996,8 @@ export const map: {
    *
    * **Example** (Mapping channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class TransformError extends Data.TaggedError("TransformError")<{
    *   readonly reason: string
@@ -1821,12 +2006,12 @@ export const map: {
    * // Basic mapping of channel values
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    * const doubledChannel = Channel.map(numbersChannel, (n) => n * 2)
-   * // Outputs: 2, 4, 6, 8, 10
+   * Effect.runSync(Channel.runCollect(doubledChannel)) // => [2, 4, 6, 8, 10]
    *
    * // Transform string data
    * const wordsChannel = Channel.fromIterable(["hello", "world", "effect"])
    * const upperCaseChannel = Channel.map(wordsChannel, (word) => word.toUpperCase())
-   * // Outputs: "HELLO", "WORLD", "EFFECT"
+   * Effect.runSync(Channel.runCollect(upperCaseChannel)) // => ["HELLO", "WORLD", "EFFECT"]
    *
    * // Complex object transformation
    * type User = { id: number; name: string }
@@ -1840,6 +2025,7 @@ export const map: {
    *   displayName: `User: ${user.name}`,
    *   isActive: true
    * }))
+   * Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: "User: Alice", isActive: true }, { displayName: "User: Bob", isActive: true }]
    * ```
    *
    * @category sequencing
@@ -1853,8 +2039,8 @@ export const map: {
    *
    * **Example** (Mapping channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class TransformError extends Data.TaggedError("TransformError")<{
    *   readonly reason: string
@@ -1863,12 +2049,12 @@ export const map: {
    * // Basic mapping of channel values
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    * const doubledChannel = Channel.map(numbersChannel, (n) => n * 2)
-   * // Outputs: 2, 4, 6, 8, 10
+   * Effect.runSync(Channel.runCollect(doubledChannel)) // => [2, 4, 6, 8, 10]
    *
    * // Transform string data
    * const wordsChannel = Channel.fromIterable(["hello", "world", "effect"])
    * const upperCaseChannel = Channel.map(wordsChannel, (word) => word.toUpperCase())
-   * // Outputs: "HELLO", "WORLD", "EFFECT"
+   * Effect.runSync(Channel.runCollect(upperCaseChannel)) // => ["HELLO", "WORLD", "EFFECT"]
    *
    * // Complex object transformation
    * type User = { id: number; name: string }
@@ -1882,6 +2068,7 @@ export const map: {
    *   displayName: `User: ${user.name}`,
    *   isActive: true
    * }))
+   * Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: "User: Alice", isActive: true }, { displayName: "User: Bob", isActive: true }]
    * ```
    *
    * @category sequencing
@@ -2014,40 +2201,15 @@ const concurrencyIsSequential = (
  *
  * **Example** (Mapping channel output with effects)
  *
- * ```ts
- * import { Channel, Data, Effect } from "effect"
- *
- * class NetworkError extends Data.TaggedError("NetworkError")<{
- *   readonly url: string
- * }> {}
- *
- * // Transform values using effectful operations
- * const urlsChannel = Channel.fromIterable([
- *   "/api/users/1",
- *   "/api/users/2",
- *   "/api/users/3"
- * ])
- *
- * const fetchDataChannel = Channel.mapEffect(
- *   urlsChannel,
- *   (url) =>
- *     Effect.tryPromise({
- *       try: () => fetch(url).then((res) => res.json()),
- *       catch: () => new NetworkError({ url })
- *     })
- * )
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
- * // Concurrent processing with options
  * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
  * const processedChannel = Channel.mapEffect(
  *   numbersChannel,
- *   (n) =>
- *     Effect.gen(function*() {
- *       yield* Effect.sleep("100 millis") // Simulate async work
- *       return n * n
- *     }),
- *   { concurrency: 3, unordered: true }
+ *   (n) => Effect.succeed(n * n)
  * )
+ * await Effect.runPromise(Channel.runCollect(processedChannel)) // => [1, 4, 9, 16, 25]
  * ```
  *
  * @category sequencing
@@ -2072,40 +2234,15 @@ export const mapEffect: {
    *
    * **Example** (Mapping channel output with effects)
    *
-   * ```ts
-   * import { Channel, Data, Effect } from "effect"
-   *
-   * class NetworkError extends Data.TaggedError("NetworkError")<{
-   *   readonly url: string
-   * }> {}
-   *
-   * // Transform values using effectful operations
-   * const urlsChannel = Channel.fromIterable([
-   *   "/api/users/1",
-   *   "/api/users/2",
-   *   "/api/users/3"
-   * ])
-   *
-   * const fetchDataChannel = Channel.mapEffect(
-   *   urlsChannel,
-   *   (url) =>
-   *     Effect.tryPromise({
-   *       try: () => fetch(url).then((res) => res.json()),
-   *       catch: () => new NetworkError({ url })
-   *     })
-   * )
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
-   * // Concurrent processing with options
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    * const processedChannel = Channel.mapEffect(
    *   numbersChannel,
-   *   (n) =>
-   *     Effect.gen(function*() {
-   *       yield* Effect.sleep("100 millis") // Simulate async work
-   *       return n * n
-   *     }),
-   *   { concurrency: 3, unordered: true }
+   *   (n) => Effect.succeed(n * n)
    * )
+   * await Effect.runPromise(Channel.runCollect(processedChannel)) // => [1, 4, 9, 16, 25]
    * ```
    *
    * @category sequencing
@@ -2138,40 +2275,15 @@ export const mapEffect: {
    *
    * **Example** (Mapping channel output with effects)
    *
-   * ```ts
-   * import { Channel, Data, Effect } from "effect"
-   *
-   * class NetworkError extends Data.TaggedError("NetworkError")<{
-   *   readonly url: string
-   * }> {}
-   *
-   * // Transform values using effectful operations
-   * const urlsChannel = Channel.fromIterable([
-   *   "/api/users/1",
-   *   "/api/users/2",
-   *   "/api/users/3"
-   * ])
-   *
-   * const fetchDataChannel = Channel.mapEffect(
-   *   urlsChannel,
-   *   (url) =>
-   *     Effect.tryPromise({
-   *       try: () => fetch(url).then((res) => res.json()),
-   *       catch: () => new NetworkError({ url })
-   *     })
-   * )
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
-   * // Concurrent processing with options
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    * const processedChannel = Channel.mapEffect(
    *   numbersChannel,
-   *   (n) =>
-   *     Effect.gen(function*() {
-   *       yield* Effect.sleep("100 millis") // Simulate async work
-   *       return n * n
-   *     }),
-   *   { concurrency: 3, unordered: true }
+   *   (n) => Effect.succeed(n * n)
    * )
+   * await Effect.runPromise(Channel.runCollect(processedChannel)) // => [1, 4, 9, 16, 25]
    * ```
    *
    * @category sequencing
@@ -2414,8 +2526,8 @@ export const mapInputError: {
  *
  * **Example** (Tapping channel output)
  *
- * ```ts
- * import { Channel, Console, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class LogError extends Data.TaggedError("LogError")<{
  *   readonly message: string
@@ -2425,13 +2537,13 @@ export const mapInputError: {
  * const numberChannel = Channel.fromIterable([1, 2, 3])
  *
  * // Tap into each output element to perform side effects
+ * const processed: Array<number> = []
  * const tappedChannel = Channel.tap(
  *   numberChannel,
- *   (n) => Console.log(`Processing number: ${n}`)
+ *   (n) => Effect.sync(() => processed.push(n))
  * )
  *
- * // The channel still outputs the same elements but logs each one
- * // Outputs: 1, 2, 3 (while logging each)
+ * const observed = [await Effect.runPromise(Channel.runCollect(tappedChannel)), processed] // => [[1, 2, 3], [1, 2, 3]]
  * ```
  *
  * @category sequencing
@@ -2450,8 +2562,8 @@ export const tap: {
    *
    * **Example** (Tapping channel output)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class LogError extends Data.TaggedError("LogError")<{
    *   readonly message: string
@@ -2461,13 +2573,13 @@ export const tap: {
    * const numberChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Tap into each output element to perform side effects
+   * const processed: Array<number> = []
    * const tappedChannel = Channel.tap(
    *   numberChannel,
-   *   (n) => Console.log(`Processing number: ${n}`)
+   *   (n) => Effect.sync(() => processed.push(n))
    * )
    *
-   * // The channel still outputs the same elements but logs each one
-   * // Outputs: 1, 2, 3 (while logging each)
+   * const observed = [await Effect.runPromise(Channel.runCollect(tappedChannel)), processed] // => [[1, 2, 3], [1, 2, 3]]
    * ```
    *
    * @category sequencing
@@ -2493,8 +2605,8 @@ export const tap: {
    *
    * **Example** (Tapping channel output)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class LogError extends Data.TaggedError("LogError")<{
    *   readonly message: string
@@ -2504,13 +2616,13 @@ export const tap: {
    * const numberChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Tap into each output element to perform side effects
+   * const processed: Array<number> = []
    * const tappedChannel = Channel.tap(
    *   numberChannel,
-   *   (n) => Console.log(`Processing number: ${n}`)
+   *   (n) => Effect.sync(() => processed.push(n))
    * )
    *
-   * // The channel still outputs the same elements but logs each one
-   * // Outputs: 1, 2, 3 (while logging each)
+   * const observed = [await Effect.runPromise(Channel.runCollect(tappedChannel)), processed] // => [[1, 2, 3], [1, 2, 3]]
    * ```
    *
    * @category sequencing
@@ -2548,8 +2660,8 @@ export const tap: {
  *
  * **Example** (Flat mapping channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class ProcessError extends Data.TaggedError("ProcessError")<{
  *   readonly cause: string
@@ -2565,8 +2677,7 @@ export const tap: {
  *     Channel.fromIterable(Array.from({ length: n }, (_, i) => `item-${n}-${i}`))
  * )
  *
- * // Flattens nested channels into a single stream
- * // Outputs: "item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"
+ * Effect.runSync(Channel.runCollect(flatMappedChannel)) // => ["item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"]
  * ```
  *
  * @category sequencing
@@ -2586,8 +2697,8 @@ export const flatMap: {
    *
    * **Example** (Flat mapping channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ProcessError extends Data.TaggedError("ProcessError")<{
    *   readonly cause: string
@@ -2603,8 +2714,7 @@ export const flatMap: {
    *     Channel.fromIterable(Array.from({ length: n }, (_, i) => `item-${n}-${i}`))
    * )
    *
-   * // Flattens nested channels into a single stream
-   * // Outputs: "item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"
+   * Effect.runSync(Channel.runCollect(flatMappedChannel)) // => ["item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"]
    * ```
    *
    * @category sequencing
@@ -2640,8 +2750,8 @@ export const flatMap: {
    *
    * **Example** (Flat mapping channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ProcessError extends Data.TaggedError("ProcessError")<{
    *   readonly cause: string
@@ -2657,8 +2767,7 @@ export const flatMap: {
    *     Channel.fromIterable(Array.from({ length: n }, (_, i) => `item-${n}-${i}`))
    * )
    *
-   * // Flattens nested channels into a single stream
-   * // Outputs: "item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"
+   * Effect.runSync(Channel.runCollect(flatMappedChannel)) // => ["item-1-0", "item-2-0", "item-2-1", "item-3-0", "item-3-1", "item-3-2"]
    * ```
    *
    * @category sequencing
@@ -2828,8 +2937,8 @@ const flatMapConcurrent = <
  *
  * **Example** (Concatenating with completion values)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class ConcatError extends Data.TaggedError("ConcatError")<{
  *   readonly reason: string
@@ -2840,8 +2949,7 @@ const flatMapConcurrent = <
  *   Channel.concatWith((sum: void) => Channel.succeed(`Completed processing`))
  * )
  *
- * // Concatenates additional channel based on completion value
- * // Outputs: 1, 2, 3, then "Completed processing"
+ * Effect.runSync(Channel.runCollect(numberChannel)) // => [1, 2, 3, "Completed processing"]
  * ```
  *
  * @category sequencing
@@ -2854,8 +2962,8 @@ export const concatWith: {
    *
    * **Example** (Concatenating with completion values)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ConcatError extends Data.TaggedError("ConcatError")<{
    *   readonly reason: string
@@ -2866,8 +2974,7 @@ export const concatWith: {
    *   Channel.concatWith((sum: void) => Channel.succeed(`Completed processing`))
    * )
    *
-   * // Concatenates additional channel based on completion value
-   * // Outputs: 1, 2, 3, then "Completed processing"
+   * Effect.runSync(Channel.runCollect(numberChannel)) // => [1, 2, 3, "Completed processing"]
    * ```
    *
    * @category sequencing
@@ -2892,8 +2999,8 @@ export const concatWith: {
    *
    * **Example** (Concatenating with completion values)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ConcatError extends Data.TaggedError("ConcatError")<{
    *   readonly reason: string
@@ -2904,8 +3011,7 @@ export const concatWith: {
    *   Channel.concatWith((sum: void) => Channel.succeed(`Completed processing`))
    * )
    *
-   * // Concatenates additional channel based on completion value
-   * // Outputs: 1, 2, 3, then "Completed processing"
+   * Effect.runSync(Channel.runCollect(numberChannel)) // => [1, 2, 3, "Completed processing"]
    * ```
    *
    * @category sequencing
@@ -2991,8 +3097,8 @@ export const concatWith: {
  *
  * **Example** (Concatenating channels)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class ConcatError extends Data.TaggedError("ConcatError")<{
  *   readonly reason: string
@@ -3005,7 +3111,7 @@ export const concatWith: {
  * // Concatenate them
  * const concatenatedChannel = Channel.concat(firstChannel, secondChannel)
  *
- * // Outputs: 1, 2, 3, "a", "b", "c"
+ * Effect.runSync(Channel.runCollect(concatenatedChannel)) // => [1, 2, 3, "a", "b", "c"]
  * ```
  *
  * @category sequencing
@@ -3018,8 +3124,8 @@ export const concat: {
    *
    * **Example** (Concatenating channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ConcatError extends Data.TaggedError("ConcatError")<{
    *   readonly reason: string
@@ -3032,7 +3138,7 @@ export const concat: {
    * // Concatenate them
    * const concatenatedChannel = Channel.concat(firstChannel, secondChannel)
    *
-   * // Outputs: 1, 2, 3, "a", "b", "c"
+   * Effect.runSync(Channel.runCollect(concatenatedChannel)) // => [1, 2, 3, "a", "b", "c"]
    * ```
    *
    * @category sequencing
@@ -3055,8 +3161,8 @@ export const concat: {
    *
    * **Example** (Concatenating channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ConcatError extends Data.TaggedError("ConcatError")<{
    *   readonly reason: string
@@ -3069,7 +3175,7 @@ export const concat: {
    * // Concatenate them
    * const concatenatedChannel = Channel.concat(firstChannel, secondChannel)
    *
-   * // Outputs: 1, 2, 3, "a", "b", "c"
+   * Effect.runSync(Channel.runCollect(concatenatedChannel)) // => [1, 2, 3, "a", "b", "c"]
    * ```
    *
    * @category sequencing
@@ -3425,8 +3531,8 @@ export const orElseIfEmpty: {
  *
  * **Example** (Flattening nested channels)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class FlattenError extends Data.TaggedError("FlattenError")<{
  *   readonly cause: string
@@ -3442,7 +3548,7 @@ export const orElseIfEmpty: {
  * // Flatten the nested channels
  * const flattenedChannel = Channel.flatten(nestedChannels)
  *
- * // Outputs: 1, 2, 3, 4, 5, 6
+ * Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6]
  * ```
  *
  * @category constructors
@@ -3480,8 +3586,8 @@ export const flatten = <
  *
  * **Example** (Flattening arrays of channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class FlattenError extends Data.TaggedError("FlattenError")<{
  *   readonly message: string
@@ -3497,7 +3603,7 @@ export const flatten = <
  * // Flatten the arrays into individual elements
  * const flattenedChannel = Channel.flattenArray(arrayChannel)
  *
- * // Outputs: 1, 2, 3, 4, 5, 6, 7, 8, 9
+ * Effect.runSync(Channel.runCollect(flattenedChannel)) // => [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * ```
  *
  * @category transforming
@@ -3575,8 +3681,8 @@ export const flattenTake = <
  *
  * **Example** (Draining channel output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create a channel that outputs values
  * const sourceChannel = Channel.fromIterable([1, 2, 3, 4, 5])
@@ -3584,8 +3690,7 @@ export const flattenTake = <
  * // Drain all output, keeping only the completion
  * const drainedChannel = Channel.drain(sourceChannel)
  *
- * // The channel completes but emits no values
- * // Useful for consuming side effects without collecting output
+ * Effect.runSync(Channel.runCollect(drainedChannel)) // => []
  * ```
  *
  * @category constructors
@@ -3771,15 +3876,15 @@ export const schedule: {
  *
  * **Example** (Filtering channel output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create a channel with mixed numbers
  * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])
  *
  * // Filter to keep only even numbers
  * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)
- * // Outputs: 2, 4, 6, 8
+ * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]
  *
  * // Filter with type refinement
  * const mixedChannel = Channel.fromIterable([1, "hello", 2, "world", 3])
@@ -3787,7 +3892,7 @@ export const schedule: {
  *   mixedChannel,
  *   (value): value is number => typeof value === "number"
  * )
- * // Outputs: 1, 2, 3 (all typed as numbers)
+ * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]
  * ```
  *
  * @category filtering
@@ -3800,15 +3905,15 @@ export const filter: {
    *
    * **Example** (Filtering channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with mixed numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])
    *
    * // Filter to keep only even numbers
    * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)
-   * // Outputs: 2, 4, 6, 8
+   * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]
    *
    * // Filter with type refinement
    * const mixedChannel = Channel.fromIterable([1, "hello", 2, "world", 3])
@@ -3816,7 +3921,7 @@ export const filter: {
    *   mixedChannel,
    *   (value): value is number => typeof value === "number"
    * )
-   * // Outputs: 1, 2, 3 (all typed as numbers)
+   * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -3831,15 +3936,15 @@ export const filter: {
    *
    * **Example** (Filtering channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with mixed numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])
    *
    * // Filter to keep only even numbers
    * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)
-   * // Outputs: 2, 4, 6, 8
+   * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]
    *
    * // Filter with type refinement
    * const mixedChannel = Channel.fromIterable([1, "hello", 2, "world", 3])
@@ -3847,7 +3952,7 @@ export const filter: {
    *   mixedChannel,
    *   (value): value is number => typeof value === "number"
    * )
-   * // Outputs: 1, 2, 3 (all typed as numbers)
+   * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -3862,15 +3967,15 @@ export const filter: {
    *
    * **Example** (Filtering channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with mixed numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])
    *
    * // Filter to keep only even numbers
    * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)
-   * // Outputs: 2, 4, 6, 8
+   * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]
    *
    * // Filter with type refinement
    * const mixedChannel = Channel.fromIterable([1, "hello", 2, "world", 3])
@@ -3878,7 +3983,7 @@ export const filter: {
    *   mixedChannel,
    *   (value): value is number => typeof value === "number"
    * )
-   * // Outputs: 1, 2, 3 (all typed as numbers)
+   * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -3894,15 +3999,15 @@ export const filter: {
    *
    * **Example** (Filtering channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with mixed numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5, 6, 7, 8])
    *
    * // Filter to keep only even numbers
    * const evenChannel = Channel.filter(numbersChannel, (n) => n % 2 === 0)
-   * // Outputs: 2, 4, 6, 8
+   * Effect.runSync(Channel.runCollect(evenChannel)) // => [2, 4, 6, 8]
    *
    * // Filter with type refinement
    * const mixedChannel = Channel.fromIterable([1, "hello", 2, "world", 3])
@@ -3910,7 +4015,7 @@ export const filter: {
    *   mixedChannel,
    *   (value): value is number => typeof value === "number"
    * )
-   * // Outputs: 1, 2, 3 (all typed as numbers)
+   * Effect.runSync(Channel.runCollect(numbersOnlyChannel)) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -4203,8 +4308,8 @@ export const filterMapEffect: {
  *
  * **Example** (Filtering array output)
  *
- * ```ts
- * import { Array, Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Channel, Effect } from "effect"
  *
  * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
  *
@@ -4217,7 +4322,7 @@ export const filterMapEffect: {
  *
  * // Filter arrays to keep only even numbers
  * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
- * // Outputs: [2, 4], [6, 8, 10], [12, 14]
+ * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
  * // Note: Only non-empty filtered arrays are emitted
  *
  * // Arrays that would become empty after filtering are discarded entirely
@@ -4227,7 +4332,7 @@ export const filterMapEffect: {
  *   Array.make(7, 9)
  * ]).pipe(Channel.filter(nonEmptyArrayPredicate))
  * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
- * // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+ * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
  * ```
  *
  * @category filtering
@@ -4240,8 +4345,8 @@ export const filterArray: {
    *
    * **Example** (Filtering array output)
    *
-   * ```ts
-   * import { Array, Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Array, Channel, Effect } from "effect"
    *
    * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
    *
@@ -4254,7 +4359,7 @@ export const filterArray: {
    *
    * // Filter arrays to keep only even numbers
    * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4], [6, 8, 10], [12, 14]
+   * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
    * // Note: Only non-empty filtered arrays are emitted
    *
    * // Arrays that would become empty after filtering are discarded entirely
@@ -4264,7 +4369,7 @@ export const filterArray: {
    *   Array.make(7, 9)
    * ]).pipe(Channel.filter(nonEmptyArrayPredicate))
    * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+   * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
    * ```
    *
    * @category filtering
@@ -4279,8 +4384,8 @@ export const filterArray: {
    *
    * **Example** (Filtering array output)
    *
-   * ```ts
-   * import { Array, Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Array, Channel, Effect } from "effect"
    *
    * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
    *
@@ -4293,7 +4398,7 @@ export const filterArray: {
    *
    * // Filter arrays to keep only even numbers
    * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4], [6, 8, 10], [12, 14]
+   * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
    * // Note: Only non-empty filtered arrays are emitted
    *
    * // Arrays that would become empty after filtering are discarded entirely
@@ -4303,7 +4408,7 @@ export const filterArray: {
    *   Array.make(7, 9)
    * ]).pipe(Channel.filter(nonEmptyArrayPredicate))
    * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+   * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
    * ```
    *
    * @category filtering
@@ -4318,8 +4423,8 @@ export const filterArray: {
    *
    * **Example** (Filtering array output)
    *
-   * ```ts
-   * import { Array, Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Array, Channel, Effect } from "effect"
    *
    * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
    *
@@ -4332,7 +4437,7 @@ export const filterArray: {
    *
    * // Filter arrays to keep only even numbers
    * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4], [6, 8, 10], [12, 14]
+   * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
    * // Note: Only non-empty filtered arrays are emitted
    *
    * // Arrays that would become empty after filtering are discarded entirely
@@ -4342,7 +4447,7 @@ export const filterArray: {
    *   Array.make(7, 9)
    * ]).pipe(Channel.filter(nonEmptyArrayPredicate))
    * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+   * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
    * ```
    *
    * @category filtering
@@ -4358,8 +4463,8 @@ export const filterArray: {
    *
    * **Example** (Filtering array output)
    *
-   * ```ts
-   * import { Array, Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Array, Channel, Effect } from "effect"
    *
    * const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
    *
@@ -4372,7 +4477,7 @@ export const filterArray: {
    *
    * // Filter arrays to keep only even numbers
    * const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4], [6, 8, 10], [12, 14]
+   * Effect.runSync(Channel.runCollect(evenArraysChannel)) // => [[2, 4], [6, 8, 10], [12, 14]]
    * // Note: Only non-empty filtered arrays are emitted
    *
    * // Arrays that would become empty after filtering are discarded entirely
@@ -4382,7 +4487,7 @@ export const filterArray: {
    *   Array.make(7, 9)
    * ]).pipe(Channel.filter(nonEmptyArrayPredicate))
    * const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
-   * // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+   * Effect.runSync(Channel.runCollect(filteredOddChannel)) // => [[2, 4]]
    * ```
    *
    * @category filtering
@@ -4640,7 +4745,7 @@ export const filterMapArrayEffect: {
  *
  * **Example** (Mapping with accumulated state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Create a channel with numbers
@@ -4656,8 +4761,6 @@ export const filterMapArrayEffect: {
  *     return [newSum, [current, newSum]] as const
  *   }
  * )
- * // Outputs: 1, 1, 2, 3, 3, 6, 4, 10
- *
  * // Using with Effect for async processing
  * const asyncMapAccum = Channel.mapAccum(
  *   numbersChannel,
@@ -4668,6 +4771,8 @@ export const filterMapArrayEffect: {
  *       return [newAcc, [`${value}-processed`, newAcc]] as const
  *     })
  * )
+ * Effect.runSync(Channel.runCollect(runningSum)) // => [1, 1, 2, 3, 3, 6, 4, 10]
+ * Effect.runSync(Channel.runCollect(asyncMapAccum)) // => ["1-processed", "1", "2-processed", "12", "3-processed", "123", "4-processed", "1234"]
  * ```
  *
  * @category sequencing
@@ -4679,7 +4784,7 @@ export const mapAccum: {
    *
    * **Example** (Mapping with accumulated state)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
    * // Create a channel with numbers
@@ -4695,8 +4800,6 @@ export const mapAccum: {
    *     return [newSum, [current, newSum]] as const
    *   }
    * )
-   * // Outputs: 1, 1, 2, 3, 3, 6, 4, 10
-   *
    * // Using with Effect for async processing
    * const asyncMapAccum = Channel.mapAccum(
    *   numbersChannel,
@@ -4707,6 +4810,8 @@ export const mapAccum: {
    *       return [newAcc, [`${value}-processed`, newAcc]] as const
    *     })
    * )
+   * Effect.runSync(Channel.runCollect(runningSum)) // => [1, 1, 2, 3, 3, 6, 4, 10]
+   * Effect.runSync(Channel.runCollect(asyncMapAccum)) // => ["1-processed", "1", "2-processed", "12", "3-processed", "123", "4-processed", "1234"]
    * ```
    *
    * @category sequencing
@@ -4744,7 +4849,7 @@ export const mapAccum: {
    *
    * **Example** (Mapping with accumulated state)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
    * // Create a channel with numbers
@@ -4760,8 +4865,6 @@ export const mapAccum: {
    *     return [newSum, [current, newSum]] as const
    *   }
    * )
-   * // Outputs: 1, 1, 2, 3, 3, 6, 4, 10
-   *
    * // Using with Effect for async processing
    * const asyncMapAccum = Channel.mapAccum(
    *   numbersChannel,
@@ -4772,6 +4875,8 @@ export const mapAccum: {
    *       return [newAcc, [`${value}-processed`, newAcc]] as const
    *     })
    * )
+   * Effect.runSync(Channel.runCollect(runningSum)) // => [1, 1, 2, 3, 3, 6, 4, 10]
+   * Effect.runSync(Channel.runCollect(asyncMapAccum)) // => ["1-processed", "1", "2-processed", "12", "3-processed", "123", "4-processed", "1234"]
    * ```
    *
    * @category sequencing
@@ -4858,15 +4963,15 @@ export const mapAccum: {
  *
  * **Example** (Scanning channel output)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create a channel with numbers
  * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
  *
  * // Scan to create running sum
  * const runningSumChannel = Channel.scan(numbersChannel, 0, (sum, n) => sum + n)
- * // Outputs: 0, 1, 3, 6, 10, 15
+ * Effect.runSync(Channel.runCollect(runningSumChannel)) // => [0, 1, 3, 6, 10, 15]
  * // Note: emits the initial value and each intermediate result
  *
  * // Scan with string concatenation
@@ -4876,7 +4981,7 @@ export const mapAccum: {
  *   "",
  *   (sentence, word) => sentence === "" ? word : `${sentence} ${word}`
  * )
- * // Outputs: "", "hello", "hello world", "hello world from", "hello world from effect"
+ * Effect.runSync(Channel.runCollect(sentenceChannel)) // => ["", "hello", "hello world", "hello world from", "hello world from effect"]
  * ```
  *
  * @category sequencing
@@ -4889,15 +4994,15 @@ export const scan: {
    *
    * **Example** (Scanning channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    *
    * // Scan to create running sum
    * const runningSumChannel = Channel.scan(numbersChannel, 0, (sum, n) => sum + n)
-   * // Outputs: 0, 1, 3, 6, 10, 15
+   * Effect.runSync(Channel.runCollect(runningSumChannel)) // => [0, 1, 3, 6, 10, 15]
    * // Note: emits the initial value and each intermediate result
    *
    * // Scan with string concatenation
@@ -4907,7 +5012,7 @@ export const scan: {
    *   "",
    *   (sentence, word) => sentence === "" ? word : `${sentence} ${word}`
    * )
-   * // Outputs: "", "hello", "hello world", "hello world from", "hello world from effect"
+   * Effect.runSync(Channel.runCollect(sentenceChannel)) // => ["", "hello", "hello world", "hello world from", "hello world from effect"]
    * ```
    *
    * @category sequencing
@@ -4935,15 +5040,15 @@ export const scan: {
    *
    * **Example** (Scanning channel output)
    *
-   * ```ts
-   * import { Channel } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create a channel with numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    *
    * // Scan to create running sum
    * const runningSumChannel = Channel.scan(numbersChannel, 0, (sum, n) => sum + n)
-   * // Outputs: 0, 1, 3, 6, 10, 15
+   * Effect.runSync(Channel.runCollect(runningSumChannel)) // => [0, 1, 3, 6, 10, 15]
    * // Note: emits the initial value and each intermediate result
    *
    * // Scan with string concatenation
@@ -4953,7 +5058,7 @@ export const scan: {
    *   "",
    *   (sentence, word) => sentence === "" ? word : `${sentence} ${word}`
    * )
-   * // Outputs: "", "hello", "hello world", "hello world from", "hello world from effect"
+   * Effect.runSync(Channel.runCollect(sentenceChannel)) // => ["", "hello", "hello world", "hello world from", "hello world from effect"]
    * ```
    *
    * @category sequencing
@@ -4982,7 +5087,7 @@ export const scan: {
  *
  * **Example** (Scanning channel output with effects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect } from "effect"
  *
  * class ScanError extends Data.TaggedError("ScanError")<{
@@ -4998,12 +5103,10 @@ export const scan: {
  *   "",
  *   (acc, value) =>
  *     Effect.gen(function*() {
- *       // Simulate async work
- *       yield* Effect.sleep("10 millis")
  *       return acc + value.toString()
  *     })
  * )
- * // Outputs: "", "1", "12", "123", "1234"
+ * await Effect.runPromise(Channel.runCollect(asyncScanChannel)) // => ["", "1", "12", "123", "1234"]
  *
  * // Scan with error handling
  * const errorHandlingScan = Channel.scanEffect(
@@ -5016,6 +5119,7 @@ export const scan: {
  *     return Effect.succeed(sum + n)
  *   }
  * )
+ * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
  * ```
  *
  * @category sequencing
@@ -5033,7 +5137,7 @@ export const scanEffect: {
    *
    * **Example** (Scanning channel output with effects)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Data, Effect } from "effect"
    *
    * class ScanError extends Data.TaggedError("ScanError")<{
@@ -5049,12 +5153,10 @@ export const scanEffect: {
    *   "",
    *   (acc, value) =>
    *     Effect.gen(function*() {
-   *       // Simulate async work
-   *       yield* Effect.sleep("10 millis")
    *       return acc + value.toString()
    *     })
    * )
-   * // Outputs: "", "1", "12", "123", "1234"
+   * await Effect.runPromise(Channel.runCollect(asyncScanChannel)) // => ["", "1", "12", "123", "1234"]
    *
    * // Scan with error handling
    * const errorHandlingScan = Channel.scanEffect(
@@ -5067,6 +5169,7 @@ export const scanEffect: {
    *     return Effect.succeed(sum + n)
    *   }
    * )
+   * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
    * ```
    *
    * @category sequencing
@@ -5099,7 +5202,7 @@ export const scanEffect: {
    *
    * **Example** (Scanning channel output with effects)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Data, Effect } from "effect"
    *
    * class ScanError extends Data.TaggedError("ScanError")<{
@@ -5115,12 +5218,10 @@ export const scanEffect: {
    *   "",
    *   (acc, value) =>
    *     Effect.gen(function*() {
-   *       // Simulate async work
-   *       yield* Effect.sleep("10 millis")
    *       return acc + value.toString()
    *     })
    * )
-   * // Outputs: "", "1", "12", "123", "1234"
+   * await Effect.runPromise(Channel.runCollect(asyncScanChannel)) // => ["", "1", "12", "123", "1234"]
    *
    * // Scan with error handling
    * const errorHandlingScan = Channel.scanEffect(
@@ -5133,6 +5234,7 @@ export const scanEffect: {
    *     return Effect.succeed(sum + n)
    *   }
    * )
+   * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
    * ```
    *
    * @category sequencing
@@ -5174,8 +5276,8 @@ export const scanEffect: {
  *
  * **Example** (Recovering from failure causes)
  *
- * ```ts
- * import { Cause, Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Data, Effect } from "effect"
  *
  * class ProcessError extends Data.TaggedError("ProcessError")<{
  *   readonly reason: string
@@ -5198,7 +5300,7 @@ export const scanEffect: {
  *   return Channel.succeed("Recovered from interruption")
  * })
  *
- * // The channel recovers gracefully from errors
+ * Effect.runSync(Channel.runCollect(recoveredChannel)) // => ["Recovered from failure"]
  * ```
  *
  * @category error handling
@@ -5211,8 +5313,8 @@ export const catchCause: {
    *
    * **Example** (Recovering from failure causes)
    *
-   * ```ts
-   * import { Cause, Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Cause, Channel, Data, Effect } from "effect"
    *
    * class ProcessError extends Data.TaggedError("ProcessError")<{
    *   readonly reason: string
@@ -5235,7 +5337,7 @@ export const catchCause: {
    *   return Channel.succeed("Recovered from interruption")
    * })
    *
-   * // The channel recovers gracefully from errors
+   * Effect.runSync(Channel.runCollect(recoveredChannel)) // => ["Recovered from failure"]
    * ```
    *
    * @category error handling
@@ -5265,8 +5367,8 @@ export const catchCause: {
    *
    * **Example** (Recovering from failure causes)
    *
-   * ```ts
-   * import { Cause, Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Cause, Channel, Data, Effect } from "effect"
    *
    * class ProcessError extends Data.TaggedError("ProcessError")<{
    *   readonly reason: string
@@ -5289,7 +5391,7 @@ export const catchCause: {
    *   return Channel.succeed("Recovered from interruption")
    * })
    *
-   * // The channel recovers gracefully from errors
+   * Effect.runSync(Channel.runCollect(recoveredChannel)) // => ["Recovered from failure"]
    * ```
    *
    * @category error handling
@@ -6762,8 +6864,8 @@ export const catchTag: {
  *
  * **Example** (Recovering from nested reasons)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class RateLimitError extends Data.TaggedError("RateLimitError")<{
  *   retryAfter: number
@@ -6777,15 +6879,15 @@ export const catchTag: {
  *   reason: RateLimitError | QuotaExceededError
  * }> {}
  *
- * const channel = Channel.fail(
- *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
- * )
+ * const reason = new RateLimitError({ retryAfter: 60 })
+ * const channel = Channel.fail(new AiError({ reason }))
  *
  * const recovered = channel.pipe(
  *   Channel.catchReason("AiError", "RateLimitError", (reason) =>
  *     Channel.succeed(`retry: ${reason.retryAfter}`)
  *   )
  * )
+ * Effect.runSync(Channel.runCollect(recovered)) // => ["retry: 60"]
  * ```
  *
  * @category error handling
@@ -6797,8 +6899,8 @@ export const catchReason: {
    *
    * **Example** (Recovering from nested reasons)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class RateLimitError extends Data.TaggedError("RateLimitError")<{
    *   retryAfter: number
@@ -6812,15 +6914,15 @@ export const catchReason: {
    *   reason: RateLimitError | QuotaExceededError
    * }> {}
    *
-   * const channel = Channel.fail(
-   *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
-   * )
+   * const reason = new RateLimitError({ retryAfter: 60 })
+   * const channel = Channel.fail(new AiError({ reason }))
    *
    * const recovered = channel.pipe(
    *   Channel.catchReason("AiError", "RateLimitError", (reason) =>
    *     Channel.succeed(`retry: ${reason.retryAfter}`)
    *   )
    * )
+   * Effect.runSync(Channel.runCollect(recovered)) // => ["retry: 60"]
    * ```
    *
    * @category error handling
@@ -6883,8 +6985,8 @@ export const catchReason: {
    *
    * **Example** (Recovering from nested reasons)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class RateLimitError extends Data.TaggedError("RateLimitError")<{
    *   retryAfter: number
@@ -6898,15 +7000,15 @@ export const catchReason: {
    *   reason: RateLimitError | QuotaExceededError
    * }> {}
    *
-   * const channel = Channel.fail(
-   *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
-   * )
+   * const reason = new RateLimitError({ retryAfter: 60 })
+   * const channel = Channel.fail(new AiError({ reason }))
    *
    * const recovered = channel.pipe(
    *   Channel.catchReason("AiError", "RateLimitError", (reason) =>
    *     Channel.succeed(`retry: ${reason.retryAfter}`)
    *   )
    * )
+   * Effect.runSync(Channel.runCollect(recovered)) // => ["retry: 60"]
    * ```
    *
    * @category error handling
@@ -7227,8 +7329,8 @@ export const catchReasons: {
  *
  * **Example** (Promoting nested reasons)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Exit } from "effect"
  *
  * class RateLimitError extends Data.TaggedError("RateLimitError")<{
  *   retryAfter: number
@@ -7242,11 +7344,11 @@ export const catchReasons: {
  *   reason: RateLimitError | QuotaExceededError
  * }> {}
  *
- * const channel = Channel.fail(
- *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
- * )
+ * const reason = new RateLimitError({ retryAfter: 60 })
+ * const channel = Channel.fail(new AiError({ reason }))
  *
  * const unwrapped = channel.pipe(Channel.unwrapReason("AiError"))
+ * Effect.runSync(Effect.exit(Channel.runCollect(unwrapped))) // => Exit.fail(reason)
  * ```
  *
  * @category error handling
@@ -7258,8 +7360,8 @@ export const unwrapReason: {
    *
    * **Example** (Promoting nested reasons)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class RateLimitError extends Data.TaggedError("RateLimitError")<{
    *   retryAfter: number
@@ -7273,11 +7375,11 @@ export const unwrapReason: {
    *   reason: RateLimitError | QuotaExceededError
    * }> {}
    *
-   * const channel = Channel.fail(
-   *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
-   * )
+   * const reason = new RateLimitError({ retryAfter: 60 })
+   * const channel = Channel.fail(new AiError({ reason }))
    *
    * const unwrapped = channel.pipe(Channel.unwrapReason("AiError"))
+   * Effect.runSync(Effect.exit(Channel.runCollect(unwrapped))) // => Exit.fail(reason)
    * ```
    *
    * @category error handling
@@ -7302,8 +7404,8 @@ export const unwrapReason: {
    *
    * **Example** (Promoting nested reasons)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class RateLimitError extends Data.TaggedError("RateLimitError")<{
    *   retryAfter: number
@@ -7317,11 +7419,11 @@ export const unwrapReason: {
    *   reason: RateLimitError | QuotaExceededError
    * }> {}
    *
-   * const channel = Channel.fail(
-   *   new AiError({ reason: new RateLimitError({ retryAfter: 60 }) })
-   * )
+   * const reason = new RateLimitError({ retryAfter: 60 })
+   * const channel = Channel.fail(new AiError({ reason }))
    *
    * const unwrapped = channel.pipe(Channel.unwrapReason("AiError"))
+   * Effect.runSync(Effect.exit(Channel.runCollect(unwrapped))) // => Exit.fail(reason)
    * ```
    *
    * @category error handling
@@ -7419,20 +7521,21 @@ export const mapError: {
  *
  * **Example** (Converting failures to defects)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Cause, Channel, Data, Effect, Exit } from "effect"
  *
  * class ValidationError extends Data.TaggedError("ValidationError")<{
  *   readonly field: string
  * }> {}
  *
  * // Create a channel that might fail
- * const failingChannel = Channel.fail(new ValidationError({ field: "email" }))
+ * const error = new ValidationError({ field: "email" })
+ * const failingChannel = Channel.fail(error)
  *
  * // Convert failures to defects
  * const fatalChannel = Channel.orDie(failingChannel)
  *
- * // Any failure will now become a defect (uncaught exception)
+ * Effect.runSync(Effect.exit(Channel.runCollect(fatalChannel))) // => Exit.failCause(Cause.die(error))
  * ```
  *
  * @category error handling
@@ -7647,8 +7750,8 @@ export const retry: {
  *
  * **Example** (Switching mapped channels)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class SwitchError extends Data.TaggedError("SwitchError")<{
  *   readonly reason: string
@@ -7663,7 +7766,7 @@ export const retry: {
  *   (n) => Channel.fromIterable([`value-${n}`])
  * )
  *
- * // Outputs: "value-1", "value-2", "value-3"
+ * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
  * ```
  *
  * @category sequencing
@@ -7682,8 +7785,8 @@ export const switchMap: {
    *
    * **Example** (Switching mapped channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class SwitchError extends Data.TaggedError("SwitchError")<{
    *   readonly reason: string
@@ -7698,7 +7801,7 @@ export const switchMap: {
    *   (n) => Channel.fromIterable([`value-${n}`])
    * )
    *
-   * // Outputs: "value-1", "value-2", "value-3"
+   * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
    * ```
    *
    * @category sequencing
@@ -7733,8 +7836,8 @@ export const switchMap: {
    *
    * **Example** (Switching mapped channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class SwitchError extends Data.TaggedError("SwitchError")<{
    *   readonly reason: string
@@ -7749,7 +7852,7 @@ export const switchMap: {
    *   (n) => Channel.fromIterable([`value-${n}`])
    * )
    *
-   * // Outputs: "value-1", "value-2", "value-3"
+   * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
    * ```
    *
    * @category sequencing
@@ -7839,8 +7942,8 @@ export const switchMap: {
  *
  * **Example** (Merging nested channels)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class MergeAllError extends Data.TaggedError("MergeAllError")<{
  *   readonly reason: string
@@ -7855,11 +7958,11 @@ export const switchMap: {
  *
  * // Merge all channels with bounded concurrency
  * const mergedChannel = Channel.mergeAll({
- *   concurrency: 2,
+ *   concurrency: 1,
  *   bufferSize: 16
  * })(nestedChannels)
  *
- * // Outputs: 1, 2, 3, 4, 5, 6 (order may vary due to concurrency)
+ * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
  * ```
  *
  * @category combining
@@ -7876,8 +7979,8 @@ export const mergeAll: {
    *
    * **Example** (Merging nested channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class MergeAllError extends Data.TaggedError("MergeAllError")<{
    *   readonly reason: string
@@ -7892,11 +7995,11 @@ export const mergeAll: {
    *
    * // Merge all channels with bounded concurrency
    * const mergedChannel = Channel.mergeAll({
-   *   concurrency: 2,
+   *   concurrency: 1,
    *   bufferSize: 16
    * })(nestedChannels)
    *
-   * // Outputs: 1, 2, 3, 4, 5, 6 (order may vary due to concurrency)
+   * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
    * ```
    *
    * @category combining
@@ -7937,8 +8040,8 @@ export const mergeAll: {
    *
    * **Example** (Merging nested channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class MergeAllError extends Data.TaggedError("MergeAllError")<{
    *   readonly reason: string
@@ -7953,11 +8056,11 @@ export const mergeAll: {
    *
    * // Merge all channels with bounded concurrency
    * const mergedChannel = Channel.mergeAll({
-   *   concurrency: 2,
+   *   concurrency: 1,
    *   bufferSize: 16
    * })(nestedChannels)
    *
-   * // Outputs: 1, 2, 3, 4, 5, 6 (order may vary due to concurrency)
+   * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
    * ```
    *
    * @category combining
@@ -8032,8 +8135,8 @@ export const mergeAll: {
          *
          * **Example** (Merging nested channels)
          *
-         * ```ts
-         * import { Channel, Data } from "effect"
+         * ```ts import.meta.vitest
+         * import { Channel, Data, Effect } from "effect"
          *
          * class MergeAllError extends Data.TaggedError("MergeAllError")<{
          *   readonly reason: string
@@ -8048,11 +8151,11 @@ export const mergeAll: {
          *
          * // Merge all channels with bounded concurrency
          * const mergedChannel = Channel.mergeAll({
-         *   concurrency: 2,
+         *   concurrency: 1,
          *   bufferSize: 16
          * })(nestedChannels)
          *
-         * // Outputs: 1, 2, 3, 4, 5, 6 (order may vary due to concurrency)
+         * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
          * ```
          *
          * @category combining
@@ -8068,8 +8171,8 @@ export const mergeAll: {
          *
          * **Example** (Merging nested channels)
          *
-         * ```ts
-         * import { Channel, Data } from "effect"
+         * ```ts import.meta.vitest
+         * import { Channel, Data, Effect } from "effect"
          *
          * class MergeAllError extends Data.TaggedError("MergeAllError")<{
          *   readonly reason: string
@@ -8084,11 +8187,11 @@ export const mergeAll: {
          *
          * // Merge all channels with bounded concurrency
          * const mergedChannel = Channel.mergeAll({
-         *   concurrency: 2,
+         *   concurrency: 1,
          *   bufferSize: 16
          * })(nestedChannels)
          *
-         * // Outputs: 1, 2, 3, 4, 5, 6 (order may vary due to concurrency)
+         * await Effect.runPromise(Channel.runCollect(mergedChannel)) // => [1, 2, 3, 4, 5, 6]
          * ```
          *
          * @category combining
@@ -8103,8 +8206,21 @@ export const mergeAll: {
 
         yield* Effect.gen(function*() {
           while (true) {
-            if (semaphore) yield* semaphore.take(1)
-            const channel = yield* pull
+            let pullFiber: Fiber.Fiber<Pull.Success<typeof pull>, any> | undefined
+            if (semaphore) {
+              if (fibers.size < concurrencyN) {
+                yield* semaphore.take(1)
+              } else {
+                pullFiber = yield* Effect.forkChild(pull)
+                yield* Effect.raceFirst(
+                  semaphore.take(1),
+                  Effect.andThen(Fiber.join(pullFiber), Effect.never)
+                )
+              }
+            }
+            const channel = pullFiber === undefined
+              ? yield* pull
+              : yield* Fiber.join(pullFiber)
             const childScope = Scope.forkUnsafe(forkedScope)
             const childPull = yield* toTransform(channel)(upstream, childScope)
 
@@ -8139,7 +8255,13 @@ export const mergeAll: {
             fibers.add(fiber)
           }
         }).pipe(
-          Effect.catchCause((cause) => doneLatch.whenOpen(Queue.failCause(queue, cause))),
+          Effect.catchCause((cause) => {
+            const halt = Pull.filterDone(cause)
+            if (Result.isSuccess(halt)) {
+              return doneLatch.whenOpen(Queue.failCause(queue, cause))
+            }
+            return Queue.failCause(queue, cause)
+          }),
           Effect.forkIn(forkedScope)
         )
 
@@ -8153,14 +8275,11 @@ export const mergeAll: {
  *
  * **Example** (Choosing merge halt strategies)
  *
- * ```ts
- * import type { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel } from "effect"
  *
  * // Different halt strategies for channel merging
- * const leftFirst: Channel.HaltStrategy = "left" // Stop when left channel halts
- * const rightFirst: Channel.HaltStrategy = "right" // Stop when right channel halts
- * const both: Channel.HaltStrategy = "both" // Stop when both channels halt
- * const either: Channel.HaltStrategy = "either" // Stop when either channel halts
+ * const strategies: Array<Channel.HaltStrategy> = ["left", "right", "both", "either"] // => ["left", "right", "both", "either"]
  * ```
  *
  * @category models
@@ -8174,24 +8293,18 @@ export type HaltStrategy = "left" | "right" | "both" | "either"
  *
  * **Example** (Merging channels)
  *
- * ```ts
- * import { Channel, Data } from "effect"
- *
- * class MergeError extends Data.TaggedError("MergeError")<{
- *   readonly source: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * // Create two channels
  * const leftChannel = Channel.fromIterable([1, 2, 3])
  * const rightChannel = Channel.fromIterable(["a", "b", "c"])
  *
- * // Merge them with "either" halt strategy
- * const mergedChannel = Channel.merge(leftChannel, rightChannel, {
- *   haltStrategy: "either"
- * })
+ * // The default "both" strategy waits for both channels to complete
+ * const mergedChannel = Channel.merge(leftChannel, rightChannel)
  *
- * // Outputs elements from both channels concurrently
- * // Order may vary: 1, "a", 2, "b", 3, "c"
+ * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+ * values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
  * ```
  *
  * @category combining
@@ -8204,24 +8317,18 @@ export const merge: {
    *
    * **Example** (Merging channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
-   *
-   * class MergeError extends Data.TaggedError("MergeError")<{
-   *   readonly source: string
-   * }> {}
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create two channels
    * const leftChannel = Channel.fromIterable([1, 2, 3])
    * const rightChannel = Channel.fromIterable(["a", "b", "c"])
    *
-   * // Merge them with "either" halt strategy
-   * const mergedChannel = Channel.merge(leftChannel, rightChannel, {
-   *   haltStrategy: "either"
-   * })
+   * // The default "both" strategy waits for both channels to complete
+   * const mergedChannel = Channel.merge(leftChannel, rightChannel)
    *
-   * // Outputs elements from both channels concurrently
-   * // Order may vary: 1, "a", 2, "b", 3, "c"
+   * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+   * values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
    * ```
    *
    * @category combining
@@ -8249,24 +8356,18 @@ export const merge: {
    *
    * **Example** (Merging channels)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
-   *
-   * class MergeError extends Data.TaggedError("MergeError")<{
-   *   readonly source: string
-   * }> {}
+   * ```ts import.meta.vitest
+   * import { Channel, Effect } from "effect"
    *
    * // Create two channels
    * const leftChannel = Channel.fromIterable([1, 2, 3])
    * const rightChannel = Channel.fromIterable(["a", "b", "c"])
    *
-   * // Merge them with "either" halt strategy
-   * const mergedChannel = Channel.merge(leftChannel, rightChannel, {
-   *   haltStrategy: "either"
-   * })
+   * // The default "both" strategy waits for both channels to complete
+   * const mergedChannel = Channel.merge(leftChannel, rightChannel)
    *
-   * // Outputs elements from both channels concurrently
-   * // Order may vary: 1, "a", 2, "b", 3, "c"
+   * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+   * values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
    * ```
    *
    * @category combining
@@ -8340,24 +8441,18 @@ export const merge: {
      *
      * **Example** (Merging channels)
      *
-     * ```ts
-     * import { Channel, Data } from "effect"
-     *
-     * class MergeError extends Data.TaggedError("MergeError")<{
-     *   readonly source: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Channel, Effect } from "effect"
      *
      * // Create two channels
      * const leftChannel = Channel.fromIterable([1, 2, 3])
      * const rightChannel = Channel.fromIterable(["a", "b", "c"])
      *
-     * // Merge them with "either" halt strategy
-     * const mergedChannel = Channel.merge(leftChannel, rightChannel, {
-     *   haltStrategy: "either"
-     * })
+     * // The default "both" strategy waits for both channels to complete
+     * const mergedChannel = Channel.merge(leftChannel, rightChannel)
      *
-     * // Outputs elements from both channels concurrently
-     * // Order may vary: 1, "a", 2, "b", 3, "c"
+     * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+     * values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
      * ```
      *
      * @category combining
@@ -8369,24 +8464,18 @@ export const merge: {
      *
      * **Example** (Merging channels)
      *
-     * ```ts
-     * import { Channel, Data } from "effect"
-     *
-     * class MergeError extends Data.TaggedError("MergeError")<{
-     *   readonly source: string
-     * }> {}
+     * ```ts import.meta.vitest
+     * import { Channel, Effect } from "effect"
      *
      * // Create two channels
      * const leftChannel = Channel.fromIterable([1, 2, 3])
      * const rightChannel = Channel.fromIterable(["a", "b", "c"])
      *
-     * // Merge them with "either" halt strategy
-     * const mergedChannel = Channel.merge(leftChannel, rightChannel, {
-     *   haltStrategy: "either"
-     * })
+     * // The default "both" strategy waits for both channels to complete
+     * const mergedChannel = Channel.merge(leftChannel, rightChannel)
      *
-     * // Outputs elements from both channels concurrently
-     * // Order may vary: 1, "a", 2, "b", 3, "c"
+     * const values = await Effect.runPromise(Channel.runCollect(mergedChannel))
+     * values.map(String).sort() // => ["1", "2", "3", "a", "b", "c"]
      * ```
      *
      * @category combining
@@ -8532,19 +8621,16 @@ export const mergeEffect: {
  *
  * **Example** (Splitting string chunks into lines)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Stream } from "effect"
  *
- * Effect.runPromise(Effect.gen(function*() {
- *   const result = yield* Stream.runCollect(
- *     Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
- *   )
- *   console.log(result)
- *   // [ 'hello', 'world' ]
- * }))
+ * const result = await Effect.runPromise(Stream.runCollect(
+ *   Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
+ * ))
+ * result // => ["hello", "world"]
  * ```
  *
- * @category String manipulation
+ * @category splitting
  * @since 2.0.0
  */
 export const splitLines = <Err, Done>(): Channel<
@@ -8658,7 +8744,7 @@ export const splitLines = <Err, Done>(): Channel<
  * span `Uint8Array` boundaries. The optional `encoding` and `options` are
  * passed to `TextDecoder`.
  *
- * @category String manipulation
+ * @category decoding
  * @since 4.0.0
  */
 export const decodeText = <Err, Done>(encoding?: string, options?: TextDecoderOptions): Channel<
@@ -8684,7 +8770,7 @@ export const decodeText = <Err, Done>(encoding?: string, options?: TextDecoderOp
  *
  * Each string inside an emitted array is encoded independently.
  *
- * @category String manipulation
+ * @category encoding
  * @since 4.0.0
  */
 export const encodeText = <Err, Done>(): Channel<
@@ -8710,8 +8796,8 @@ export const encodeText = <Err, Done>(): Channel<
  *
  * **Example** (Piping one channel into another)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class PipeError extends Data.TaggedError("PipeError")<{
  *   readonly stage: string
@@ -8724,7 +8810,7 @@ export const encodeText = <Err, Done>(): Channel<
  * // Pipe the source into the transform
  * const pipedChannel = Channel.pipeTo(sourceChannel, transformChannel)
  *
- * // Outputs: 2, 4, 6
+ * Effect.runSync(Channel.runCollect(pipedChannel)) // => [2, 4, 6]
  * ```
  *
  * @category sequencing
@@ -8739,8 +8825,8 @@ export const pipeTo: {
    *
    * **Example** (Piping one channel into another)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class PipeError extends Data.TaggedError("PipeError")<{
    *   readonly stage: string
@@ -8753,7 +8839,7 @@ export const pipeTo: {
    * // Pipe the source into the transform
    * const pipedChannel = Channel.pipeTo(sourceChannel, transformChannel)
    *
-   * // Outputs: 2, 4, 6
+   * Effect.runSync(Channel.runCollect(pipedChannel)) // => [2, 4, 6]
    * ```
    *
    * @category sequencing
@@ -8770,8 +8856,8 @@ export const pipeTo: {
    *
    * **Example** (Piping one channel into another)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class PipeError extends Data.TaggedError("PipeError")<{
    *   readonly stage: string
@@ -8784,7 +8870,7 @@ export const pipeTo: {
    * // Pipe the source into the transform
    * const pipedChannel = Channel.pipeTo(sourceChannel, transformChannel)
    *
-   * // Outputs: 2, 4, 6
+   * Effect.runSync(Channel.runCollect(pipedChannel)) // => [2, 4, 6]
    * ```
    *
    * @category sequencing
@@ -8812,21 +8898,22 @@ export const pipeTo: {
  *
  * **Example** (Piping while preserving failures)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Exit } from "effect"
  *
  * class SourceError extends Data.TaggedError("SourceError")<{
  *   readonly code: number
  * }> {}
  *
  * // Create a failing source channel
- * const failingSource = Channel.fail(new SourceError({ code: 404 }))
- * const safeTransform = Channel.succeed("transformed")
+ * const error = new SourceError({ code: 404 })
+ * const failingSource = Channel.fail(error)
+ * const safeTransform = Channel.identity<never, never, never>()
  *
  * // Pipe while preserving source failures
  * const safePipedChannel = Channel.pipeToOrFail(failingSource, safeTransform)
  *
- * // Source errors are preserved and not sent to transform channel
+ * Effect.runSync(Effect.exit(Channel.runCollect(safePipedChannel))) // => Exit.fail(error)
  * ```
  *
  * @category sequencing
@@ -8840,21 +8927,22 @@ export const pipeToOrFail: {
    *
    * **Example** (Piping while preserving failures)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class SourceError extends Data.TaggedError("SourceError")<{
    *   readonly code: number
    * }> {}
    *
    * // Create a failing source channel
-   * const failingSource = Channel.fail(new SourceError({ code: 404 }))
-   * const safeTransform = Channel.succeed("transformed")
+   * const error = new SourceError({ code: 404 })
+   * const failingSource = Channel.fail(error)
+   * const safeTransform = Channel.identity<never, never, never>()
    *
    * // Pipe while preserving source failures
    * const safePipedChannel = Channel.pipeToOrFail(failingSource, safeTransform)
    *
-   * // Source errors are preserved and not sent to transform channel
+   * Effect.runSync(Effect.exit(Channel.runCollect(safePipedChannel))) // => Exit.fail(error)
    * ```
    *
    * @category sequencing
@@ -8870,21 +8958,22 @@ export const pipeToOrFail: {
    *
    * **Example** (Piping while preserving failures)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class SourceError extends Data.TaggedError("SourceError")<{
    *   readonly code: number
    * }> {}
    *
    * // Create a failing source channel
-   * const failingSource = Channel.fail(new SourceError({ code: 404 }))
-   * const safeTransform = Channel.succeed("transformed")
+   * const error = new SourceError({ code: 404 })
+   * const failingSource = Channel.fail(error)
+   * const safeTransform = Channel.identity<never, never, never>()
    *
    * // Pipe while preserving source failures
    * const safePipedChannel = Channel.pipeToOrFail(failingSource, safeTransform)
    *
-   * // Source errors are preserved and not sent to transform channel
+   * Effect.runSync(Effect.exit(Channel.runCollect(safePipedChannel))) // => Exit.fail(error)
    * ```
    *
    * @category sequencing
@@ -8926,7 +9015,7 @@ export const pipeToOrFail: {
  *
  * **Example** (Unwrapping channel effects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect } from "effect"
  *
  * class UnwrapError extends Data.TaggedError("UnwrapError")<{
@@ -8941,7 +9030,7 @@ export const pipeToOrFail: {
  * // Unwrap the effect to get the channel
  * const unwrappedChannel = Channel.unwrap(channelEffect)
  *
- * // The resulting channel outputs: 1, 2, 3
+ * Effect.runSync(Channel.runCollect(unwrappedChannel)) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -8990,7 +9079,7 @@ export const scoped = <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
  *
  * **Example** (Embedding custom input handling)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Create a base channel
@@ -9001,13 +9090,11 @@ export const scoped = <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
  *   baseChannel,
  *   (upstream) =>
  *     upstream.pipe(
- *       Effect.tap((message) =>
- *         Effect.sync(() => console.log(message))
- *       ),
  *       Effect.forever,
  *       Effect.ignore
  *     )
  * )
+ * await Effect.runPromise(Channel.runCollect(embeddedChannel)) // => [1, 2, 3]
  * ```
  *
  * @category sequencing
@@ -9025,7 +9112,7 @@ export const embedInput: {
    *
    * **Example** (Embedding custom input handling)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
    * // Create a base channel
@@ -9036,13 +9123,11 @@ export const embedInput: {
    *   baseChannel,
    *   (upstream) =>
    *     upstream.pipe(
-   *       Effect.tap((message) =>
-   *         Effect.sync(() => console.log(message))
-   *       ),
    *       Effect.forever,
    *       Effect.ignore
    *     )
    * )
+   * await Effect.runPromise(Channel.runCollect(embeddedChannel)) // => [1, 2, 3]
    * ```
    *
    * @category sequencing
@@ -9066,7 +9151,7 @@ export const embedInput: {
    *
    * **Example** (Embedding custom input handling)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Channel, Effect } from "effect"
    *
    * // Create a base channel
@@ -9077,13 +9162,11 @@ export const embedInput: {
    *   baseChannel,
    *   (upstream) =>
    *     upstream.pipe(
-   *       Effect.tap((message) =>
-   *         Effect.sync(() => console.log(message))
-   *       ),
    *       Effect.forever,
    *       Effect.ignore
    *     )
    * )
+   * await Effect.runPromise(Channel.runCollect(embeddedChannel)) // => [1, 2, 3]
    * ```
    *
    * @category sequencing
@@ -9133,7 +9216,7 @@ export const embedInput: {
  *
  * @see {@link bufferArray} for buffering elements from array outputs
  *
- * @category Buffering
+ * @category buffering
  * @since 2.0.0
  */
 export const buffer: {
@@ -9159,7 +9242,7 @@ export const buffer: {
    *
    * @see {@link bufferArray} for buffering elements from array outputs
    *
-   * @category Buffering
+   * @category buffering
    * @since 2.0.0
    */
   (
@@ -9192,7 +9275,7 @@ export const buffer: {
    *
    * @see {@link bufferArray} for buffering elements from array outputs
    *
-   * @category Buffering
+   * @category buffering
    * @since 2.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -9233,7 +9316,7 @@ export const buffer: {
      *
      * @see {@link bufferArray} for buffering elements from array outputs
      *
-     * @category Buffering
+     * @category buffering
      * @since 2.0.0
      */
     OutElem, /**
@@ -9258,7 +9341,7 @@ export const buffer: {
      *
      * @see {@link bufferArray} for buffering elements from array outputs
      *
-     * @category Buffering
+     * @category buffering
      * @since 2.0.0
      */
     OutErr | Cause.Done<OutDone>>({
@@ -9299,7 +9382,7 @@ export const buffer: {
  *
  * @see {@link buffer} for buffering output elements without flattening arrays
  *
- * @category Buffering
+ * @category buffering
  * @since 4.0.0
  */
 export const bufferArray: {
@@ -9327,7 +9410,7 @@ export const bufferArray: {
    *
    * @see {@link buffer} for buffering output elements without flattening arrays
    *
-   * @category Buffering
+   * @category buffering
    * @since 4.0.0
    */
   (
@@ -9362,7 +9445,7 @@ export const bufferArray: {
    *
    * @see {@link buffer} for buffering output elements without flattening arrays
    *
-   * @category Buffering
+   * @category buffering
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -9405,7 +9488,7 @@ export const bufferArray: {
      *
      * @see {@link buffer} for buffering output elements without flattening arrays
      *
-     * @category Buffering
+     * @category buffering
      * @since 4.0.0
      */
     OutElem, /**
@@ -9432,7 +9515,7 @@ export const bufferArray: {
      *
      * @see {@link buffer} for buffering output elements without flattening arrays
      *
-     * @category Buffering
+     * @category buffering
      * @since 4.0.0
      */
     OutErr | Cause.Done<OutDone>>({
@@ -9571,17 +9654,16 @@ export const haltWhen: {
 ): Channel<OutElem, OutErr | OutErr2, OutDone | OutDone2, InElem, InErr, InDone, Env2 | Env> =>
   fromTransformBracket(Effect.fnUntraced(function*(upstream, scope, forkedScope) {
     const pull = yield* toTransform(self)(upstream, scope)
-    let haltCause: Cause.Cause<OutErr2 | Cause.Done<OutDone2>> | undefined = undefined
-    yield* effect.pipe(
-      Effect.catchCause((cause) => {
-        haltCause = cause
-        return Effect.void
-      }),
-      Effect.forkIn(forkedScope)
-    )
-    return Effect.suspend((): Pull.Pull<OutElem, OutErr | OutErr2, OutDone | OutDone2> =>
-      haltCause ? Effect.failCause(haltCause) : pull
-    )
+    const fiber = yield* Effect.forkIn(effect, forkedScope, { startImmediately: true })
+    return Effect.suspend((): Pull.Pull<OutElem, OutErr | OutErr2, OutDone | OutDone2> => {
+      const exit = fiber.pollUnsafe()
+      return exit === undefined
+        ? pull
+        : Exit.match(exit, {
+          onFailure: Effect.failCause,
+          onSuccess: Cause.done
+        })
+    })
   })))
 
 /**
@@ -9639,8 +9721,8 @@ export const onError: {
  *
  * **Example** (Running exit finalizers)
  *
- * ```ts
- * import { Channel, Console, Data, Exit } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Exit } from "effect"
  *
  * class ExitError extends Data.TaggedError("ExitError")<{
  *   readonly stage: string
@@ -9650,13 +9732,12 @@ export const onError: {
  * const dataChannel = Channel.fromIterable([1, 2, 3])
  *
  * // Attach exit handler
+ * const exits: Array<Exit.Exit<void, ExitError>> = []
  * const channelWithExit = Channel.onExit(dataChannel, (exit) => {
- *   if (Exit.isSuccess(exit)) {
- *     return Console.log(`Channel completed successfully with: ${exit.value}`)
- *   } else {
- *     return Console.log(`Channel failed with: ${exit.cause}`)
- *   }
+ *   exits.push(exit)
+ *   return Effect.void
  * })
+ * const observed = [await Effect.runPromise(Channel.runCollect(channelWithExit)), exits] // => [[1, 2, 3], [Exit.void]]
  * ```
  *
  * @category resource management
@@ -9669,8 +9750,8 @@ export const onExit: {
    *
    * **Example** (Running exit finalizers)
    *
-   * ```ts
-   * import { Channel, Console, Data, Exit } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class ExitError extends Data.TaggedError("ExitError")<{
    *   readonly stage: string
@@ -9680,13 +9761,12 @@ export const onExit: {
    * const dataChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Attach exit handler
+   * const exits: Array<Exit.Exit<void, ExitError>> = []
    * const channelWithExit = Channel.onExit(dataChannel, (exit) => {
-   *   if (Exit.isSuccess(exit)) {
-   *     return Console.log(`Channel completed successfully with: ${exit.value}`)
-   *   } else {
-   *     return Console.log(`Channel failed with: ${exit.cause}`)
-   *   }
+   *   exits.push(exit)
+   *   return Effect.void
    * })
+   * const observed = [await Effect.runPromise(Channel.runCollect(channelWithExit)), exits] // => [[1, 2, 3], [Exit.void]]
    * ```
    *
    * @category resource management
@@ -9703,8 +9783,8 @@ export const onExit: {
    *
    * **Example** (Running exit finalizers)
    *
-   * ```ts
-   * import { Channel, Console, Data, Exit } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Exit } from "effect"
    *
    * class ExitError extends Data.TaggedError("ExitError")<{
    *   readonly stage: string
@@ -9714,13 +9794,12 @@ export const onExit: {
    * const dataChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Attach exit handler
+   * const exits: Array<Exit.Exit<void, ExitError>> = []
    * const channelWithExit = Channel.onExit(dataChannel, (exit) => {
-   *   if (Exit.isSuccess(exit)) {
-   *     return Console.log(`Channel completed successfully with: ${exit.value}`)
-   *   } else {
-   *     return Console.log(`Channel failed with: ${exit.cause}`)
-   *   }
+   *   exits.push(exit)
+   *   return Effect.void
    * })
+   * const observed = [await Effect.runPromise(Channel.runCollect(channelWithExit)), exits] // => [[1, 2, 3], [Exit.void]]
    * ```
    *
    * @category resource management
@@ -9919,8 +9998,8 @@ export const onEnd: {
  *
  * **Example** (Ensuring cleanup runs)
  *
- * ```ts
- * import { Channel, Console, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class EnsureError extends Data.TaggedError("EnsureError")<{
  *   readonly operation: string
@@ -9930,10 +10009,12 @@ export const onEnd: {
  * const dataChannel = Channel.fromIterable([1, 2, 3])
  *
  * // Ensure cleanup always runs
+ * const events: Array<string> = []
  * const channelWithCleanup = Channel.ensuring(
  *   dataChannel,
- *   Console.log("Cleanup executed regardless of success or failure")
+ *   Effect.sync(() => events.push("cleanup"))
  * )
+ * const observed = [await Effect.runPromise(Channel.runCollect(channelWithCleanup)), events] // => [[1, 2, 3], ["cleanup"]]
  * ```
  *
  * @category resource management
@@ -9946,8 +10027,8 @@ export const ensuring: {
    *
    * **Example** (Ensuring cleanup runs)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class EnsureError extends Data.TaggedError("EnsureError")<{
    *   readonly operation: string
@@ -9957,10 +10038,12 @@ export const ensuring: {
    * const dataChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Ensure cleanup always runs
+   * const events: Array<string> = []
    * const channelWithCleanup = Channel.ensuring(
    *   dataChannel,
-   *   Console.log("Cleanup executed regardless of success or failure")
+   *   Effect.sync(() => events.push("cleanup"))
    * )
+   * const observed = [await Effect.runPromise(Channel.runCollect(channelWithCleanup)), events] // => [[1, 2, 3], ["cleanup"]]
    * ```
    *
    * @category resource management
@@ -9975,8 +10058,8 @@ export const ensuring: {
    *
    * **Example** (Ensuring cleanup runs)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class EnsureError extends Data.TaggedError("EnsureError")<{
    *   readonly operation: string
@@ -9986,10 +10069,12 @@ export const ensuring: {
    * const dataChannel = Channel.fromIterable([1, 2, 3])
    *
    * // Ensure cleanup always runs
+   * const events: Array<string> = []
    * const channelWithCleanup = Channel.ensuring(
    *   dataChannel,
-   *   Console.log("Cleanup executed regardless of success or failure")
+   *   Effect.sync(() => events.push("cleanup"))
    * )
+   * const observed = [await Effect.runPromise(Channel.runCollect(channelWithCleanup)), events] // => [[1, 2, 3], ["cleanup"]]
    * ```
    *
    * @category resource management
@@ -10030,7 +10115,7 @@ const runWith = <
 /**
  * Creates a channel from the specified services.
  *
- * @category services
+ * @category accessors
  * @since 2.0.0
  */
 export const contextWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(
@@ -10044,7 +10129,7 @@ export const contextWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone
  * Provides a `Context` to the channel, removing the corresponding service
  * requirements from the returned channel.
  *
- * @category services
+ * @category providing services
  * @since 2.0.0
  */
 export const provideContext: {
@@ -10052,7 +10137,7 @@ export const provideContext: {
    * Provides a `Context` to the channel, removing the corresponding service
    * requirements from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <R2>(context: Context.Context<R2>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10062,7 +10147,7 @@ export const provideContext: {
    * Provides a `Context` to the channel, removing the corresponding service
    * requirements from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
@@ -10084,7 +10169,7 @@ export const provideContext: {
  * Provides a concrete service for a context key, removing that service
  * requirement from the returned channel.
  *
- * @category services
+ * @category providing services
  * @since 2.0.0
  */
 export const provideService: {
@@ -10092,7 +10177,7 @@ export const provideService: {
    * Provides a concrete service for a context key, removing that service
    * requirement from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10102,7 +10187,7 @@ export const provideService: {
    * Provides a concrete service for a context key, removing that service
    * requirement from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
@@ -10135,7 +10220,7 @@ export const provideService: {
  * If the service effect fails, the returned channel fails. The provided service
  * removes the corresponding service requirement from the returned channel.
  *
- * @category services
+ * @category providing services
  * @since 4.0.0
  */
 export const provideServiceEffect: {
@@ -10152,7 +10237,7 @@ export const provideServiceEffect: {
    * If the service effect fails, the returned channel fails. The provided service
    * removes the corresponding service requirement from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <I, S, ES, RS>(key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10171,7 +10256,7 @@ export const provideServiceEffect: {
    * If the service effect fails, the returned channel fails. The provided service
    * removes the corresponding service requirement from the returned channel.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
@@ -10201,7 +10286,7 @@ export const provideServiceEffect: {
  * builds the layer in the channel scope. Use `options.local` to build a fresh
  * layer instance for this provision.
  *
- * @category services
+ * @category providing services
  * @since 4.0.0
  */
 export const provide: {
@@ -10215,7 +10300,7 @@ export const provide: {
    * builds the layer in the channel scope. Use `options.local` to build a fresh
    * layer instance for this provision.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <A, E = never, R = never>(
@@ -10236,7 +10321,7 @@ export const provide: {
    * builds the layer in the channel scope. Use `options.local` to build a fresh
    * layer instance for this provision.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, A, E = never, R = never>(
@@ -10275,7 +10360,7 @@ export const provide: {
  * provide to the channel. The returned channel requires the services needed to
  * build that context.
  *
- * @category services
+ * @category providing services
  * @since 4.0.0
  */
 export const updateContext: {
@@ -10288,7 +10373,7 @@ export const updateContext: {
    * provide to the channel. The returned channel requires the services needed to
    * build that context.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <Env, R2>(f: (context: Context.Context<R2>) => Context.Context<Env>): <OutElem, OutErr, OutDone, InElem, InErr, InDone>(
@@ -10303,7 +10388,7 @@ export const updateContext: {
    * provide to the channel. The returned channel requires the services needed to
    * build that context.
    *
-   * @category services
+   * @category providing services
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
@@ -10329,7 +10414,7 @@ export const updateContext: {
  * The existing service is read from the context. The updated service is
  * provided to the channel under the same key.
  *
- * @category services
+ * @category providing services
  * @since 2.0.0
  */
 export const updateService: {
@@ -10341,7 +10426,7 @@ export const updateService: {
    * The existing service is read from the context. The updated service is
    * provided to the channel under the same key.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <I, S>(key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10355,7 +10440,7 @@ export const updateService: {
    * The existing service is read from the context. The updated service is
    * provided to the channel under the same key.
    *
-   * @category services
+   * @category providing services
    * @since 2.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
@@ -10447,7 +10532,7 @@ const withSpanImpl = <OutElem, OutErr, OutDone, InElem, InErr, InDone, R>(
 /**
  * The starting channel for Do notation, emitting an empty object.
  *
- * @category do notation
+ * @category constructors
  * @since 4.0.0
  */
 export const Do: Channel<{}> = succeed({})
@@ -10501,7 +10586,7 @@ export {
   /**
    * Adds a computed field to each object emitted by a channel.
    *
-   * @category do notation
+   * @category mapping
    * @since 4.0.0
    */
   let_ as let
@@ -10517,7 +10602,7 @@ export {
  * channel's output becomes the value of the new field. `options.concurrency`
  * and `options.bufferSize` control how derived channels are flattened.
  *
- * @category do notation
+ * @category sequencing
  * @since 4.0.0
  */
 export const bind: {
@@ -10531,7 +10616,7 @@ export const bind: {
    * channel's output becomes the value of the new field. `options.concurrency`
    * and `options.bufferSize` control how derived channels are flattened.
    *
-   * @category do notation
+   * @category sequencing
    * @since 4.0.0
    */
   <N extends string, OutElem extends object, B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>(
@@ -10562,7 +10647,7 @@ export const bind: {
    * channel's output becomes the value of the new field. `options.concurrency`
    * and `options.bufferSize` control how derived channels are flattened.
    *
-   * @category do notation
+   * @category sequencing
    * @since 4.0.0
    */
   <
@@ -10649,7 +10734,7 @@ export const bind: {
  * @see {@link bind} for adding a field produced by another channel
  * @see {@link let_ let} for adding a computed field
  *
- * @category do notation
+ * @category mapping
  * @since 4.0.0
  */
 export const bindTo: {
@@ -10665,7 +10750,7 @@ export const bindTo: {
    * @see {@link bind} for adding a field produced by another channel
    * @see {@link let_ let} for adding a computed field
    *
-   * @category do notation
+   * @category mapping
    * @since 4.0.0
    */
   <N extends string>(name: N): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
@@ -10691,7 +10776,7 @@ export const bindTo: {
    * @see {@link bind} for adding a field produced by another channel
    * @see {@link let_ let} for adding a computed field
    *
-   * @category do notation
+   * @category mapping
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, N extends string>(
@@ -10724,8 +10809,8 @@ export const bindTo: {
  *
  * **Example** (Counting channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class CountError extends Data.TaggedError("CountError")<{
  *   readonly reason: string
@@ -10737,10 +10822,10 @@ export const bindTo: {
  * // Count the elements
  * const countEffect = Channel.runCount(numbersChannel)
  *
- * // Effect.runSync(countEffect) // Returns: 5
+ * Effect.runSync(countEffect) // => 5
  * ```
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runCount = <OutElem, OutErr, OutDone, Env>(
@@ -10752,8 +10837,8 @@ export const runCount = <OutElem, OutErr, OutDone, Env>(
  *
  * **Example** (Draining channel output at runtime)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class DrainError extends Data.TaggedError("DrainError")<{
  *   readonly stage: string
@@ -10761,18 +10846,15 @@ export const runCount = <OutElem, OutErr, OutDone, Env>(
  *
  * // Create a channel that outputs elements and completes with a result
  * const resultChannel = Channel.fromIterable([1, 2, 3])
- * const completedChannel = Channel.concatWith(
- *   resultChannel,
- *   () => Channel.succeed("completed")
- * )
+ * const completedChannel = Channel.concat(resultChannel, Channel.end("completed"))
  *
  * // Drain all elements and get only the final result
  * const drainEffect = Channel.runDrain(completedChannel)
  *
- * // Effect.runSync(drainEffect) // Returns: "completed"
+ * Effect.runSync(drainEffect) // => "completed"
  * ```
  *
- * @category execution
+ * @category running
  * @since 2.0.0
  */
 export const runDrain = <OutElem, OutErr, OutDone, Env>(
@@ -10784,8 +10866,8 @@ export const runDrain = <OutElem, OutErr, OutDone, Env>(
  *
  * **Example** (Running effects for each output)
  *
- * ```ts
- * import { Channel, Console, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class ForEachError extends Data.TaggedError("ForEachError")<{
  *   readonly element: unknown
@@ -10794,16 +10876,18 @@ export const runDrain = <OutElem, OutErr, OutDone, Env>(
  * // Create a channel with numbers
  * const numbersChannel = Channel.fromIterable([1, 2, 3])
  *
- * // Run forEach to log each element
+ * // Run forEach to process each element
+ * const processed: Array<number> = []
  * const forEachEffect = Channel.runForEach(
  *   numbersChannel,
- *   (n) => Console.log(`Processing: ${n}`)
+ *   (n) => Effect.sync(() => processed.push(n))
  * )
  *
- * // Logs: "Processing: 1", "Processing: 2", "Processing: 3"
+ * await Effect.runPromise(forEachEffect)
+ * processed // => [1, 2, 3]
  * ```
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runForEach: {
@@ -10812,8 +10896,8 @@ export const runForEach: {
    *
    * **Example** (Running effects for each output)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ForEachError extends Data.TaggedError("ForEachError")<{
    *   readonly element: unknown
@@ -10822,16 +10906,18 @@ export const runForEach: {
    * // Create a channel with numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3])
    *
-   * // Run forEach to log each element
+   * // Run forEach to process each element
+   * const processed: Array<number> = []
    * const forEachEffect = Channel.runForEach(
    *   numbersChannel,
-   *   (n) => Console.log(`Processing: ${n}`)
+   *   (n) => Effect.sync(() => processed.push(n))
    * )
    *
-   * // Logs: "Processing: 1", "Processing: 2", "Processing: 3"
+   * await Effect.runPromise(forEachEffect)
+   * processed // => [1, 2, 3]
    * ```
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, EX, RX>(f: (o: OutElem) => Effect.Effect<void, EX, RX>): <OutErr, OutDone, Env>(
@@ -10842,8 +10928,8 @@ export const runForEach: {
    *
    * **Example** (Running effects for each output)
    *
-   * ```ts
-   * import { Channel, Console, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class ForEachError extends Data.TaggedError("ForEachError")<{
    *   readonly element: unknown
@@ -10852,16 +10938,18 @@ export const runForEach: {
    * // Create a channel with numbers
    * const numbersChannel = Channel.fromIterable([1, 2, 3])
    *
-   * // Run forEach to log each element
+   * // Run forEach to process each element
+   * const processed: Array<number> = []
    * const forEachEffect = Channel.runForEach(
    *   numbersChannel,
-   *   (n) => Console.log(`Processing: ${n}`)
+   *   (n) => Effect.sync(() => processed.push(n))
    * )
    *
-   * // Logs: "Processing: 1", "Processing: 2", "Processing: 3"
+   * await Effect.runPromise(forEachEffect)
+   * processed // => [1, 2, 3]
    * ```
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, Env, EX, RX>(
@@ -10886,7 +10974,7 @@ export const runForEach: {
  * Returning `true` continues consuming the channel. Returning `false` stops
  * consumption early. The returned effect completes with `void`.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runForEachWhile: {
@@ -10899,7 +10987,7 @@ export const runForEachWhile: {
    * Returning `true` continues consuming the channel. Returning `false` stops
    * consumption early. The returned effect completes with `void`.
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, EX, RX>(f: (o: OutElem) => Effect.Effect<boolean, EX, RX>): <OutErr, OutDone, Env>(
@@ -10914,7 +11002,7 @@ export const runForEachWhile: {
    * Returning `true` continues consuming the channel. Returning `false` stops
    * consumption early. The returned effect completes with `void`.
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, Env, EX, RX>(
@@ -10940,8 +11028,8 @@ export const runForEachWhile: {
  *
  * **Example** (Collecting channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class CollectError extends Data.TaggedError("CollectError")<{
  *   readonly reason: string
@@ -10953,10 +11041,10 @@ export const runForEachWhile: {
  * // Collect all elements into an array
  * const collectEffect = Channel.runCollect(numbersChannel)
  *
- * // Effect.runSync(collectEffect) // Returns: [1, 2, 3, 4, 5]
+ * Effect.runSync(collectEffect) // => [1, 2, 3, 4, 5]
  * ```
  *
- * @category execution
+ * @category running
  * @since 2.0.0
  */
 export const runCollect = <OutElem, OutErr, OutDone, Env>(
@@ -10970,7 +11058,7 @@ export const runCollect = <OutElem, OutErr, OutDone, Env>(
 /**
  * Runs a channel and outputs the done value.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runDone = <OutElem, OutErr, OutDone, Env>(
@@ -10986,7 +11074,7 @@ export const runDone = <OutElem, OutErr, OutDone, Env>(
  * Returns `Option.some` with the first output element, or `Option.none` if the
  * channel completes without emitting output.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runHead = <OutElem, OutErr, OutDone, Env>(
@@ -11013,7 +11101,7 @@ export const runHead = <OutElem, OutErr, OutDone, Env>(
  * Returns `Option.some` with the last emitted element, or `Option.none` if the
  * channel completes without emitting output.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runLast = <OutElem, OutErr, OutDone, Env>(
@@ -11041,8 +11129,8 @@ export const runLast = <OutElem, OutErr, OutDone, Env>(
  *
  * **Example** (Folding channel output)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect } from "effect"
  *
  * class FoldError extends Data.TaggedError("FoldError")<{
  *   readonly operation: string
@@ -11054,10 +11142,10 @@ export const runLast = <OutElem, OutErr, OutDone, Env>(
  * // Fold to calculate sum
  * const sumEffect = Channel.runFold(numbersChannel, () => 0, (acc, n) => acc + n)
  *
- * // Effect.runSync(sumEffect) // Returns: 15
+ * Effect.runSync(sumEffect) // => 15
  * ```
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runFold: {
@@ -11066,8 +11154,8 @@ export const runFold: {
    *
    * **Example** (Folding channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class FoldError extends Data.TaggedError("FoldError")<{
    *   readonly operation: string
@@ -11079,10 +11167,10 @@ export const runFold: {
    * // Fold to calculate sum
    * const sumEffect = Channel.runFold(numbersChannel, () => 0, (acc, n) => acc + n)
    *
-   * // Effect.runSync(sumEffect) // Returns: 15
+   * Effect.runSync(sumEffect) // => 15
    * ```
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <Z, OutElem>(initial: LazyArg<Z>, f: (acc: Z, o: OutElem) => Z): <OutErr, OutDone, Env>(
@@ -11093,8 +11181,8 @@ export const runFold: {
    *
    * **Example** (Folding channel output)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect } from "effect"
    *
    * class FoldError extends Data.TaggedError("FoldError")<{
    *   readonly operation: string
@@ -11106,10 +11194,10 @@ export const runFold: {
    * // Fold to calculate sum
    * const sumEffect = Channel.runFold(numbersChannel, () => 0, (acc, n) => acc + n)
    *
-   * // Effect.runSync(sumEffect) // Returns: 15
+   * Effect.runSync(sumEffect) // => 15
    * ```
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, Env, Z>(
@@ -11152,7 +11240,7 @@ export const runFold: {
  * the effectful accumulator function. The returned effect succeeds with the
  * final accumulator value.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export const runFoldEffect: {
@@ -11170,7 +11258,7 @@ export const runFoldEffect: {
    * the effectful accumulator function. The returned effect succeeds with the
    * final accumulator value.
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, Z, E, R>(initial: LazyArg<Z>, f: (acc: Z, o: OutElem) => Effect.Effect<Z, E, R>): <OutErr, OutDone, Env>(
@@ -11190,7 +11278,7 @@ export const runFoldEffect: {
    * the effectful accumulator function. The returned effect succeeds with the
    * final accumulator value.
    *
-   * @category execution
+   * @category running
    * @since 4.0.0
    */
   <OutElem, OutErr, OutDone, Env, Z, E, R>(
@@ -11233,7 +11321,7 @@ export const runFoldEffect: {
  *
  * **Example** (Converting channels to pulls)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect } from "effect"
  *
  * class PullError extends Data.TaggedError("PullError")<{
@@ -11243,12 +11331,11 @@ export const runFoldEffect: {
  * // Create a channel
  * const numbersChannel = Channel.fromIterable([1, 2, 3])
  *
- * // Convert to Pull within a scope
- * const pullEffect = Effect.scoped(
- *   Channel.toPull(numbersChannel)
- * )
- *
- * // Use the Pull to manually consume elements
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   const pull = yield* Channel.toPull(numbersChannel)
+ *   return [yield* pull, yield* pull, yield* pull]
+ * }))
+ * await Effect.runPromise(program) // => [1, 2, 3]
  * ```
  *
  * @category destructors
@@ -11282,7 +11369,7 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
  *
  * **Example** (Converting channels to scoped pulls)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect, Scope } from "effect"
  *
  * class ScopedPullError extends Data.TaggedError("ScopedPullError")<{
@@ -11294,10 +11381,11 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
  *
  * // Convert to Pull with explicit scope
  * const scopedPullEffect = Effect.gen(function*() {
- *   const scope = yield* Scope.make()
+ *   const scope = yield* Effect.scope
  *   const pull = yield* Channel.toPullScoped(numbersChannel, scope)
- *   return pull
+ *   return [yield* pull, yield* pull, yield* pull]
  * })
+ * await Effect.runPromise(Effect.scoped(scopedPullEffect)) // => [1, 2, 3]
  * ```
  *
  * @category destructors
@@ -11455,8 +11543,8 @@ export const runIntoQueueArray: {
  *
  * **Example** (Converting channels to queues)
  *
- * ```ts
- * import { Channel, Data } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Data, Effect, Queue } from "effect"
  *
  * class QueueError extends Data.TaggedError("QueueError")<{
  *   readonly operation: string
@@ -11466,10 +11554,11 @@ export const runIntoQueueArray: {
  * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])
  *
  * // Convert to queue for concurrent processing
- * const queueEffect = Channel.toQueue(dataChannel, { capacity: 32 })
- *
- * // The queue can be used for concurrent consumption
- * // Multiple consumers can read from the queue
+ * const program = Effect.scoped(Effect.gen(function*() {
+ *   const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })
+ *   return yield* Queue.takeBetween(queue, 5, 5)
+ * }))
+ * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category destructors
@@ -11488,8 +11577,8 @@ export const toQueue: {
    *
    * **Example** (Converting channels to queues)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Queue } from "effect"
    *
    * class QueueError extends Data.TaggedError("QueueError")<{
    *   readonly operation: string
@@ -11499,10 +11588,11 @@ export const toQueue: {
    * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    *
    * // Convert to queue for concurrent processing
-   * const queueEffect = Channel.toQueue(dataChannel, { capacity: 32 })
-   *
-   * // The queue can be used for concurrent consumption
-   * // Multiple consumers can read from the queue
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })
+   *   return yield* Queue.takeBetween(queue, 5, 5)
+   * }))
+   * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
    * ```
    *
    * @category destructors
@@ -11530,8 +11620,8 @@ export const toQueue: {
    *
    * **Example** (Converting channels to queues)
    *
-   * ```ts
-   * import { Channel, Data } from "effect"
+   * ```ts import.meta.vitest
+   * import { Channel, Data, Effect, Queue } from "effect"
    *
    * class QueueError extends Data.TaggedError("QueueError")<{
    *   readonly operation: string
@@ -11541,10 +11631,11 @@ export const toQueue: {
    * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])
    *
    * // Convert to queue for concurrent processing
-   * const queueEffect = Channel.toQueue(dataChannel, { capacity: 32 })
-   *
-   * // The queue can be used for concurrent consumption
-   * // Multiple consumers can read from the queue
+   * const program = Effect.scoped(Effect.gen(function*() {
+   *   const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })
+   *   return yield* Queue.takeBetween(queue, 5, 5)
+   * }))
+   * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
    * ```
    *
    * @category destructors
@@ -11583,8 +11674,8 @@ export const toQueue: {
      *
      * **Example** (Converting channels to queues)
      *
-     * ```ts
-     * import { Channel, Data } from "effect"
+     * ```ts import.meta.vitest
+     * import { Channel, Data, Effect, Queue } from "effect"
      *
      * class QueueError extends Data.TaggedError("QueueError")<{
      *   readonly operation: string
@@ -11594,10 +11685,11 @@ export const toQueue: {
      * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])
      *
      * // Convert to queue for concurrent processing
-     * const queueEffect = Channel.toQueue(dataChannel, { capacity: 32 })
-     *
-     * // The queue can be used for concurrent consumption
-     * // Multiple consumers can read from the queue
+     * const program = Effect.scoped(Effect.gen(function*() {
+     *   const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })
+     *   return yield* Queue.takeBetween(queue, 5, 5)
+     * }))
+     * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
      * ```
      *
      * @category destructors
@@ -11615,8 +11707,8 @@ export const toQueue: {
      *
      * **Example** (Converting channels to queues)
      *
-     * ```ts
-     * import { Channel, Data } from "effect"
+     * ```ts import.meta.vitest
+     * import { Channel, Data, Effect, Queue } from "effect"
      *
      * class QueueError extends Data.TaggedError("QueueError")<{
      *   readonly operation: string
@@ -11626,10 +11718,11 @@ export const toQueue: {
      * const dataChannel = Channel.fromIterable([1, 2, 3, 4, 5])
      *
      * // Convert to queue for concurrent processing
-     * const queueEffect = Channel.toQueue(dataChannel, { capacity: 32 })
-     *
-     * // The queue can be used for concurrent consumption
-     * // Multiple consumers can read from the queue
+     * const program = Effect.scoped(Effect.gen(function*() {
+     *   const queue = yield* Channel.toQueue(dataChannel, { capacity: 32 })
+     *   return yield* Queue.takeBetween(queue, 5, 5)
+     * }))
+     * await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
      * ```
      *
      * @category destructors