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

package/dist/Channel.d.ts

@@ -51,12 +51,12 @@ export declare const TypeId: TypeId;
  *
  * **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
@@ -90,8 +90,8 @@ export declare const isChannel: (u: unknown) => u is Channel<unknown, unknown, u
  *
  * **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>
@@ -109,6 +109,9 @@ export declare const isChannel: (u: unknown) => u is Channel<unknown, unknown, u
  *   boolean, // InDone - input completion
  *   { db: string } // Env - required environment
  * >
+ *
+ * const channel: NumberChannel = Channel.succeed(1)
+ * Effect.runSync(Channel.runCollect(channel)) // => [1]
  * ```
  *
  * @category models
@@ -198,12 +201,13 @@ export interface VarianceStruct<out OutElem, out OutErr, out OutDone, in InElem,
  *
  * **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
@@ -215,7 +219,7 @@ export declare const fromTransform: <OutElem, OutErr, OutDone, InElem, InErr, In
  *
  * **Example** (Transforming pull behavior)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Transform a channel by modifying its pull behavior
@@ -228,7 +232,7 @@ export declare const fromTransform: <OutElem, OutErr, OutDone, InElem, InErr, In
  *       Effect.map(pull, (value) => value * 2)
  *     )
  * )
- * // Outputs: 2, 4, 6
+ * await Effect.runPromise(Channel.runCollect(transformedChannel)) // => [2, 4, 6]
  * ```
  *
  * @category constructors
@@ -240,12 +244,18 @@ export declare const transformPull: <OutElem, OutErr, OutDone, InElem, InErr, In
  *
  * **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
@@ -273,12 +283,13 @@ export declare const fromTransformBracket: <OutElem, OutErr, OutDone, InElem, 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
@@ -290,10 +301,10 @@ export declare const toTransform: <OutElem, OutErr, OutDone, InElem, InErr, InDo
  *
  * **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
@@ -305,7 +316,7 @@ export declare const DefaultChunkSize: number;
  *
  * **Example** (Creating channels from callbacks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect, Queue } from "effect"
  *
  * const channel = Channel.callback<number>((queue) =>
@@ -313,8 +324,10 @@ export declare const DefaultChunkSize: number;
  *     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
@@ -329,14 +342,15 @@ export declare const callback: <A, E = never, R = never>(f: (queue: Queue.Queue<
  *
  * **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
@@ -351,11 +365,11 @@ export declare const callbackArray: <A, E = never, R = never>(f: (queue: Queue.Q
  *
  * **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
@@ -374,14 +388,16 @@ export declare const suspend: <OutElem, OutErr, OutDone, InElem, InErr, InDone,
  *
  * **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
@@ -400,13 +416,15 @@ export declare const acquireUseRelease: <A, E, R, OutElem, OutErr, OutDone, InEl
  *
  * **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
@@ -425,13 +443,15 @@ export declare 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
@@ -450,13 +470,15 @@ export declare 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
@@ -469,12 +491,12 @@ export declare 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
@@ -486,11 +508,11 @@ export declare const fromIterator: <A, L>(iterator: LazyArg<Iterator<A, L>>) =>
  *
  * **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
@@ -502,12 +524,12 @@ export declare 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
@@ -519,8 +541,8 @@ export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Channel<A>;
  *
  * **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> => {
@@ -536,13 +558,13 @@ export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Channel<A>;
  * }
  *
  * 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> {
@@ -554,7 +576,7 @@ export declare const fromChunk: <A>(chunk: Chunk.Chunk<A>) => Channel<A>;
  * }
  *
  * 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
@@ -566,12 +588,12 @@ export declare const fromIteratorArray: <A, L>(iterator: LazyArg<Iterator<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
@@ -583,12 +605,12 @@ export declare const fromIterable: <A, L>(iterable: Iterable<A, L>) => Channel<A
  *
  * **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
@@ -600,11 +622,11 @@ export declare const fromIterableArray: <A, L>(iterable: Iterable<A, L>, chunkSi
  *
  * **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
@@ -616,11 +638,11 @@ export declare const succeed: <A>(value: A) => Channel<A>;
  *
  * **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
@@ -639,8 +661,8 @@ export declare const endSync: <A>(evaluate: LazyArg<A>) => Channel<never, never,
  *
  * **Example** (Computing values lazily)
  *
- * ```ts
- * import { Channel } from "effect"
+ * ```ts import.meta.vitest
+ * import { Channel, Effect } from "effect"
  *
  * let requests = 0
  *
@@ -648,7 +670,7 @@ export declare const endSync: <A>(evaluate: LazyArg<A>) => Channel<never, never,
  *   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
@@ -660,8 +682,8 @@ export declare const sync: <A>(evaluate: LazyArg<A>) => Channel<A>;
  *
  * **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
@@ -673,6 +695,8 @@ export declare const sync: <A>(evaluate: LazyArg<A>) => Channel<A>;
  * // 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
@@ -684,7 +708,7 @@ export declare const empty: Channel<never>;
  *
  * **Example** (Creating non-terminating channels)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel } from "effect"
  *
  * // Create a channel that never completes
@@ -699,6 +723,8 @@ export declare const empty: Channel<never>;
  * // 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
@@ -710,26 +736,11 @@ export declare const never: Channel<never, never, never>;
  *
  * **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
@@ -747,27 +758,18 @@ export declare const fail: <E>(error: E) => Channel<never, E, never>;
  *
  * **Example** (Failing with a lazy error)
  *
- * ```ts
- * import { Channel } 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")
- * })
+ * ```ts import.meta.vitest
+ * import { Channel, Effect, Exit } from "effect"
  *
- * // 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
@@ -784,20 +786,12 @@ export declare const failSync: <E>(evaluate: LazyArg<E>) => Channel<never, E, ne
  *
  * **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
@@ -810,8 +804,8 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, E,
  *
  * **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
@@ -820,11 +814,10 @@ export declare const failCause: <E>(cause: Cause.Cause<E>) => Channel<never, E,
  *   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
@@ -836,20 +829,12 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Ch
  *
  * **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
@@ -861,33 +846,13 @@ export declare const die: (defect: unknown) => Channel<never, never, never>;
  *
  * **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
@@ -931,35 +896,17 @@ export declare const fromEffectTake: <A, E, Done, E2, R>(effect: Effect.Effect<T
  *
  * **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
@@ -971,39 +918,17 @@ export declare const fromQueue: <A, E>(queue: Queue.Dequeue<A, E>) => Channel<A,
  *
  * **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
@@ -1023,8 +948,8 @@ export declare const identity: <Elem, Err, Done>() => Channel<Elem, Err, Done, E
  *
  * **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
@@ -1049,6 +974,8 @@ export declare const identity: <Elem, Err, Done>() => Channel<Elem, Err, Done, E
  *   // 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*() {
@@ -1074,8 +1001,8 @@ export declare const fromSubscription: <A>(subscription: PubSub.Subscription<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
@@ -1097,12 +1024,14 @@ export declare const fromSubscription: <A>(subscription: PubSub.Subscription<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
@@ -1116,19 +1045,21 @@ export declare const fromSubscription: <A>(subscription: PubSub.Subscription<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<
@@ -1158,8 +1089,12 @@ export declare const fromSubscription: <A>(subscription: PubSub.Subscription<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
@@ -1177,15 +1112,15 @@ export declare const fromSubscriptionArray: <A>(subscription: PubSub.Subscriptio
  *
  * **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)
@@ -1198,15 +1133,17 @@ export declare const fromSubscriptionArray: <A>(subscription: PubSub.Subscriptio
  *   // 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)
@@ -1219,14 +1156,17 @@ export declare const fromSubscriptionArray: <A>(subscription: PubSub.Subscriptio
  *     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
@@ -1235,7 +1175,7 @@ export declare const fromSubscriptionArray: <A>(subscription: PubSub.Subscriptio
  * }
  *
  * 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)
@@ -1252,8 +1192,11 @@ export declare const fromSubscriptionArray: <A>(subscription: PubSub.Subscriptio
  *     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
@@ -1271,15 +1214,15 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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)
@@ -1293,12 +1236,14 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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
@@ -1309,7 +1254,7 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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)
@@ -1330,14 +1275,20 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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
@@ -1347,7 +1298,7 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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)
@@ -1374,8 +1325,17 @@ export declare const fromPubSub: <A>(pubsub: PubSub.PubSub<A>) => Channel<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
@@ -1401,6 +1361,106 @@ export declare const fromPubSubTake: <A, E, Done>(pubsub: PubSub.PubSub<Take.Tak
  * @since 4.0.0
  */
 export declare const fromSchedule: <O, E, R>(schedule: Schedule.Schedule<O, unknown, E, R>) => Channel<O, E, O, unknown, unknown, unknown, R>;
+/**
+ * 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 declare const fromReadableStream: <A, E>(options: {
+    readonly evaluate: LazyArg<ReadableStream<A>>;
+    readonly onError: (error: unknown) => E;
+    readonly releaseLockOnEnd?: boolean | undefined;
+}) => Channel<Arr.NonEmptyReadonlyArray<A>, E>;
+/**
+ * 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 declare 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>;
+/**
+ * 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 declare 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>;
 /**
  * Creates a channel that pulls values from an `AsyncIterable`.
  *
@@ -1434,8 +1494,8 @@ export declare const fromAsyncIterableArray: <A, D, E>(iterable: AsyncIterable<A
  *
  * **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
@@ -1444,12 +1504,12 @@ export declare const fromAsyncIterableArray: <A, D, E>(iterable: AsyncIterable<A
  * // 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 }
@@ -1463,6 +1523,7 @@ export declare const fromAsyncIterableArray: <A, D, E>(iterable: AsyncIterable<A
  *   displayName: `User: ${user.name}`,
  *   isActive: true
  * }))
+ * Effect.runSync(Channel.runCollect(displayChannel)) // => [{ displayName: "User: Alice", isActive: true }, { displayName: "User: Bob", isActive: true }]
  * ```
  *
  * @category sequencing
@@ -1474,8 +1535,8 @@ export declare 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
@@ -1484,12 +1545,12 @@ export declare 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 }
@@ -1503,6 +1564,7 @@ export declare 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
@@ -1514,8 +1576,8 @@ export declare 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
@@ -1524,12 +1586,12 @@ export declare 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 }
@@ -1543,6 +1605,7 @@ export declare 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
@@ -1627,40 +1690,15 @@ export declare const mapDoneEffect: {
  *
  * **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
@@ -1685,40 +1723,15 @@ export declare 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
@@ -1746,40 +1759,15 @@ export declare 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
@@ -1852,8 +1840,8 @@ export declare 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
@@ -1863,13 +1851,13 @@ export declare 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
@@ -1888,8 +1876,8 @@ export declare 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
@@ -1899,13 +1887,13 @@ export declare 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
@@ -1926,8 +1914,8 @@ export declare 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
@@ -1937,13 +1925,13 @@ export declare 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
@@ -1966,8 +1954,8 @@ export declare 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
@@ -1983,8 +1971,7 @@ export declare 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
@@ -2004,8 +1991,8 @@ export declare 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
@@ -2021,8 +2008,7 @@ export declare 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
@@ -2045,8 +2031,8 @@ export declare 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
@@ -2062,8 +2048,7 @@ export declare 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
@@ -2080,8 +2065,8 @@ export declare const flatMap: {
  *
  * **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
@@ -2092,8 +2077,7 @@ export declare const flatMap: {
  *   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
@@ -2106,8 +2090,8 @@ export declare 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
@@ -2118,8 +2102,7 @@ export declare 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
@@ -2132,8 +2115,8 @@ export declare 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
@@ -2144,8 +2127,7 @@ export declare 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
@@ -2159,8 +2141,8 @@ export declare 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
@@ -2173,7 +2155,7 @@ export declare 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
@@ -2186,8 +2168,8 @@ export declare 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
@@ -2200,7 +2182,7 @@ export declare 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
@@ -2213,8 +2195,8 @@ export declare 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
@@ -2227,7 +2209,7 @@ export declare 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
@@ -2338,8 +2320,8 @@ export declare 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
@@ -2355,7 +2337,7 @@ export declare 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
@@ -2367,8 +2349,8 @@ export declare const flatten: <OutElem, OutErr, OutDone, InElem, InErr, InDone,
  *
  * **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
@@ -2384,7 +2366,7 @@ export declare const flatten: <OutElem, OutErr, OutDone, InElem, InErr, InDone,
  * // 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
@@ -2410,8 +2392,8 @@ export declare const flattenTake: <OutElem, OutErr, OutDone, OutErr2, OutDone2,
  *
  * **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])
@@ -2419,8 +2401,7 @@ export declare const flattenTake: <OutElem, OutErr, OutDone, OutErr2, OutDone2,
  * // 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
@@ -2508,15 +2489,15 @@ export declare 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])
@@ -2524,7 +2505,7 @@ export declare 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
@@ -2537,15 +2518,15 @@ export declare 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])
@@ -2553,7 +2534,7 @@ export declare 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
@@ -2566,15 +2547,15 @@ export declare 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])
@@ -2582,7 +2563,7 @@ export declare 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
@@ -2595,15 +2576,15 @@ export declare 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])
@@ -2611,7 +2592,7 @@ export declare 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
@@ -2624,15 +2605,15 @@ export declare 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])
@@ -2640,7 +2621,7 @@ export declare 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
@@ -2846,8 +2827,8 @@ export declare 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
  *
@@ -2860,7 +2841,7 @@ export declare 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
@@ -2870,7 +2851,7 @@ export declare 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
@@ -2883,8 +2864,8 @@ export declare 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
      *
@@ -2897,7 +2878,7 @@ export declare 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
@@ -2907,7 +2888,7 @@ export declare 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
@@ -2920,8 +2901,8 @@ export declare 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
      *
@@ -2934,7 +2915,7 @@ export declare 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
@@ -2944,7 +2925,7 @@ export declare 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
@@ -2957,8 +2938,8 @@ export declare 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
      *
@@ -2971,7 +2952,7 @@ export declare 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
@@ -2981,7 +2962,7 @@ export declare 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
@@ -2994,8 +2975,8 @@ export declare 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
      *
@@ -3008,7 +2989,7 @@ export declare 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
@@ -3018,7 +2999,7 @@ export declare 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
@@ -3187,7 +3168,7 @@ export declare const filterMapArrayEffect: {
  *
  * **Example** (Mapping with accumulated state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Create a channel with numbers
@@ -3203,8 +3184,6 @@ export declare 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,
@@ -3215,6 +3194,8 @@ export declare 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
@@ -3226,7 +3207,7 @@ export declare const mapAccum: {
      *
      * **Example** (Mapping with accumulated state)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Channel, Effect } from "effect"
      *
      * // Create a channel with numbers
@@ -3242,8 +3223,6 @@ export declare 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,
@@ -3254,6 +3233,8 @@ export declare 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
@@ -3267,7 +3248,7 @@ export declare const mapAccum: {
      *
      * **Example** (Mapping with accumulated state)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Channel, Effect } from "effect"
      *
      * // Create a channel with numbers
@@ -3283,8 +3264,6 @@ export declare 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,
@@ -3295,6 +3274,8 @@ export declare 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
@@ -3310,15 +3291,15 @@ export declare 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
@@ -3328,7 +3309,7 @@ export declare 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
@@ -3341,15 +3322,15 @@ export declare 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
@@ -3359,7 +3340,7 @@ export declare 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
@@ -3372,15 +3353,15 @@ export declare 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
@@ -3390,7 +3371,7 @@ export declare 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
@@ -3409,7 +3390,7 @@ export declare 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")<{
@@ -3425,12 +3406,10 @@ export declare 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(
@@ -3443,6 +3422,7 @@ export declare const scan: {
  *     return Effect.succeed(sum + n)
  *   }
  * )
+ * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
  * ```
  *
  * @category sequencing
@@ -3460,7 +3440,7 @@ export declare 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")<{
@@ -3476,12 +3456,10 @@ export declare 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(
@@ -3494,6 +3472,7 @@ export declare const scanEffect: {
      *     return Effect.succeed(sum + n)
      *   }
      * )
+     * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
      * ```
      *
      * @category sequencing
@@ -3511,7 +3490,7 @@ export declare 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")<{
@@ -3527,12 +3506,10 @@ export declare 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(
@@ -3545,6 +3522,7 @@ export declare const scanEffect: {
      *     return Effect.succeed(sum + n)
      *   }
      * )
+     * await Effect.runPromise(Channel.runCollect(errorHandlingScan)) // => [0, 1, 3, 6, 10]
      * ```
      *
      * @category sequencing
@@ -3558,8 +3536,8 @@ export declare 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
@@ -3582,7 +3560,7 @@ export declare 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
@@ -3595,8 +3573,8 @@ export declare 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
@@ -3619,7 +3597,7 @@ export declare 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
@@ -3632,8 +3610,8 @@ export declare 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
@@ -3656,7 +3634,7 @@ export declare 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
@@ -4139,8 +4117,8 @@ export declare 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
@@ -4154,15 +4132,15 @@ export declare 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
@@ -4174,8 +4152,8 @@ export declare 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
@@ -4189,15 +4167,15 @@ export declare 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
@@ -4209,8 +4187,8 @@ export declare 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
@@ -4224,15 +4202,15 @@ export declare 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
@@ -4299,8 +4277,8 @@ export declare 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
@@ -4314,11 +4292,11 @@ export declare 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
@@ -4330,8 +4308,8 @@ export declare 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
@@ -4345,11 +4323,11 @@ export declare 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
@@ -4361,8 +4339,8 @@ export declare 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
@@ -4376,11 +4354,11 @@ export declare 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
@@ -4422,20 +4400,21 @@ export declare 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
@@ -4522,8 +4501,8 @@ export declare 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
@@ -4538,7 +4517,7 @@ export declare const retry: {
  *   (n) => Channel.fromIterable([`value-${n}`])
  * )
  *
- * // Outputs: "value-1", "value-2", "value-3"
+ * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
  * ```
  *
  * @category sequencing
@@ -4557,8 +4536,8 @@ export declare 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
@@ -4573,7 +4552,7 @@ export declare const switchMap: {
      *   (n) => Channel.fromIterable([`value-${n}`])
      * )
      *
-     * // Outputs: "value-1", "value-2", "value-3"
+     * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
      * ```
      *
      * @category sequencing
@@ -4595,8 +4574,8 @@ export declare 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
@@ -4611,7 +4590,7 @@ export declare const switchMap: {
      *   (n) => Channel.fromIterable([`value-${n}`])
      * )
      *
-     * // Outputs: "value-1", "value-2", "value-3"
+     * await Effect.runPromise(Channel.runCollect(switchedChannel)) // => ["value-3"]
      * ```
      *
      * @category sequencing
@@ -4632,8 +4611,8 @@ export declare 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
@@ -4648,11 +4627,11 @@ export declare 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
@@ -4669,8 +4648,8 @@ export declare 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
@@ -4685,11 +4664,11 @@ export declare 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
@@ -4710,8 +4689,8 @@ export declare 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
@@ -4726,11 +4705,11 @@ export declare 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
@@ -4747,14 +4726,11 @@ export declare 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
@@ -4767,24 +4743,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
@@ -4797,24 +4767,18 @@ export declare 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
@@ -4829,24 +4793,18 @@ export declare 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
@@ -4925,19 +4883,16 @@ export declare 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 declare const splitLines: <Err, Done>() => Channel<Arr.NonEmptyReadonlyArray<string>, Err, Done, Arr.NonEmptyReadonlyArray<string>, Err, Done>;
@@ -4950,7 +4905,7 @@ export declare const splitLines: <Err, Done>() => Channel<Arr.NonEmptyReadonlyAr
  * span `Uint8Array` boundaries. The optional `encoding` and `options` are
  * passed to `TextDecoder`.
  *
- * @category String manipulation
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decodeText: <Err, Done>(encoding?: string, options?: TextDecoderOptions) => Channel<Arr.NonEmptyReadonlyArray<string>, Err, Done, Arr.NonEmptyReadonlyArray<Uint8Array>, Err, Done>;
@@ -4961,7 +4916,7 @@ export declare const decodeText: <Err, Done>(encoding?: string, options?: TextDe
  *
  * Each string inside an emitted array is encoded independently.
  *
- * @category String manipulation
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encodeText: <Err, Done>() => Channel<Arr.NonEmptyReadonlyArray<Uint8Array>, Err, Done, Arr.NonEmptyReadonlyArray<string>, Err, Done>;
@@ -4973,8 +4928,8 @@ export declare const encodeText: <Err, Done>() => Channel<Arr.NonEmptyReadonlyAr
  *
  * **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
@@ -4987,7 +4942,7 @@ export declare const encodeText: <Err, Done>() => Channel<Arr.NonEmptyReadonlyAr
  * // 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
@@ -5002,8 +4957,8 @@ export declare 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
@@ -5016,7 +4971,7 @@ export declare 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
@@ -5031,8 +4986,8 @@ export declare 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
@@ -5045,7 +5000,7 @@ export declare 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
@@ -5060,21 +5015,22 @@ export declare 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
@@ -5088,21 +5044,22 @@ export declare 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
@@ -5116,21 +5073,22 @@ export declare 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
@@ -5144,7 +5102,7 @@ export declare const pipeToOrFail: {
  *
  * **Example** (Unwrapping channel effects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect } from "effect"
  *
  * class UnwrapError extends Data.TaggedError("UnwrapError")<{
@@ -5159,7 +5117,7 @@ export declare 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
@@ -5185,7 +5143,7 @@ export declare const scoped: <OutElem, OutErr, OutDone, InElem, InErr, InDone, E
  *
  * **Example** (Embedding custom input handling)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Effect } from "effect"
  *
  * // Create a base channel
@@ -5196,13 +5154,11 @@ export declare const scoped: <OutElem, OutErr, OutDone, InElem, InErr, InDone, E
  *   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
@@ -5220,7 +5176,7 @@ export declare const embedInput: {
      *
      * **Example** (Embedding custom input handling)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Channel, Effect } from "effect"
      *
      * // Create a base channel
@@ -5231,13 +5187,11 @@ export declare 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
@@ -5255,7 +5209,7 @@ export declare const embedInput: {
      *
      * **Example** (Embedding custom input handling)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Channel, Effect } from "effect"
      *
      * // Create a base channel
@@ -5266,13 +5220,11 @@ export declare 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
@@ -5302,7 +5254,7 @@ export declare const embedInput: {
  *
  * @see {@link bufferArray} for buffering elements from array outputs
  *
- * @category Buffering
+ * @category buffering
  * @since 2.0.0
  */
 export declare const buffer: {
@@ -5328,7 +5280,7 @@ export declare const buffer: {
      *
      * @see {@link bufferArray} for buffering elements from array outputs
      *
-     * @category Buffering
+     * @category buffering
      * @since 2.0.0
      */
     (options: {
@@ -5359,7 +5311,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, options: {
@@ -5393,7 +5345,7 @@ export declare const buffer: {
  *
  * @see {@link buffer} for buffering output elements without flattening arrays
  *
- * @category Buffering
+ * @category buffering
  * @since 4.0.0
  */
 export declare const bufferArray: {
@@ -5421,7 +5373,7 @@ export declare const bufferArray: {
      *
      * @see {@link buffer} for buffering output elements without flattening arrays
      *
-     * @category Buffering
+     * @category buffering
      * @since 4.0.0
      */
     (options: {
@@ -5454,7 +5406,7 @@ export declare 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>(self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>, options: {
@@ -5605,8 +5557,8 @@ export declare 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
@@ -5616,13 +5568,12 @@ export declare 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
@@ -5635,8 +5586,8 @@ export declare 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
@@ -5646,13 +5597,12 @@ export declare 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
@@ -5665,8 +5615,8 @@ export declare 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
@@ -5676,13 +5626,12 @@ export declare 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
@@ -5828,8 +5777,8 @@ export declare 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
@@ -5839,10 +5788,12 @@ export declare 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
@@ -5855,8 +5806,8 @@ export declare 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
@@ -5866,10 +5817,12 @@ export declare 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
@@ -5882,8 +5835,8 @@ export declare 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
@@ -5893,10 +5846,12 @@ export declare 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
@@ -5907,7 +5862,7 @@ export declare const ensuring: {
 /**
  * Creates a channel from the specified services.
  *
- * @category services
+ * @category accessors
  * @since 2.0.0
  */
 export declare const contextWith: <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(f: (context: Context.Context<Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env | Env2>;
@@ -5915,7 +5870,7 @@ export declare const contextWith: <Env, OutElem, OutErr, OutDone, InElem, InErr,
  * 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 declare const provideContext: {
@@ -5923,7 +5878,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>>;
@@ -5931,7 +5886,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, context: Context.Context<R2>): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>>;
@@ -5940,7 +5895,7 @@ export declare 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 declare const provideService: {
@@ -5948,7 +5903,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>;
@@ -5956,7 +5911,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, key: Context.Key<I, S>, service: NoInfer<S>): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>;
@@ -5974,7 +5929,7 @@ export declare 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 declare const provideServiceEffect: {
@@ -5991,7 +5946,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>;
@@ -6008,7 +5963,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>;
@@ -6023,7 +5978,7 @@ export declare 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 declare const provide: {
@@ -6037,7 +5992,7 @@ export declare 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>(layer: Layer.Layer<A, E, R> | Context.Context<A>, options?: {
@@ -6053,7 +6008,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, layer: Layer.Layer<A, E, R> | Context.Context<A>, options?: {
@@ -6069,7 +6024,7 @@ export declare 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 declare const updateContext: {
@@ -6082,7 +6037,7 @@ export declare 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>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>;
@@ -6095,7 +6050,7 @@ export declare 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>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, f: (context: Context.Context<R2>) => Context.Context<Env>): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>;
@@ -6108,7 +6063,7 @@ export declare 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 declare const updateService: {
@@ -6120,7 +6075,7 @@ export declare 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>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>;
@@ -6132,7 +6087,7 @@ export declare 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>(self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>, service: Context.Key<I, S>, f: (service: NoInfer<S>) => S): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>;
@@ -6177,7 +6132,7 @@ export declare const withSpan: {
 /**
  * The starting channel for Do notation, emitting an empty object.
  *
- * @category do notation
+ * @category constructors
  * @since 4.0.0
  */
 export declare const Do: Channel<{}>;
@@ -6193,7 +6148,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 };
@@ -6207,7 +6162,7 @@ let_ as let };
  * 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 declare const bind: {
@@ -6221,7 +6176,7 @@ export declare 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>(name: Exclude<N, keyof OutElem>, f: (a: NoInfer<OutElem>) => Channel<B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>, options?: {
@@ -6240,7 +6195,7 @@ export declare 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
      */
     <OutElem extends object, OutErr, OutDone, InElem, InErr, InDone, Env, N extends string, B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, name: Exclude<N, keyof OutElem>, f: (a: NoInfer<OutElem>) => Channel<B, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>, options?: {
@@ -6262,7 +6217,7 @@ export declare 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 declare const bindTo: {
@@ -6278,7 +6233,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<{
@@ -6296,7 +6251,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>, name: N): Channel<{
@@ -6308,8 +6263,8 @@ export declare 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
@@ -6321,10 +6276,10 @@ export declare 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 declare const runCount: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<void, OutErr, Env>;
@@ -6333,8 +6288,8 @@ export declare const runCount: <OutElem, OutErr, OutDone, Env>(self: Channel<Out
  *
  * **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
@@ -6342,18 +6297,15 @@ export declare const runCount: <OutElem, OutErr, OutDone, Env>(self: Channel<Out
  *
  * // 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 declare const runDrain: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<OutDone, OutErr, Env>;
@@ -6362,8 +6314,8 @@ export declare const runDrain: <OutElem, OutErr, OutDone, Env>(self: Channel<Out
  *
  * **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
@@ -6372,16 +6324,18 @@ export declare const runDrain: <OutElem, OutErr, OutDone, Env>(self: Channel<Out
  * // 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 declare const runForEach: {
@@ -6390,8 +6344,8 @@ export declare 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
@@ -6400,16 +6354,18 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<OutDone, OutErr | EX, Env | RX>;
@@ -6418,8 +6374,8 @@ export declare 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
@@ -6428,16 +6384,18 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>, f: (o: OutElem) => Effect.Effect<void, EX, RX>): Effect.Effect<OutDone, OutErr | EX, Env | RX>;
@@ -6451,7 +6409,7 @@ export declare 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 declare const runForEachWhile: {
@@ -6464,7 +6422,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<void, OutErr | EX, Env | RX>;
@@ -6477,7 +6435,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>, f: (o: OutElem) => Effect.Effect<boolean, EX, RX>): Effect.Effect<void, OutErr | EX, Env | RX>;
@@ -6487,8 +6445,8 @@ export declare 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
@@ -6500,17 +6458,17 @@ export declare 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 declare const runCollect: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<Array<OutElem>, OutErr, Env>;
 /**
  * Runs a channel and outputs the done value.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export declare const runDone: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<OutDone, OutErr, Env>;
@@ -6523,7 +6481,7 @@ export declare const runDone: <OutElem, OutErr, OutDone, Env>(self: Channel<OutE
  * 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 declare const runHead: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<Option.Option<OutElem>, OutErr, Env>;
@@ -6536,7 +6494,7 @@ export declare const runHead: <OutElem, OutErr, OutDone, Env>(self: Channel<OutE
  * 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 declare const runLast: <OutElem, OutErr, OutDone, Env>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<Option.Option<OutElem>, OutErr, Env>;
@@ -6545,8 +6503,8 @@ export declare const runLast: <OutElem, OutErr, OutDone, Env>(self: Channel<OutE
  *
  * **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
@@ -6558,10 +6516,10 @@ export declare const runLast: <OutElem, OutErr, OutDone, Env>(self: Channel<OutE
  * // 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 declare const runFold: {
@@ -6570,8 +6528,8 @@ export declare 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
@@ -6583,10 +6541,10 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<Z, OutErr, Env>;
@@ -6595,8 +6553,8 @@ export declare 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
@@ -6608,10 +6566,10 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>, initial: LazyArg<Z>, f: (acc: Z, o: OutElem) => Z): Effect.Effect<Z, OutErr, Env>;
@@ -6630,7 +6588,7 @@ export declare const runFold: {
  * the effectful accumulator function. The returned effect succeeds with the
  * final accumulator value.
  *
- * @category execution
+ * @category running
  * @since 4.0.0
  */
 export declare const runFoldEffect: {
@@ -6648,7 +6606,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>) => Effect.Effect<Z, OutErr | E, Env | R>;
@@ -6666,7 +6624,7 @@ export declare 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>(self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>, initial: LazyArg<Z>, f: (acc: Z, o: OutElem) => Effect.Effect<Z, E, R>): Effect.Effect<Z, OutErr | E, Env | R>;
@@ -6682,7 +6640,7 @@ export declare const runFoldEffect: {
  *
  * **Example** (Converting channels to pulls)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect } from "effect"
  *
  * class PullError extends Data.TaggedError("PullError")<{
@@ -6692,12 +6650,11 @@ export declare 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
@@ -6709,7 +6666,7 @@ export declare const toPull: <OutElem, OutErr, OutDone, Env>(self: Channel<OutEl
  *
  * **Example** (Converting channels to scoped pulls)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Channel, Data, Effect, Scope } from "effect"
  *
  * class ScopedPullError extends Data.TaggedError("ScopedPullError")<{
@@ -6721,10 +6678,11 @@ export declare const toPull: <OutElem, OutErr, OutDone, Env>(self: Channel<OutEl
  *
  * // 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
@@ -6826,8 +6784,8 @@ export declare 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
@@ -6837,10 +6795,11 @@ export declare 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
@@ -6859,8 +6818,8 @@ export declare 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
@@ -6870,10 +6829,11 @@ export declare 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
@@ -6897,8 +6857,8 @@ export declare 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
@@ -6908,10 +6868,11 @@ export declare 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