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

package/dist/Chunk.d.ts

@@ -30,12 +30,12 @@ declare const TypeId = "~effect/collections/Chunk";
  *
  * **Example** (Inspecting chunk values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk: Chunk.Chunk<number> = Chunk.make(1, 2, 3)
- * console.log(chunk.length) // 3
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3]
+ * chunk.length // => 3
+ * Chunk.toArray(chunk) // => [1, 2, 3]
  * ```
  *
  * @category models
@@ -56,12 +56,12 @@ export interface Chunk<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspec
  *
  * **Example** (Working with non-empty chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nonEmptyChunk: Chunk.NonEmptyChunk<number> = Chunk.make(1, 2, 3)
- * console.log(Chunk.headNonEmpty(nonEmptyChunk)) // 1
- * console.log(Chunk.lastNonEmpty(nonEmptyChunk)) // 3
+ * Chunk.headNonEmpty(nonEmptyChunk) // => 1
+ * Chunk.lastNonEmpty(nonEmptyChunk) // => 3
  * ```
  *
  * @category models
@@ -74,7 +74,7 @@ export interface NonEmptyChunk<out A> extends Chunk<A>, NonEmptyIterable<A> {
  *
  * **Example** (Applying the Chunk type lambda)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Chunk, HKT } from "effect"
  *
  * // Create a Chunk type using the type lambda
@@ -82,7 +82,7 @@ export interface NonEmptyChunk<out A> extends Chunk<A>, NonEmptyIterable<A> {
  * // Equivalent to: Chunk<number>
  * ```
  *
- * @category type lambdas
+ * @category utility types
  * @since 2.0.0
  */
 export interface ChunkTypeLambda extends TypeLambda {
@@ -117,7 +117,7 @@ interface ISlice<A> {
  *
  * **Example** (Comparing chunks for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Equivalence } from "effect"
  *
  * const chunk1 = Chunk.make(1, 2, 3)
@@ -125,8 +125,8 @@ interface ISlice<A> {
  * const chunk3 = Chunk.make(1, 2, 4)
  *
  * const eq = Chunk.makeEquivalence(Equivalence.strictEqual<number>())
- * console.log(eq(chunk1, chunk2)) // true
- * console.log(eq(chunk1, chunk3)) // false
+ * eq(chunk1, chunk2) // => true
+ * eq(chunk1, chunk3) // => false
  * ```
  *
  * @category instances
@@ -138,18 +138,18 @@ export declare const makeEquivalence: <A>(isEquivalent: Equivalence.Equivalence<
  *
  * **Example** (Checking for chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
  * const array = [1, 2, 3]
  *
- * console.log(Chunk.isChunk(chunk)) // true
- * console.log(Chunk.isChunk(array)) // false
- * console.log(Chunk.isChunk("string")) // false
+ * Chunk.isChunk(chunk) // => true
+ * Chunk.isChunk(array) // => false
+ * Chunk.isChunk("string") // => false
  * ```
  *
- * @category constructors
+ * @category guards
  * @since 2.0.0
  */
 export declare const isChunk: {
@@ -158,18 +158,18 @@ export declare const isChunk: {
      *
      * **Example** (Checking for chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
      * const array = [1, 2, 3]
      *
-     * console.log(Chunk.isChunk(chunk)) // true
-     * console.log(Chunk.isChunk(array)) // false
-     * console.log(Chunk.isChunk("string")) // false
+     * Chunk.isChunk(chunk) // => true
+     * Chunk.isChunk(array) // => false
+     * Chunk.isChunk("string") // => false
      * ```
      *
-     * @category constructors
+     * @category guards
      * @since 2.0.0
      */
     <A>(u: Iterable<A>): u is Chunk<A>;
@@ -178,18 +178,18 @@ export declare const isChunk: {
      *
      * **Example** (Checking for chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
      * const array = [1, 2, 3]
      *
-     * console.log(Chunk.isChunk(chunk)) // true
-     * console.log(Chunk.isChunk(array)) // false
-     * console.log(Chunk.isChunk("string")) // false
+     * Chunk.isChunk(chunk) // => true
+     * Chunk.isChunk(array) // => false
+     * Chunk.isChunk("string") // => false
      * ```
      *
-     * @category constructors
+     * @category guards
      * @since 2.0.0
      */
     (u: unknown): u is Chunk<unknown>;
@@ -199,11 +199,10 @@ export declare const isChunk: {
  *
  * **Example** (Creating an empty chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const emptyChunk = Chunk.empty()
- * console.log(Chunk.size(emptyChunk)) // 0
+ * Chunk.size(Chunk.empty()) // => 0
  * ```
  *
  * @category constructors
@@ -215,11 +214,10 @@ export declare const empty: <A = never>() => Chunk<A>;
  *
  * **Example** (Creating a non-empty chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.make(1, 2, 3, 4)) // => [1, 2, 3, 4]
  * ```
  *
  * @category constructors
@@ -231,11 +229,10 @@ export declare const make: <As extends readonly [any, ...Array<any>]>(...as: As)
  *
  * **Example** (Creating a single-element chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.of("hello")
- * console.log(Chunk.toArray(chunk)) // ["hello"]
+ * Chunk.toArray(Chunk.of("hello")) // => ["hello"]
  * ```
  *
  * @category constructors
@@ -247,11 +244,10 @@ export declare const of: <A>(a: A) => NonEmptyChunk<A>;
  *
  * **Example** (Creating chunks from iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.fromIterable([1, 2, 3])
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.fromIterable([1, 2, 3])) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -265,17 +261,16 @@ export declare const fromIterable: <A>(self: Iterable<A>) => Chunk<A>;
  *
  * **Example** (Converting chunks to mutable arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
  * const array = Chunk.toArray(chunk)
- * console.log(array) // [1, 2, 3]
- * console.log(Array.isArray(array)) // true
+ * array // => [1, 2, 3]
+ * Array.isArray(array) // => true
  *
  * // With empty chunk
- * const emptyChunk = Chunk.empty<number>()
- * console.log(Chunk.toArray(emptyChunk)) // []
+ * Chunk.toArray(Chunk.empty<number>()) // => []
  * ```
  *
  * @category converting
@@ -289,19 +284,18 @@ export declare const toArray: <S extends Chunk<any>>(self: S) => S extends NonEm
  *
  * **Example** (Converting chunks to readonly arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
  * const readonlyArray = Chunk.toReadonlyArray(chunk)
- * console.log(readonlyArray) // [1, 2, 3]
+ * readonlyArray // => [1, 2, 3]
  *
  * // The result is read-only, modifications would cause TypeScript errors
  * // readonlyArray[0] = 10 // TypeScript error
  *
  * // With empty chunk
- * const emptyChunk = Chunk.empty<number>()
- * console.log(Chunk.toReadonlyArray(emptyChunk)) // []
+ * Chunk.toReadonlyArray(Chunk.empty<number>()) // => []
  * ```
  *
  * @category converting
@@ -322,16 +316,14 @@ export declare const toReadonlyArray: <S extends Chunk<any>>(self: S) => S exten
  *
  * **Example** (Reversing chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
- * const result = Chunk.reverse(chunk)
- *
- * console.log(Chunk.toArray(result)) // [3, 2, 1]
+ * Chunk.toArray(Chunk.reverse(chunk)) // => [3, 2, 1]
  * ```
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export declare const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Infer<S>>;
@@ -341,21 +333,20 @@ export declare const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, C
  *
  * **Example** (Accessing elements safely)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
  *
- * console.log(Chunk.get(chunk, 1)) // Option.some("b")
- * console.log(Chunk.get(chunk, 10)) // Option.none()
- * console.log(Chunk.get(chunk, -1)) // Option.none()
+ * Chunk.get(chunk, 1) // => Option.some("b")
+ * Chunk.get(chunk, 10) // => Option.none()
+ * Chunk.get(chunk, -1) // => Option.none()
  *
  * // Using pipe syntax
- * const result = chunk.pipe(Chunk.get(2))
- * console.log(result) // Option.some("c")
+ * chunk.pipe(Chunk.get(2)) // => Option.some("c")
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const get: {
@@ -365,21 +356,20 @@ export declare const get: {
      *
      * **Example** (Accessing elements safely)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      *
-     * console.log(Chunk.get(chunk, 1)) // Option.some("b")
-     * console.log(Chunk.get(chunk, 10)) // Option.none()
-     * console.log(Chunk.get(chunk, -1)) // Option.none()
+     * Chunk.get(chunk, 1) // => Option.some("b")
+     * Chunk.get(chunk, 10) // => Option.none()
+     * Chunk.get(chunk, -1) // => Option.none()
      *
      * // Using pipe syntax
-     * const result = chunk.pipe(Chunk.get(2))
-     * console.log(result) // Option.some("c")
+     * chunk.pipe(Chunk.get(2)) // => Option.some("c")
      * ```
      *
-     * @category elements
+     * @category getters
      * @since 2.0.0
      */
     (index: number): <A>(self: Chunk<A>) => Option<A>;
@@ -389,21 +379,20 @@ export declare const get: {
      *
      * **Example** (Accessing elements safely)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      *
-     * console.log(Chunk.get(chunk, 1)) // Option.some("b")
-     * console.log(Chunk.get(chunk, 10)) // Option.none()
-     * console.log(Chunk.get(chunk, -1)) // Option.none()
+     * Chunk.get(chunk, 1) // => Option.some("b")
+     * Chunk.get(chunk, 10) // => Option.none()
+     * Chunk.get(chunk, -1) // => Option.none()
      *
      * // Using pipe syntax
-     * const result = chunk.pipe(Chunk.get(2))
-     * console.log(result) // Option.some("c")
+     * chunk.pipe(Chunk.get(2)) // => Option.some("c")
      * ```
      *
-     * @category elements
+     * @category getters
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, index: number): Option<A>;
@@ -422,16 +411,16 @@ export declare const get: {
  *
  * **Example** (Creating chunks without copying arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const array = [1, 2, 3, 4, 5]
  * const chunk = Chunk.fromArrayUnsafe(array)
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3, 4, 5]
+ * Chunk.toArray(chunk) // => [1, 2, 3, 4, 5]
  *
  * // Warning: Since this doesn't copy the array, mutations affect the chunk
  * array[0] = 999
- * console.log(Chunk.toArray(chunk)) // [999, 2, 3, 4, 5]
+ * Chunk.toArray(chunk) // => [999, 2, 3, 4, 5]
  * ```
  *
  * @category unsafe
@@ -452,15 +441,15 @@ export declare const fromArrayUnsafe: <A>(self: ReadonlyArray<A>) => Chunk<A>;
  *
  * **Example** (Creating non-empty chunks without copying arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Chunk } from "effect"
  *
  * const nonEmptyArray = Array.make(1, 2, 3, 4, 5)
  * const chunk = Chunk.fromNonEmptyArrayUnsafe(nonEmptyArray)
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3, 4, 5]
+ * Chunk.toArray(chunk) // => [1, 2, 3, 4, 5]
  *
  * // The result is guaranteed to be non-empty
- * console.log(Chunk.isNonEmpty(chunk)) // true
+ * Chunk.isNonEmpty(chunk) // => true
  * ```
  *
  * @category unsafe
@@ -481,16 +470,16 @@ export declare const fromNonEmptyArrayUnsafe: <A>(self: NonEmptyReadonlyArray<A>
  *
  * **Example** (Accessing elements unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
  *
- * console.log(Chunk.getUnsafe(chunk, 1)) // "b"
- * console.log(Chunk.getUnsafe(chunk, 3)) // "d"
+ * Chunk.getUnsafe(chunk, 1) // => "b"
+ * Chunk.getUnsafe(chunk, 3) // => "d"
  *
  * // Use Chunk.get when the index may be out of bounds
- * console.log(Option.isNone(Chunk.get(chunk, 10))) // true
+ * Option.isNone(Chunk.get(chunk, 10)) // => true
  * ```
  *
  * @category unsafe
@@ -511,16 +500,16 @@ export declare const getUnsafe: {
      *
      * **Example** (Accessing elements unsafely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      *
-     * console.log(Chunk.getUnsafe(chunk, 1)) // "b"
-     * console.log(Chunk.getUnsafe(chunk, 3)) // "d"
+     * Chunk.getUnsafe(chunk, 1) // => "b"
+     * Chunk.getUnsafe(chunk, 3) // => "d"
      *
      * // Use Chunk.get when the index may be out of bounds
-     * console.log(Option.isNone(Chunk.get(chunk, 10))) // true
+     * Option.isNone(Chunk.get(chunk, 10)) // => true
      * ```
      *
      * @category unsafe
@@ -541,16 +530,16 @@ export declare const getUnsafe: {
      *
      * **Example** (Accessing elements unsafely)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      *
-     * console.log(Chunk.getUnsafe(chunk, 1)) // "b"
-     * console.log(Chunk.getUnsafe(chunk, 3)) // "d"
+     * Chunk.getUnsafe(chunk, 1) // => "b"
+     * Chunk.getUnsafe(chunk, 3) // => "d"
      *
      * // Use Chunk.get when the index may be out of bounds
-     * console.log(Option.isNone(Chunk.get(chunk, 10))) // true
+     * Option.isNone(Chunk.get(chunk, 10)) // => true
      * ```
      *
      * @category unsafe
@@ -568,17 +557,15 @@ export declare const getUnsafe: {
  *
  * **Example** (Appending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
- * const newChunk = Chunk.append(chunk, 4)
- * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.append(chunk, 4)) // => [1, 2, 3, 4]
  *
  * // Appending to empty chunk
  * const emptyChunk = Chunk.empty<number>()
- * const singleElement = Chunk.append(emptyChunk, 42)
- * console.log(Chunk.toArray(singleElement)) // [42]
+ * Chunk.toArray(Chunk.append(emptyChunk, 42)) // => [42]
  * ```
  *
  * @see {@link prepend} for adding one element before the existing elements
@@ -598,17 +585,15 @@ export declare const append: {
      *
      * **Example** (Appending an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
-     * const newChunk = Chunk.append(chunk, 4)
-     * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.append(chunk, 4)) // => [1, 2, 3, 4]
      *
      * // Appending to empty chunk
      * const emptyChunk = Chunk.empty<number>()
-     * const singleElement = Chunk.append(emptyChunk, 42)
-     * console.log(Chunk.toArray(singleElement)) // [42]
+     * Chunk.toArray(Chunk.append(emptyChunk, 42)) // => [42]
      * ```
      *
      * @see {@link prepend} for adding one element before the existing elements
@@ -628,17 +613,15 @@ export declare const append: {
      *
      * **Example** (Appending an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
-     * const newChunk = Chunk.append(chunk, 4)
-     * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.append(chunk, 4)) // => [1, 2, 3, 4]
      *
      * // Appending to empty chunk
      * const emptyChunk = Chunk.empty<number>()
-     * const singleElement = Chunk.append(emptyChunk, 42)
-     * console.log(Chunk.toArray(singleElement)) // [42]
+     * Chunk.toArray(Chunk.append(emptyChunk, 42)) // => [42]
      * ```
      *
      * @see {@link prepend} for adding one element before the existing elements
@@ -654,17 +637,15 @@ export declare const append: {
  *
  * **Example** (Prepending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(2, 3, 4)
- * const newChunk = Chunk.prepend(chunk, 1)
- * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.prepend(chunk, 1)) // => [1, 2, 3, 4]
  *
  * // Prepending to empty chunk
  * const emptyChunk = Chunk.empty<string>()
- * const singleElement = Chunk.prepend(emptyChunk, "first")
- * console.log(Chunk.toArray(singleElement)) // ["first"]
+ * Chunk.toArray(Chunk.prepend(emptyChunk, "first")) // => ["first"]
  * ```
  *
  * @category combining
@@ -676,17 +657,15 @@ export declare const prepend: {
      *
      * **Example** (Prepending an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(2, 3, 4)
-     * const newChunk = Chunk.prepend(chunk, 1)
-     * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.prepend(chunk, 1)) // => [1, 2, 3, 4]
      *
      * // Prepending to empty chunk
      * const emptyChunk = Chunk.empty<string>()
-     * const singleElement = Chunk.prepend(emptyChunk, "first")
-     * console.log(Chunk.toArray(singleElement)) // ["first"]
+     * Chunk.toArray(Chunk.prepend(emptyChunk, "first")) // => ["first"]
      * ```
      *
      * @category combining
@@ -698,17 +677,15 @@ export declare const prepend: {
      *
      * **Example** (Prepending an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(2, 3, 4)
-     * const newChunk = Chunk.prepend(chunk, 1)
-     * console.log(Chunk.toArray(newChunk)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.prepend(chunk, 1)) // => [1, 2, 3, 4]
      *
      * // Prepending to empty chunk
      * const emptyChunk = Chunk.empty<string>()
-     * const singleElement = Chunk.prepend(emptyChunk, "first")
-     * console.log(Chunk.toArray(singleElement)) // ["first"]
+     * Chunk.toArray(Chunk.prepend(emptyChunk, "first")) // => ["first"]
      * ```
      *
      * @category combining
@@ -721,15 +698,14 @@ export declare const prepend: {
  *
  * **Example** (Taking elements from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.take(chunk, 3)
- * console.log(Chunk.toArray(result)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.take(chunk, 3)) // => [1, 2, 3]
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const take: {
@@ -738,15 +714,14 @@ export declare const take: {
      *
      * **Example** (Taking elements from the start)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.take(chunk, 3)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.take(chunk, 3)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
@@ -755,15 +730,14 @@ export declare const take: {
      *
      * **Example** (Taking elements from the start)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.take(chunk, 3)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.take(chunk, 3)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
@@ -773,15 +747,14 @@ export declare const take: {
  *
  * **Example** (Dropping elements from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.drop(chunk, 2)
- * console.log(Chunk.toArray(result)) // [3, 4, 5]
+ * Chunk.toArray(Chunk.drop(chunk, 2)) // => [3, 4, 5]
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const drop: {
@@ -790,15 +763,14 @@ export declare const drop: {
      *
      * **Example** (Dropping elements from the start)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.drop(chunk, 2)
-     * console.log(Chunk.toArray(result)) // [3, 4, 5]
+     * Chunk.toArray(Chunk.drop(chunk, 2)) // => [3, 4, 5]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
@@ -807,15 +779,14 @@ export declare const drop: {
      *
      * **Example** (Dropping elements from the start)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.drop(chunk, 2)
-     * console.log(Chunk.toArray(result)) // [3, 4, 5]
+     * Chunk.toArray(Chunk.drop(chunk, 2)) // => [3, 4, 5]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
@@ -825,15 +796,14 @@ export declare const drop: {
  *
  * **Example** (Dropping elements from the end)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.dropRight(chunk, 2)
- * console.log(Chunk.toArray(result)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.dropRight(chunk, 2)) // => [1, 2, 3]
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const dropRight: {
@@ -842,15 +812,14 @@ export declare const dropRight: {
      *
      * **Example** (Dropping elements from the end)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.dropRight(chunk, 2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.dropRight(chunk, 2)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
@@ -859,15 +828,14 @@ export declare const dropRight: {
      *
      * **Example** (Dropping elements from the end)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.dropRight(chunk, 2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.dropRight(chunk, 2)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
@@ -877,15 +845,14 @@ export declare const dropRight: {
  *
  * **Example** (Dropping elements while a predicate matches)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.dropWhile(chunk, (n) => n < 3)
- * console.log(Chunk.toArray(result)) // [3, 4, 5]
+ * Chunk.toArray(Chunk.dropWhile(chunk, (n) => n < 3)) // => [3, 4, 5]
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const dropWhile: {
@@ -894,15 +861,14 @@ export declare const dropWhile: {
      *
      * **Example** (Dropping elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.dropWhile(chunk, (n) => n < 3)
-     * console.log(Chunk.toArray(result)) // [3, 4, 5]
+     * Chunk.toArray(Chunk.dropWhile(chunk, (n) => n < 3)) // => [3, 4, 5]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
@@ -911,15 +877,14 @@ export declare const dropWhile: {
      *
      * **Example** (Dropping elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.dropWhile(chunk, (n) => n < 3)
-     * console.log(Chunk.toArray(result)) // [3, 4, 5]
+     * Chunk.toArray(Chunk.dropWhile(chunk, (n) => n < 3)) // => [3, 4, 5]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
@@ -930,16 +895,13 @@ export declare const dropWhile: {
  *
  * **Example** (Prepending all elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const result = Chunk.make(1, 2).pipe(
+ * Chunk.make(1, 2).pipe(
  *   Chunk.prependAll(Chunk.make("a", "b")),
  *   Chunk.toArray
- * )
- *
- * console.log(result)
- * // [ "a", "b", 1, 2 ]
+ * ) // => ["a", "b", 1, 2]
  * ```
  *
  * @category combining
@@ -952,16 +914,13 @@ export declare const prependAll: {
      *
      * **Example** (Prepending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.prependAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ "a", "b", 1, 2 ]
+     * ) // => ["a", "b", 1, 2]
      * ```
      *
      * @category combining
@@ -974,16 +933,13 @@ export declare const prependAll: {
      *
      * **Example** (Prepending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.prependAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ "a", "b", 1, 2 ]
+     * ) // => ["a", "b", 1, 2]
      * ```
      *
      * @category combining
@@ -996,16 +952,13 @@ export declare const prependAll: {
      *
      * **Example** (Prepending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.prependAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ "a", "b", 1, 2 ]
+     * ) // => ["a", "b", 1, 2]
      * ```
      *
      * @category combining
@@ -1018,16 +971,13 @@ export declare const prependAll: {
      *
      * **Example** (Prepending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.prependAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ "a", "b", 1, 2 ]
+     * ) // => ["a", "b", 1, 2]
      * ```
      *
      * @category combining
@@ -1046,16 +996,13 @@ export declare const prependAll: {
  *
  * **Example** (Appending all elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const result = Chunk.make(1, 2).pipe(
+ * Chunk.make(1, 2).pipe(
  *   Chunk.appendAll(Chunk.make("a", "b")),
  *   Chunk.toArray
- * )
- *
- * console.log(result)
- * // [ 1, 2, "a", "b" ]
+ * ) // => [1, 2, "a", "b"]
  * ```
  *
  * @see {@link prependAll} for concatenating chunks in the opposite order
@@ -1076,16 +1023,13 @@ export declare const appendAll: {
      *
      * **Example** (Appending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.appendAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ 1, 2, "a", "b" ]
+     * ) // => [1, 2, "a", "b"]
      * ```
      *
      * @see {@link prependAll} for concatenating chunks in the opposite order
@@ -1106,16 +1050,13 @@ export declare const appendAll: {
      *
      * **Example** (Appending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.appendAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ 1, 2, "a", "b" ]
+     * ) // => [1, 2, "a", "b"]
      * ```
      *
      * @see {@link prependAll} for concatenating chunks in the opposite order
@@ -1136,16 +1077,13 @@ export declare const appendAll: {
      *
      * **Example** (Appending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.appendAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ 1, 2, "a", "b" ]
+     * ) // => [1, 2, "a", "b"]
      * ```
      *
      * @see {@link prependAll} for concatenating chunks in the opposite order
@@ -1166,16 +1104,13 @@ export declare const appendAll: {
      *
      * **Example** (Appending all elements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.make(1, 2).pipe(
+     * Chunk.make(1, 2).pipe(
      *   Chunk.appendAll(Chunk.make("a", "b")),
      *   Chunk.toArray
-     * )
-     *
-     * console.log(result)
-     * // [ 1, 2, "a", "b" ]
+     * ) // => [1, 2, "a", "b"]
      * ```
      *
      * @see {@link prependAll} for concatenating chunks in the opposite order
@@ -1191,7 +1126,7 @@ export declare const appendAll: {
  *
  * **Example** (Filtering and mapping values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
  * const chunk = Chunk.make("1", "2", "hello", "3", "world")
@@ -1199,14 +1134,14 @@ export declare const appendAll: {
  *   const num = parseInt(str)
  *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
- * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
+ * Chunk.toArray(numbers) // => [1, 2, 3]
  *
  * // With index parameter
  * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
  *   const num = parseInt(str)
  *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
  * })
- * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
+ * Chunk.toArray(evenIndexNumbers) // => [1]
  * ```
  *
  * @category filtering
@@ -1218,7 +1153,7 @@ export declare const filterMap: {
      *
      * **Example** (Filtering and mapping values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "world")
@@ -1226,14 +1161,14 @@ export declare const filterMap: {
      *   const num = parseInt(str)
      *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
-     * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
+     * Chunk.toArray(numbers) // => [1, 2, 3]
      *
      * // With index parameter
      * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
      *   const num = parseInt(str)
      *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
      * })
-     * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
+     * Chunk.toArray(evenIndexNumbers) // => [1]
      * ```
      *
      * @category filtering
@@ -1245,7 +1180,7 @@ export declare const filterMap: {
      *
      * **Example** (Filtering and mapping values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "world")
@@ -1253,14 +1188,14 @@ export declare const filterMap: {
      *   const num = parseInt(str)
      *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
-     * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
+     * Chunk.toArray(numbers) // => [1, 2, 3]
      *
      * // With index parameter
      * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
      *   const num = parseInt(str)
      *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
      * })
-     * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
+     * Chunk.toArray(evenIndexNumbers) // => [1]
      * ```
      *
      * @category filtering
@@ -1273,17 +1208,17 @@ export declare const filterMap: {
  *
  * **Example** (Filtering values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
  * const evenNumbers = Chunk.filter(chunk, (n) => n % 2 === 0)
- * console.log(Chunk.toArray(evenNumbers)) // [2, 4, 6]
+ * Chunk.toArray(evenNumbers) // => [2, 4, 6]
  *
  * // With refinement
  * const mixed = Chunk.make("hello", 42, "world", 100)
  * const numbers = Chunk.filter(mixed, (x): x is number => typeof x === "number")
- * console.log(Chunk.toArray(numbers)) // [42, 100]
+ * Chunk.toArray(numbers) // => [42, 100]
  * ```
  *
  * @category filtering
@@ -1295,17 +1230,17 @@ export declare const filter: {
      *
      * **Example** (Filtering values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const evenNumbers = Chunk.filter(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(evenNumbers)) // [2, 4, 6]
+     * Chunk.toArray(evenNumbers) // => [2, 4, 6]
      *
      * // With refinement
      * const mixed = Chunk.make("hello", 42, "world", 100)
      * const numbers = Chunk.filter(mixed, (x): x is number => typeof x === "number")
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
+     * Chunk.toArray(numbers) // => [42, 100]
      * ```
      *
      * @category filtering
@@ -1317,17 +1252,17 @@ export declare const filter: {
      *
      * **Example** (Filtering values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const evenNumbers = Chunk.filter(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(evenNumbers)) // [2, 4, 6]
+     * Chunk.toArray(evenNumbers) // => [2, 4, 6]
      *
      * // With refinement
      * const mixed = Chunk.make("hello", 42, "world", 100)
      * const numbers = Chunk.filter(mixed, (x): x is number => typeof x === "number")
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
+     * Chunk.toArray(numbers) // => [42, 100]
      * ```
      *
      * @category filtering
@@ -1339,17 +1274,17 @@ export declare const filter: {
      *
      * **Example** (Filtering values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const evenNumbers = Chunk.filter(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(evenNumbers)) // [2, 4, 6]
+     * Chunk.toArray(evenNumbers) // => [2, 4, 6]
      *
      * // With refinement
      * const mixed = Chunk.make("hello", 42, "world", 100)
      * const numbers = Chunk.filter(mixed, (x): x is number => typeof x === "number")
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
+     * Chunk.toArray(numbers) // => [42, 100]
      * ```
      *
      * @category filtering
@@ -1361,17 +1296,17 @@ export declare const filter: {
      *
      * **Example** (Filtering values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const evenNumbers = Chunk.filter(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(evenNumbers)) // [2, 4, 6]
+     * Chunk.toArray(evenNumbers) // => [2, 4, 6]
      *
      * // With refinement
      * const mixed = Chunk.make("hello", 42, "world", 100)
      * const numbers = Chunk.filter(mixed, (x): x is number => typeof x === "number")
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
+     * Chunk.toArray(numbers) // => [42, 100]
      * ```
      *
      * @category filtering
@@ -1384,23 +1319,19 @@ export declare const filter: {
  *
  * **Example** (Filtering and mapping while values match)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
  * const chunk = Chunk.make("1", "2", "hello", "3", "4")
- * const result = Chunk.filterMapWhile(chunk, (s) => {
- *   const num = parseInt(s)
- *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
- * })
- * console.log(Chunk.toArray(result)) // [1, 2]
- * // Stops at "hello" and doesn't process "3", "4"
- *
- * // Compare with regular filterMap
- * const allNumbers = Chunk.filterMap(chunk, (s) => {
- *   const num = parseInt(s)
- *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
- * })
- * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.filterMapWhile(chunk, (s) => {
+ *   const n = Number(s)
+ *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+ * })) // => [1, 2]
+ *
+ * Chunk.toArray(Chunk.filterMap(chunk, (s) => {
+ *   const n = Number(s)
+ *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+ * })) // => [1, 2, 3, 4]
  * ```
  *
  * @category filtering
@@ -1412,23 +1343,19 @@ export declare const filterMapWhile: {
      *
      * **Example** (Filtering and mapping while values match)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "4")
-     * const result = Chunk.filterMapWhile(chunk, (s) => {
-     *   const num = parseInt(s)
-     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
-     * })
-     * console.log(Chunk.toArray(result)) // [1, 2]
-     * // Stops at "hello" and doesn't process "3", "4"
-     *
-     * // Compare with regular filterMap
-     * const allNumbers = Chunk.filterMap(chunk, (s) => {
-     *   const num = parseInt(s)
-     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
-     * })
-     * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.filterMapWhile(chunk, (s) => {
+     *   const n = Number(s)
+     *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+     * })) // => [1, 2]
+     *
+     * Chunk.toArray(Chunk.filterMap(chunk, (s) => {
+     *   const n = Number(s)
+     *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+     * })) // => [1, 2, 3, 4]
      * ```
      *
      * @category filtering
@@ -1440,23 +1367,19 @@ export declare const filterMapWhile: {
      *
      * **Example** (Filtering and mapping while values match)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "4")
-     * const result = Chunk.filterMapWhile(chunk, (s) => {
-     *   const num = parseInt(s)
-     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
-     * })
-     * console.log(Chunk.toArray(result)) // [1, 2]
-     * // Stops at "hello" and doesn't process "3", "4"
-     *
-     * // Compare with regular filterMap
-     * const allNumbers = Chunk.filterMap(chunk, (s) => {
-     *   const num = parseInt(s)
-     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
-     * })
-     * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
+     * Chunk.toArray(Chunk.filterMapWhile(chunk, (s) => {
+     *   const n = Number(s)
+     *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+     * })) // => [1, 2]
+     *
+     * Chunk.toArray(Chunk.filterMap(chunk, (s) => {
+     *   const n = Number(s)
+     *   return Number.isNaN(n) ? Result.failVoid : Result.succeed(n)
+     * })) // => [1, 2, 3, 4]
      * ```
      *
      * @category filtering
@@ -1469,12 +1392,11 @@ export declare const filterMapWhile: {
  *
  * **Example** (Compacting optional values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(Option.some(1), Option.none(), Option.some(3))
- * const result = Chunk.compact(chunk)
- * console.log(Chunk.toArray(result)) // [1, 3]
+ * Chunk.toArray(Chunk.compact(chunk)) // => [1, 3]
  * ```
  *
  * @category filtering
@@ -1486,12 +1408,12 @@ export declare const compact: <A>(self: Chunk<Option<A>>) => Chunk<A>;
  *
  * **Example** (Flat mapping chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3)
  * const duplicated = Chunk.flatMap(chunk, (n) => Chunk.make(n, n))
- * console.log(Chunk.toArray(duplicated)) // [1, 1, 2, 2, 3, 3]
+ * Chunk.toArray(duplicated) // => [1, 1, 2, 2, 3, 3]
  *
  * // Flattening nested arrays
  * const words = Chunk.make("hello", "world")
@@ -1499,11 +1421,11 @@ export declare const compact: <A>(self: Chunk<Option<A>>) => Chunk<A>;
  *   words,
  *   (word) => Chunk.fromIterable(word.split(""))
  * )
- * console.log(Chunk.toArray(letters)) // ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]
+ * Chunk.toArray(letters).join("") // => "helloworld"
  *
  * // With index parameter
  * const indexed = Chunk.flatMap(chunk, (n, i) => Chunk.make(n + i))
- * console.log(Chunk.toArray(indexed)) // [1, 3, 5]
+ * Chunk.toArray(indexed) // => [1, 3, 5]
  * ```
  *
  * @category sequencing
@@ -1515,12 +1437,12 @@ export declare const flatMap: {
      *
      * **Example** (Flat mapping chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
      * const duplicated = Chunk.flatMap(chunk, (n) => Chunk.make(n, n))
-     * console.log(Chunk.toArray(duplicated)) // [1, 1, 2, 2, 3, 3]
+     * Chunk.toArray(duplicated) // => [1, 1, 2, 2, 3, 3]
      *
      * // Flattening nested arrays
      * const words = Chunk.make("hello", "world")
@@ -1528,11 +1450,11 @@ export declare const flatMap: {
      *   words,
      *   (word) => Chunk.fromIterable(word.split(""))
      * )
-     * console.log(Chunk.toArray(letters)) // ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]
+     * Chunk.toArray(letters).join("") // => "helloworld"
      *
      * // With index parameter
      * const indexed = Chunk.flatMap(chunk, (n, i) => Chunk.make(n + i))
-     * console.log(Chunk.toArray(indexed)) // [1, 3, 5]
+     * Chunk.toArray(indexed) // => [1, 3, 5]
      * ```
      *
      * @category sequencing
@@ -1544,12 +1466,12 @@ export declare const flatMap: {
      *
      * **Example** (Flat mapping chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
      * const duplicated = Chunk.flatMap(chunk, (n) => Chunk.make(n, n))
-     * console.log(Chunk.toArray(duplicated)) // [1, 1, 2, 2, 3, 3]
+     * Chunk.toArray(duplicated) // => [1, 1, 2, 2, 3, 3]
      *
      * // Flattening nested arrays
      * const words = Chunk.make("hello", "world")
@@ -1557,11 +1479,11 @@ export declare const flatMap: {
      *   words,
      *   (word) => Chunk.fromIterable(word.split(""))
      * )
-     * console.log(Chunk.toArray(letters)) // ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]
+     * Chunk.toArray(letters).join("") // => "helloworld"
      *
      * // With index parameter
      * const indexed = Chunk.flatMap(chunk, (n, i) => Chunk.make(n + i))
-     * console.log(Chunk.toArray(indexed)) // [1, 3, 5]
+     * Chunk.toArray(indexed) // => [1, 3, 5]
      * ```
      *
      * @category sequencing
@@ -1573,12 +1495,12 @@ export declare const flatMap: {
      *
      * **Example** (Flat mapping chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3)
      * const duplicated = Chunk.flatMap(chunk, (n) => Chunk.make(n, n))
-     * console.log(Chunk.toArray(duplicated)) // [1, 1, 2, 2, 3, 3]
+     * Chunk.toArray(duplicated) // => [1, 1, 2, 2, 3, 3]
      *
      * // Flattening nested arrays
      * const words = Chunk.make("hello", "world")
@@ -1586,11 +1508,11 @@ export declare const flatMap: {
      *   words,
      *   (word) => Chunk.fromIterable(word.split(""))
      * )
-     * console.log(Chunk.toArray(letters)) // ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]
+     * Chunk.toArray(letters).join("") // => "helloworld"
      *
      * // With index parameter
      * const indexed = Chunk.flatMap(chunk, (n, i) => Chunk.make(n + i))
-     * console.log(Chunk.toArray(indexed)) // [1, 3, 5]
+     * Chunk.toArray(indexed) // => [1, 3, 5]
      * ```
      *
      * @category sequencing
@@ -1610,26 +1532,19 @@ export declare const flatMap: {
  *
  * **Example** (Iterating over chunk values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
  *
- * // Log each element
- * Chunk.forEach(chunk, (n) => console.log(`Value: ${n}`))
- * // Output:
- * // Value: 1
- * // Value: 2
- * // Value: 3
- * // Value: 4
+ * const values: Array<string> = []
+ * Chunk.forEach(chunk, (n) => values.push(`Value: ${n}`))
+ * values // => ["Value: 1", "Value: 2", "Value: 3", "Value: 4"]
  *
  * // With index parameter
- * Chunk.forEach(chunk, (n, i) => console.log(`Index ${i}: ${n}`))
- * // Output:
- * // Index 0: 1
- * // Index 1: 2
- * // Index 2: 3
- * // Index 3: 4
+ * const indexed: Array<string> = []
+ * Chunk.forEach(chunk, (n, i) => indexed.push(`Index ${i}: ${n}`))
+ * indexed // => ["Index 0: 1", "Index 1: 2", "Index 2: 3", "Index 3: 4"]
  * ```
  *
  * @category combinators
@@ -1648,26 +1563,19 @@ export declare const forEach: {
      *
      * **Example** (Iterating over chunk values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
      *
-     * // Log each element
-     * Chunk.forEach(chunk, (n) => console.log(`Value: ${n}`))
-     * // Output:
-     * // Value: 1
-     * // Value: 2
-     * // Value: 3
-     * // Value: 4
+     * const values: Array<string> = []
+     * Chunk.forEach(chunk, (n) => values.push(`Value: ${n}`))
+     * values // => ["Value: 1", "Value: 2", "Value: 3", "Value: 4"]
      *
      * // With index parameter
-     * Chunk.forEach(chunk, (n, i) => console.log(`Index ${i}: ${n}`))
-     * // Output:
-     * // Index 0: 1
-     * // Index 1: 2
-     * // Index 2: 3
-     * // Index 3: 4
+     * const indexed: Array<string> = []
+     * Chunk.forEach(chunk, (n, i) => indexed.push(`Index ${i}: ${n}`))
+     * indexed // => ["Index 0: 1", "Index 1: 2", "Index 2: 3", "Index 3: 4"]
      * ```
      *
      * @category combinators
@@ -1686,26 +1594,19 @@ export declare const forEach: {
      *
      * **Example** (Iterating over chunk values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
      *
-     * // Log each element
-     * Chunk.forEach(chunk, (n) => console.log(`Value: ${n}`))
-     * // Output:
-     * // Value: 1
-     * // Value: 2
-     * // Value: 3
-     * // Value: 4
+     * const values: Array<string> = []
+     * Chunk.forEach(chunk, (n) => values.push(`Value: ${n}`))
+     * values // => ["Value: 1", "Value: 2", "Value: 3", "Value: 4"]
      *
      * // With index parameter
-     * Chunk.forEach(chunk, (n, i) => console.log(`Index ${i}: ${n}`))
-     * // Output:
-     * // Index 0: 1
-     * // Index 1: 2
-     * // Index 2: 3
-     * // Index 3: 4
+     * const indexed: Array<string> = []
+     * Chunk.forEach(chunk, (n, i) => indexed.push(`Index ${i}: ${n}`))
+     * indexed // => ["Index 0: 1", "Index 1: 2", "Index 2: 3", "Index 3: 4"]
      * ```
      *
      * @category combinators
@@ -1718,7 +1619,7 @@ export declare const forEach: {
  *
  * **Example** (Flattening nested chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nested = Chunk.make(
@@ -1726,8 +1627,7 @@ export declare const forEach: {
  *   Chunk.make(3, 4, 5),
  *   Chunk.make(6)
  * )
- * const flattened = Chunk.flatten(nested)
- * console.log(Chunk.toArray(flattened)) // [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(Chunk.flatten(nested)) // => [1, 2, 3, 4, 5, 6]
  *
  * // With empty chunks
  * const withEmpty = Chunk.make(
@@ -1735,7 +1635,7 @@ export declare const forEach: {
  *   Chunk.empty<number>(),
  *   Chunk.make(3, 4)
  * )
- * console.log(Chunk.toArray(Chunk.flatten(withEmpty))) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.flatten(withEmpty)) // => [1, 2, 3, 4]
  * ```
  *
  * @category sequencing
@@ -1761,25 +1661,23 @@ export declare const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Fl
  *
  * **Example** (Splitting into fixed-size chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
  * const chunked = Chunk.chunksOf(chunk, 3)
  *
- * console.log(Chunk.toArray(chunked).map(Chunk.toArray))
- * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+ * Chunk.toArray(chunked).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  *
  * // When length is not evenly divisible
  * const chunk2 = Chunk.make(1, 2, 3, 4, 5)
  * const chunked2 = Chunk.chunksOf(chunk2, 2)
- * console.log(Chunk.toArray(chunked2).map(Chunk.toArray))
- * // [[1, 2], [3, 4], [5]]
+ * Chunk.toArray(chunked2).map(Chunk.toArray) // => [[1, 2], [3, 4], [5]]
  * ```
  *
  * @see {@link split} for splitting into a target number of chunks instead of a fixed chunk size
  *
- * @category elements
+ * @category splitting
  * @since 2.0.0
  */
 export declare const chunksOf: {
@@ -1802,25 +1700,23 @@ export declare const chunksOf: {
      *
      * **Example** (Splitting into fixed-size chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
      * const chunked = Chunk.chunksOf(chunk, 3)
      *
-     * console.log(Chunk.toArray(chunked).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+     * Chunk.toArray(chunked).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
      *
      * // When length is not evenly divisible
      * const chunk2 = Chunk.make(1, 2, 3, 4, 5)
      * const chunked2 = Chunk.chunksOf(chunk2, 2)
-     * console.log(Chunk.toArray(chunked2).map(Chunk.toArray))
-     * // [[1, 2], [3, 4], [5]]
+     * Chunk.toArray(chunked2).map(Chunk.toArray) // => [[1, 2], [3, 4], [5]]
      * ```
      *
      * @see {@link split} for splitting into a target number of chunks instead of a fixed chunk size
      *
-     * @category elements
+     * @category splitting
      * @since 2.0.0
      */
     (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
@@ -1843,25 +1739,23 @@ export declare const chunksOf: {
      *
      * **Example** (Splitting into fixed-size chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
      * const chunked = Chunk.chunksOf(chunk, 3)
      *
-     * console.log(Chunk.toArray(chunked).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+     * Chunk.toArray(chunked).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
      *
      * // When length is not evenly divisible
      * const chunk2 = Chunk.make(1, 2, 3, 4, 5)
      * const chunked2 = Chunk.chunksOf(chunk2, 2)
-     * console.log(Chunk.toArray(chunked2).map(Chunk.toArray))
-     * // [[1, 2], [3, 4], [5]]
+     * Chunk.toArray(chunked2).map(Chunk.toArray) // => [[1, 2], [3, 4], [5]]
      * ```
      *
      * @see {@link split} for splitting into a target number of chunks instead of a fixed chunk size
      *
-     * @category elements
+     * @category splitting
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
@@ -1875,26 +1769,25 @@ export declare const chunksOf: {
  *
  * **Example** (Intersecting chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk1 = Chunk.make(1, 2, 3, 4)
  * const chunk2 = Chunk.make(3, 4, 5, 6)
- * const result = Chunk.intersection(chunk1, chunk2)
- * console.log(Chunk.toArray(result)) // [3, 4]
+ * Chunk.toArray(Chunk.intersection(chunk1, chunk2)) // => [3, 4]
  *
  * // With strings
  * const words1 = Chunk.make("hello", "world", "foo")
  * const words2 = Chunk.make("world", "bar", "foo")
- * console.log(Chunk.toArray(Chunk.intersection(words1, words2))) // ["world", "foo"]
+ * Chunk.toArray(Chunk.intersection(words1, words2)) // => ["world", "foo"]
  *
  * // No intersection
  * const chunk3 = Chunk.make(1, 2)
  * const chunk4 = Chunk.make(3, 4)
- * console.log(Chunk.toArray(Chunk.intersection(chunk3, chunk4))) // []
+ * Chunk.toArray(Chunk.intersection(chunk3, chunk4)) // => []
  * ```
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export declare const intersection: {
@@ -1907,26 +1800,25 @@ export declare const intersection: {
      *
      * **Example** (Intersecting chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3, 4)
      * const chunk2 = Chunk.make(3, 4, 5, 6)
-     * const result = Chunk.intersection(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [3, 4]
+     * Chunk.toArray(Chunk.intersection(chunk1, chunk2)) // => [3, 4]
      *
      * // With strings
      * const words1 = Chunk.make("hello", "world", "foo")
      * const words2 = Chunk.make("world", "bar", "foo")
-     * console.log(Chunk.toArray(Chunk.intersection(words1, words2))) // ["world", "foo"]
+     * Chunk.toArray(Chunk.intersection(words1, words2)) // => ["world", "foo"]
      *
      * // No intersection
      * const chunk3 = Chunk.make(1, 2)
      * const chunk4 = Chunk.make(3, 4)
-     * console.log(Chunk.toArray(Chunk.intersection(chunk3, chunk4))) // []
+     * Chunk.toArray(Chunk.intersection(chunk3, chunk4)) // => []
      * ```
      *
-     * @category elements
+     * @category set operations
      * @since 2.0.0
      */
     <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A & B>;
@@ -1939,26 +1831,25 @@ export declare const intersection: {
      *
      * **Example** (Intersecting chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3, 4)
      * const chunk2 = Chunk.make(3, 4, 5, 6)
-     * const result = Chunk.intersection(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [3, 4]
+     * Chunk.toArray(Chunk.intersection(chunk1, chunk2)) // => [3, 4]
      *
      * // With strings
      * const words1 = Chunk.make("hello", "world", "foo")
      * const words2 = Chunk.make("world", "bar", "foo")
-     * console.log(Chunk.toArray(Chunk.intersection(words1, words2))) // ["world", "foo"]
+     * Chunk.toArray(Chunk.intersection(words1, words2)) // => ["world", "foo"]
      *
      * // No intersection
      * const chunk3 = Chunk.make(1, 2)
      * const chunk4 = Chunk.make(3, 4)
-     * console.log(Chunk.toArray(Chunk.intersection(chunk3, chunk4))) // []
+     * Chunk.toArray(Chunk.intersection(chunk3, chunk4)) // => []
      * ```
      *
-     * @category elements
+     * @category set operations
      * @since 2.0.0
      */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A & B>;
@@ -1968,14 +1859,14 @@ export declare const intersection: {
  *
  * **Example** (Checking for empty chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * console.log(Chunk.isEmpty(Chunk.empty())) // true
- * console.log(Chunk.isEmpty(Chunk.make(1, 2, 3))) // false
+ * Chunk.isEmpty(Chunk.empty()) // => true
+ * Chunk.isEmpty(Chunk.make(1, 2, 3)) // => false
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export declare const isEmpty: <A>(self: Chunk<A>) => boolean;
@@ -1984,14 +1875,14 @@ export declare const isEmpty: <A>(self: Chunk<A>) => boolean;
  *
  * **Example** (Checking for non-empty chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * console.log(Chunk.isNonEmpty(Chunk.empty())) // false
- * console.log(Chunk.isNonEmpty(Chunk.make(1, 2, 3))) // true
+ * Chunk.isNonEmpty(Chunk.empty()) // => false
+ * Chunk.isNonEmpty(Chunk.make(1, 2, 3)) // => true
  * ```
  *
- * @category elements
+ * @category guards
  * @since 2.0.0
  */
 export declare const isNonEmpty: <A>(self: Chunk<A>) => self is NonEmptyChunk<A>;
@@ -2000,14 +1891,14 @@ export declare const isNonEmpty: <A>(self: Chunk<A>) => self is NonEmptyChunk<A>
  *
  * **Example** (Getting the first element)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
- * console.log(Chunk.head(Chunk.empty())) // { _tag: "None" }
- * console.log(Chunk.head(Chunk.make(1, 2, 3))) // { _tag: "Some", value: 1 }
+ * Chunk.head(Chunk.empty()) // => Option.none()
+ * Chunk.head(Chunk.make(1, 2, 3)) // => Option.some(1)
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const head: <A>(self: Chunk<A>) => Option<A>;
@@ -2025,17 +1916,17 @@ export declare const head: <A>(self: Chunk<A>) => Option<A>;
  *
  * **Example** (Getting the first element unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.headUnsafe(chunk)) // 1
+ * Chunk.headUnsafe(chunk) // => 1
  *
  * const singleElement = Chunk.make("hello")
- * console.log(Chunk.headUnsafe(singleElement)) // "hello"
+ * Chunk.headUnsafe(singleElement) // => "hello"
  *
  * // Use Chunk.head when the chunk may be empty
- * console.log(Option.isNone(Chunk.head(Chunk.empty()))) // true
+ * Option.isNone(Chunk.head(Chunk.empty())) // => true
  * ```
  *
  * @category unsafe
@@ -2047,20 +1938,20 @@ export declare const headUnsafe: <A>(self: Chunk<A>) => A;
  *
  * **Example** (Getting the first element of a non-empty chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nonEmptyChunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.headNonEmpty(nonEmptyChunk)) // 1
+ * Chunk.headNonEmpty(nonEmptyChunk) // => 1
  *
  * const singleElement = Chunk.make("hello")
- * console.log(Chunk.headNonEmpty(singleElement)) // "hello"
+ * Chunk.headNonEmpty(singleElement) // => "hello"
  *
  * // Type safety: this function only accepts NonEmptyChunk
  * // Chunk.headNonEmpty(Chunk.empty()) // TypeScript error
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A;
@@ -2069,14 +1960,14 @@ export declare const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A;
  *
  * **Example** (Getting the last element)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
- * console.log(Chunk.last(Chunk.empty())) // { _tag: "None" }
- * console.log(Chunk.last(Chunk.make(1, 2, 3))) // { _tag: "Some", value: 3 }
+ * Chunk.last(Chunk.empty()) // => Option.none()
+ * Chunk.last(Chunk.make(1, 2, 3)) // => Option.some(3)
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const last: <A>(self: Chunk<A>) => Option<A>;
@@ -2094,17 +1985,17 @@ export declare const last: <A>(self: Chunk<A>) => Option<A>;
  *
  * **Example** (Getting the last element unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.lastUnsafe(chunk)) // 4
+ * Chunk.lastUnsafe(chunk) // => 4
  *
  * const singleElement = Chunk.make("hello")
- * console.log(Chunk.lastUnsafe(singleElement)) // "hello"
+ * Chunk.lastUnsafe(singleElement) // => "hello"
  *
  * // Use Chunk.last when the chunk may be empty
- * console.log(Option.isNone(Chunk.last(Chunk.empty()))) // true
+ * Option.isNone(Chunk.last(Chunk.empty())) // => true
  * ```
  *
  * @category unsafe
@@ -2116,20 +2007,20 @@ export declare const lastUnsafe: <A>(self: Chunk<A>) => A;
  *
  * **Example** (Getting the last element of a non-empty chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nonEmptyChunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.lastNonEmpty(nonEmptyChunk)) // 4
+ * Chunk.lastNonEmpty(nonEmptyChunk) // => 4
  *
  * const singleElement = Chunk.make("hello")
- * console.log(Chunk.lastNonEmpty(singleElement)) // "hello"
+ * Chunk.lastNonEmpty(singleElement) // => "hello"
  *
  * // Type safety: this function only accepts NonEmptyChunk
  * // Chunk.lastNonEmpty(Chunk.empty()) // TypeScript error
  * ```
  *
- * @category elements
+ * @category getters
  * @since 3.4.0
  */
 export declare const lastNonEmpty: <A>(self: NonEmptyChunk<A>) => A;
@@ -2138,7 +2029,7 @@ export declare const lastNonEmpty: <A>(self: NonEmptyChunk<A>) => A;
  *
  * **Example** (Working with Chunk utility types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Chunk } from "effect"
  *
  * // Extract the element type from a Chunk
@@ -2158,7 +2049,7 @@ export declare namespace Chunk {
      *
      * **Example** (Inferring element types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Chunk } from "effect"
      *
      * declare const numberChunk: Chunk.Chunk<number>
@@ -2168,7 +2059,7 @@ export declare namespace Chunk {
      * type StringType = Chunk.Chunk.Infer<typeof stringChunk> // string
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 2.0.0
      */
     type Infer<S extends Chunk<any>> = S extends Chunk<infer A> ? A : never;
@@ -2177,7 +2068,7 @@ export declare namespace Chunk {
      *
      * **Example** (Preserving non-emptiness)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Chunk } from "effect"
      *
      * declare const regularChunk: Chunk.Chunk<number>
@@ -2187,7 +2078,7 @@ export declare namespace Chunk {
      * type WithString2 = Chunk.Chunk.With<typeof nonEmptyChunk, string> // Chunk.NonEmptyChunk<string>
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 2.0.0
      */
     type With<S extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>;
@@ -2196,7 +2087,7 @@ export declare namespace Chunk {
      *
      * **Example** (Preserving non-emptiness from either input)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Chunk } from "effect"
      *
      * declare const emptyChunk: Chunk.Chunk<number>
@@ -2219,7 +2110,7 @@ export declare namespace Chunk {
      * > // Chunk.NonEmptyChunk<string>
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 2.0.0
      */
     type OrNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>;
@@ -2228,7 +2119,7 @@ export declare namespace Chunk {
      *
      * **Example** (Requiring non-emptiness from both inputs)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Chunk } from "effect"
      *
      * declare const emptyChunk: Chunk.Chunk<number>
@@ -2251,7 +2142,7 @@ export declare namespace Chunk {
      * > // Chunk.NonEmptyChunk<string>
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 2.0.0
      */
     type AndNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? T extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A> : Chunk<A>;
@@ -2260,7 +2151,7 @@ export declare namespace Chunk {
      *
      * **Example** (Flattening nested chunk types)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Chunk } from "effect"
      *
      * declare const nestedChunk: Chunk.Chunk<Chunk.Chunk<number>>
@@ -2270,7 +2161,7 @@ export declare namespace Chunk {
      * type Flattened2 = Chunk.Chunk.Flatten<typeof nestedNonEmpty> // Chunk.NonEmptyChunk<string>
      * ```
      *
-     * @category types
+     * @category utility types
      * @since 2.0.0
      */
     type Flatten<T extends Chunk<Chunk<any>>> = T extends NonEmptyChunk<NonEmptyChunk<infer A>> ? NonEmptyChunk<A> : T extends Chunk<Chunk<infer A>> ? Chunk<A> : never;
@@ -2281,12 +2172,10 @@ export declare namespace Chunk {
  *
  * **Example** (Mapping values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)
- *
- * console.log(Chunk.toArray(result)) // [2, 3]
+ * Chunk.toArray(Chunk.map(Chunk.make(1, 2), (n) => n + 1)) // => [2, 3]
  * ```
  *
  * @category mapping
@@ -2299,12 +2188,10 @@ export declare const map: {
      *
      * **Example** (Mapping values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)
-     *
-     * console.log(Chunk.toArray(result)) // [2, 3]
+     * Chunk.toArray(Chunk.map(Chunk.make(1, 2), (n) => n + 1)) // => [2, 3]
      * ```
      *
      * @category mapping
@@ -2317,12 +2204,10 @@ export declare const map: {
      *
      * **Example** (Mapping values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)
-     *
-     * console.log(Chunk.toArray(result)) // [2, 3]
+     * Chunk.toArray(Chunk.map(Chunk.make(1, 2), (n) => n + 1)) // => [2, 3]
      * ```
      *
      * @category mapping
@@ -2335,12 +2220,10 @@ export declare const map: {
      *
      * **Example** (Mapping values)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const result = Chunk.map(Chunk.make(1, 2), (n) => n + 1)
-     *
-     * console.log(Chunk.toArray(result)) // [2, 3]
+     * Chunk.toArray(Chunk.map(Chunk.make(1, 2), (n) => n + 1)) // => [2, 3]
      * ```
      *
      * @category mapping
@@ -2353,7 +2236,7 @@ export declare const map: {
  *
  * **Example** (Mapping with accumulated state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
@@ -2362,8 +2245,8 @@ export declare const map: {
  *   state + current // output running sum
  * ])
  *
- * console.log(finalState) // 15 (final accumulated sum)
- * console.log(Chunk.toArray(mapped)) // [1, 3, 6, 10, 15] (running sums)
+ * finalState // => 15
+ * Chunk.toArray(mapped) // => [1, 3, 6, 10, 15]
  *
  * // Building a string with indices
  * const words = Chunk.make("hello", "world", "effect")
@@ -2371,8 +2254,8 @@ export declare const map: {
  *   index + 1,
  *   `${index}: ${word}`
  * ])
- * console.log(count) // 3
- * console.log(Chunk.toArray(indexed)) // ["0: hello", "1: world", "2: effect"]
+ * count // => 3
+ * Chunk.toArray(indexed) // => ["0: hello", "1: world", "2: effect"]
  * ```
  *
  * @category folding
@@ -2384,7 +2267,7 @@ export declare const mapAccum: {
      *
      * **Example** (Mapping with accumulated state)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
@@ -2393,8 +2276,8 @@ export declare const mapAccum: {
      *   state + current // output running sum
      * ])
      *
-     * console.log(finalState) // 15 (final accumulated sum)
-     * console.log(Chunk.toArray(mapped)) // [1, 3, 6, 10, 15] (running sums)
+     * finalState // => 15
+     * Chunk.toArray(mapped) // => [1, 3, 6, 10, 15]
      *
      * // Building a string with indices
      * const words = Chunk.make("hello", "world", "effect")
@@ -2402,8 +2285,8 @@ export declare const mapAccum: {
      *   index + 1,
      *   `${index}: ${word}`
      * ])
-     * console.log(count) // 3
-     * console.log(Chunk.toArray(indexed)) // ["0: hello", "1: world", "2: effect"]
+     * count // => 3
+     * Chunk.toArray(indexed) // => ["0: hello", "1: world", "2: effect"]
      * ```
      *
      * @category folding
@@ -2415,7 +2298,7 @@ export declare const mapAccum: {
      *
      * **Example** (Mapping with accumulated state)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
@@ -2424,8 +2307,8 @@ export declare const mapAccum: {
      *   state + current // output running sum
      * ])
      *
-     * console.log(finalState) // 15 (final accumulated sum)
-     * console.log(Chunk.toArray(mapped)) // [1, 3, 6, 10, 15] (running sums)
+     * finalState // => 15
+     * Chunk.toArray(mapped) // => [1, 3, 6, 10, 15]
      *
      * // Building a string with indices
      * const words = Chunk.make("hello", "world", "effect")
@@ -2433,8 +2316,8 @@ export declare const mapAccum: {
      *   index + 1,
      *   `${index}: ${word}`
      * ])
-     * console.log(count) // 3
-     * console.log(Chunk.toArray(indexed)) // ["0: hello", "1: world", "2: effect"]
+     * count // => 3
+     * Chunk.toArray(indexed) // => ["0: hello", "1: world", "2: effect"]
      * ```
      *
      * @category folding
@@ -2451,15 +2334,15 @@ export declare const mapAccum: {
  *
  * **Example** (Partitioning with a Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
  * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
  *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
  * )
  *
- * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
- * console.log(Chunk.toArray(satisfying)) // [1, 5]
+ * Chunk.toArray(excluded) // => ["negative:-2"]
+ * Chunk.toArray(satisfying) // => [1, 5]
  * ```
  *
  * @category filtering
@@ -2475,15 +2358,15 @@ export declare const partition: {
      *
      * **Example** (Partitioning with a Result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
      *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
      * )
      *
-     * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
-     * console.log(Chunk.toArray(satisfying)) // [1, 5]
+     * Chunk.toArray(excluded) // => ["negative:-2"]
+     * Chunk.toArray(satisfying) // => [1, 5]
      * ```
      *
      * @category filtering
@@ -2499,15 +2382,15 @@ export declare const partition: {
      *
      * **Example** (Partitioning with a Result)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Result } from "effect"
      *
      * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
      *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
      * )
      *
-     * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
-     * console.log(Chunk.toArray(satisfying)) // [1, 5]
+     * Chunk.toArray(excluded) // => ["negative:-2"]
+     * Chunk.toArray(satisfying) // => [1, 5]
      * ```
      *
      * @category filtering
@@ -2526,7 +2409,7 @@ export declare const partition: {
  *
  * **Example** (Separating failures and successes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
  * const chunk = Chunk.make(
@@ -2538,14 +2421,14 @@ export declare const partition: {
  * )
  *
  * const [errors, values] = Chunk.separate(chunk)
- * console.log(Chunk.toArray(errors)) // ["error1", "error2"]
- * console.log(Chunk.toArray(values)) // [1, 2, 3]
+ * Chunk.toArray(errors) // => ["error1", "error2"]
+ * Chunk.toArray(values) // => [1, 2, 3]
  *
  * // All successes
  * const allSuccesses = Chunk.make(Result.succeed(1), Result.succeed(2))
  * const [noErrors, allValues] = Chunk.separate(allSuccesses)
- * console.log(Chunk.toArray(noErrors)) // []
- * console.log(Chunk.toArray(allValues)) // [1, 2]
+ * Chunk.toArray(noErrors) // => []
+ * Chunk.toArray(allValues) // => [1, 2]
  * ```
  *
  * @category filtering
@@ -2557,14 +2440,13 @@ export declare const separate: <A, B>(self: Chunk<Result<B, A>>) => [Chunk<A>, C
  *
  * **Example** (Getting chunk size)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.make(1, 2, 3)
- * console.log(Chunk.size(chunk)) // 3
+ * Chunk.size(Chunk.make(1, 2, 3)) // => 3
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const size: <A>(self: Chunk<A>) => number;
@@ -2573,21 +2455,18 @@ export declare const size: <A>(self: Chunk<A>) => number;
  *
  * **Example** (Sorting chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Order } from "effect"
  *
  * const numbers = Chunk.make(3, 1, 4, 1, 5, 9, 2, 6)
- * const sorted = Chunk.sort(numbers, Order.Number)
- * console.log(Chunk.toArray(sorted)) // [1, 1, 2, 3, 4, 5, 6, 9]
+ * Chunk.toArray(Chunk.sort(numbers, Order.Number)) // => [1, 1, 2, 3, 4, 5, 6, 9]
  *
  * // Reverse order
- * const reverseSorted = Chunk.sort(numbers, Order.flip(Order.Number))
- * console.log(Chunk.toArray(reverseSorted)) // [9, 6, 5, 4, 3, 2, 1, 1]
+ * Chunk.toArray(Chunk.sort(numbers, Order.flip(Order.Number))) // => [9, 6, 5, 4, 3, 2, 1, 1]
  *
  * // String sorting
  * const words = Chunk.make("banana", "apple", "cherry")
- * const sortedWords = Chunk.sort(words, Order.String)
- * console.log(Chunk.toArray(sortedWords)) // ["apple", "banana", "cherry"]
+ * Chunk.toArray(Chunk.sort(words, Order.String)) // => ["apple", "banana", "cherry"]
  * ```
  *
  * @category sorting
@@ -2599,21 +2478,18 @@ export declare const sort: {
      *
      * **Example** (Sorting chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Order } from "effect"
      *
      * const numbers = Chunk.make(3, 1, 4, 1, 5, 9, 2, 6)
-     * const sorted = Chunk.sort(numbers, Order.Number)
-     * console.log(Chunk.toArray(sorted)) // [1, 1, 2, 3, 4, 5, 6, 9]
+     * Chunk.toArray(Chunk.sort(numbers, Order.Number)) // => [1, 1, 2, 3, 4, 5, 6, 9]
      *
      * // Reverse order
-     * const reverseSorted = Chunk.sort(numbers, Order.flip(Order.Number))
-     * console.log(Chunk.toArray(reverseSorted)) // [9, 6, 5, 4, 3, 2, 1, 1]
+     * Chunk.toArray(Chunk.sort(numbers, Order.flip(Order.Number))) // => [9, 6, 5, 4, 3, 2, 1, 1]
      *
      * // String sorting
      * const words = Chunk.make("banana", "apple", "cherry")
-     * const sortedWords = Chunk.sort(words, Order.String)
-     * console.log(Chunk.toArray(sortedWords)) // ["apple", "banana", "cherry"]
+     * Chunk.toArray(Chunk.sort(words, Order.String)) // => ["apple", "banana", "cherry"]
      * ```
      *
      * @category sorting
@@ -2625,21 +2501,18 @@ export declare const sort: {
      *
      * **Example** (Sorting chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Order } from "effect"
      *
      * const numbers = Chunk.make(3, 1, 4, 1, 5, 9, 2, 6)
-     * const sorted = Chunk.sort(numbers, Order.Number)
-     * console.log(Chunk.toArray(sorted)) // [1, 1, 2, 3, 4, 5, 6, 9]
+     * Chunk.toArray(Chunk.sort(numbers, Order.Number)) // => [1, 1, 2, 3, 4, 5, 6, 9]
      *
      * // Reverse order
-     * const reverseSorted = Chunk.sort(numbers, Order.flip(Order.Number))
-     * console.log(Chunk.toArray(reverseSorted)) // [9, 6, 5, 4, 3, 2, 1, 1]
+     * Chunk.toArray(Chunk.sort(numbers, Order.flip(Order.Number))) // => [9, 6, 5, 4, 3, 2, 1, 1]
      *
      * // String sorting
      * const words = Chunk.make("banana", "apple", "cherry")
-     * const sortedWords = Chunk.sort(words, Order.String)
-     * console.log(Chunk.toArray(sortedWords)) // ["apple", "banana", "cherry"]
+     * Chunk.toArray(Chunk.sort(words, Order.String)) // => ["apple", "banana", "cherry"]
      * ```
      *
      * @category sorting
@@ -2652,7 +2525,7 @@ export declare const sort: {
  *
  * **Example** (Sorting chunks by a derived value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Order } from "effect"
  *
  * const people = Chunk.make(
@@ -2663,18 +2536,15 @@ export declare const sort: {
  *
  * // Sort by age
  * const byAge = Chunk.sortWith(people, (person) => person.age, Order.Number)
- * console.log(Chunk.toArray(byAge))
- * // [{ name: "Bob", age: 25 }, { name: "Alice", age: 30 }, { name: "Charlie", age: 35 }]
+ * Chunk.toArray(byAge).map((person) => person.name) // => ["Bob", "Alice", "Charlie"]
  *
  * // Sort by name
  * const byName = Chunk.sortWith(people, (person) => person.name, Order.String)
- * console.log(Chunk.toArray(byName))
- * // [{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }, { name: "Charlie", age: 35 }]
+ * Chunk.toArray(byName).map((person) => person.name) // => ["Alice", "Bob", "Charlie"]
  *
  * // Sort by string length
  * const words = Chunk.make("a", "abc", "ab")
- * const byLength = Chunk.sortWith(words, (word) => word.length, Order.Number)
- * console.log(Chunk.toArray(byLength)) // ["a", "ab", "abc"]
+ * Chunk.toArray(Chunk.sortWith(words, (word) => word.length, Order.Number)) // => ["a", "ab", "abc"]
  * ```
  *
  * @category sorting
@@ -2686,7 +2556,7 @@ export declare const sortWith: {
      *
      * **Example** (Sorting chunks by a derived value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Order } from "effect"
      *
      * const people = Chunk.make(
@@ -2697,18 +2567,15 @@ export declare const sortWith: {
      *
      * // Sort by age
      * const byAge = Chunk.sortWith(people, (person) => person.age, Order.Number)
-     * console.log(Chunk.toArray(byAge))
-     * // [{ name: "Bob", age: 25 }, { name: "Alice", age: 30 }, { name: "Charlie", age: 35 }]
+     * Chunk.toArray(byAge).map((person) => person.name) // => ["Bob", "Alice", "Charlie"]
      *
      * // Sort by name
      * const byName = Chunk.sortWith(people, (person) => person.name, Order.String)
-     * console.log(Chunk.toArray(byName))
-     * // [{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }, { name: "Charlie", age: 35 }]
+     * Chunk.toArray(byName).map((person) => person.name) // => ["Alice", "Bob", "Charlie"]
      *
      * // Sort by string length
      * const words = Chunk.make("a", "abc", "ab")
-     * const byLength = Chunk.sortWith(words, (word) => word.length, Order.Number)
-     * console.log(Chunk.toArray(byLength)) // ["a", "ab", "abc"]
+     * Chunk.toArray(Chunk.sortWith(words, (word) => word.length, Order.Number)) // => ["a", "ab", "abc"]
      * ```
      *
      * @category sorting
@@ -2720,7 +2587,7 @@ export declare const sortWith: {
      *
      * **Example** (Sorting chunks by a derived value)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Order } from "effect"
      *
      * const people = Chunk.make(
@@ -2731,18 +2598,15 @@ export declare const sortWith: {
      *
      * // Sort by age
      * const byAge = Chunk.sortWith(people, (person) => person.age, Order.Number)
-     * console.log(Chunk.toArray(byAge))
-     * // [{ name: "Bob", age: 25 }, { name: "Alice", age: 30 }, { name: "Charlie", age: 35 }]
+     * Chunk.toArray(byAge).map((person) => person.name) // => ["Bob", "Alice", "Charlie"]
      *
      * // Sort by name
      * const byName = Chunk.sortWith(people, (person) => person.name, Order.String)
-     * console.log(Chunk.toArray(byName))
-     * // [{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }, { name: "Charlie", age: 35 }]
+     * Chunk.toArray(byName).map((person) => person.name) // => ["Alice", "Bob", "Charlie"]
      *
      * // Sort by string length
      * const words = Chunk.make("a", "abc", "ab")
-     * const byLength = Chunk.sortWith(words, (word) => word.length, Order.Number)
-     * console.log(Chunk.toArray(byLength)) // ["a", "ab", "abc"]
+     * Chunk.toArray(Chunk.sortWith(words, (word) => word.length, Order.Number)) // => ["a", "ab", "abc"]
      * ```
      *
      * @category sorting
@@ -2755,23 +2619,23 @@ export declare const sortWith: {
  *
  * **Example** (Splitting at an index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
  * const [before, after] = Chunk.splitAt(chunk, 3)
- * console.log(Chunk.toArray(before)) // [1, 2, 3]
- * console.log(Chunk.toArray(after)) // [4, 5, 6]
+ * Chunk.toArray(before) // => [1, 2, 3]
+ * Chunk.toArray(after) // => [4, 5, 6]
  *
  * // Split at index 0
  * const [empty, all] = Chunk.splitAt(chunk, 0)
- * console.log(Chunk.toArray(empty)) // []
- * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(empty) // => []
+ * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
  *
  * // Split beyond length
  * const [allElements, empty2] = Chunk.splitAt(chunk, 10)
- * console.log(Chunk.toArray(allElements)) // [1, 2, 3, 4, 5, 6]
- * console.log(Chunk.toArray(empty2)) // []
+ * Chunk.toArray(allElements) // => [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(empty2) // => []
  * ```
  *
  * @category splitting
@@ -2783,23 +2647,23 @@ export declare const splitAt: {
      *
      * **Example** (Splitting at an index)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, after] = Chunk.splitAt(chunk, 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(after)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(after) // => [4, 5, 6]
      *
      * // Split at index 0
      * const [empty, all] = Chunk.splitAt(chunk, 0)
-     * console.log(Chunk.toArray(empty)) // []
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty) // => []
+     * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
      *
      * // Split beyond length
      * const [allElements, empty2] = Chunk.splitAt(chunk, 10)
-     * console.log(Chunk.toArray(allElements)) // [1, 2, 3, 4, 5, 6]
-     * console.log(Chunk.toArray(empty2)) // []
+     * Chunk.toArray(allElements) // => [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty2) // => []
      * ```
      *
      * @category splitting
@@ -2811,23 +2675,23 @@ export declare const splitAt: {
      *
      * **Example** (Splitting at an index)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, after] = Chunk.splitAt(chunk, 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(after)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(after) // => [4, 5, 6]
      *
      * // Split at index 0
      * const [empty, all] = Chunk.splitAt(chunk, 0)
-     * console.log(Chunk.toArray(empty)) // []
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty) // => []
+     * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
      *
      * // Split beyond length
      * const [allElements, empty2] = Chunk.splitAt(chunk, 10)
-     * console.log(Chunk.toArray(allElements)) // [1, 2, 3, 4, 5, 6]
-     * console.log(Chunk.toArray(empty2)) // []
+     * Chunk.toArray(allElements) // => [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty2) // => []
      * ```
      *
      * @category splitting
@@ -2847,18 +2711,18 @@ export declare const splitAt: {
  *
  * **Example** (Splitting non-empty chunks at an index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nonEmptyChunk = Chunk.make(1, 2, 3, 4, 5, 6)
  * const [before, after] = Chunk.splitNonEmptyAt(nonEmptyChunk, 3)
- * console.log(Chunk.toArray(before)) // [1, 2, 3]
- * console.log(Chunk.toArray(after)) // [4, 5, 6]
+ * Chunk.toArray(before) // => [1, 2, 3]
+ * Chunk.toArray(after) // => [4, 5, 6]
  *
  * // Split at 1 (minimum)
  * const [first, rest] = Chunk.splitNonEmptyAt(nonEmptyChunk, 1)
- * console.log(Chunk.toArray(first)) // [1]
- * console.log(Chunk.toArray(rest)) // [2, 3, 4, 5, 6]
+ * Chunk.toArray(first) // => [1]
+ * Chunk.toArray(rest) // => [2, 3, 4, 5, 6]
  *
  * // The first part is guaranteed to be NonEmptyChunk
  * // while the second part may be empty
@@ -2880,18 +2744,18 @@ export declare const splitNonEmptyAt: {
      *
      * **Example** (Splitting non-empty chunks at an index)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const nonEmptyChunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, after] = Chunk.splitNonEmptyAt(nonEmptyChunk, 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(after)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(after) // => [4, 5, 6]
      *
      * // Split at 1 (minimum)
      * const [first, rest] = Chunk.splitNonEmptyAt(nonEmptyChunk, 1)
-     * console.log(Chunk.toArray(first)) // [1]
-     * console.log(Chunk.toArray(rest)) // [2, 3, 4, 5, 6]
+     * Chunk.toArray(first) // => [1]
+     * Chunk.toArray(rest) // => [2, 3, 4, 5, 6]
      *
      * // The first part is guaranteed to be NonEmptyChunk
      * // while the second part may be empty
@@ -2913,18 +2777,18 @@ export declare const splitNonEmptyAt: {
      *
      * **Example** (Splitting non-empty chunks at an index)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const nonEmptyChunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, after] = Chunk.splitNonEmptyAt(nonEmptyChunk, 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(after)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(after) // => [4, 5, 6]
      *
      * // Split at 1 (minimum)
      * const [first, rest] = Chunk.splitNonEmptyAt(nonEmptyChunk, 1)
-     * console.log(Chunk.toArray(first)) // [1]
-     * console.log(Chunk.toArray(rest)) // [2, 3, 4, 5, 6]
+     * Chunk.toArray(first) // => [1]
+     * Chunk.toArray(rest) // => [2, 3, 4, 5, 6]
      *
      * // The first part is guaranteed to be NonEmptyChunk
      * // while the second part may be empty
@@ -2945,24 +2809,21 @@ export declare const splitNonEmptyAt: {
  *
  * **Example** (Splitting chunks into groups)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
  * const chunks = Chunk.split(chunk, 3)
- * console.log(Chunk.toArray(chunks).map(Chunk.toArray))
- * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+ * Chunk.toArray(chunks).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  *
  * // Uneven split
  * const chunk2 = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8)
  * const chunks2 = Chunk.split(chunk2, 3)
- * console.log(Chunk.toArray(chunks2).map(Chunk.toArray))
- * // [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * Chunk.toArray(chunks2).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8]]
  *
  * // Split into 1 chunk
  * const chunks3 = Chunk.split(chunk, 1)
- * console.log(Chunk.toArray(chunks3).map(Chunk.toArray))
- * // [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+ * Chunk.toArray(chunks3).map(Chunk.toArray) // => [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
  * ```
  *
  * @category splitting
@@ -2979,24 +2840,21 @@ export declare const split: {
      *
      * **Example** (Splitting chunks into groups)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
      * const chunks = Chunk.split(chunk, 3)
-     * console.log(Chunk.toArray(chunks).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+     * Chunk.toArray(chunks).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
      *
      * // Uneven split
      * const chunk2 = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8)
      * const chunks2 = Chunk.split(chunk2, 3)
-     * console.log(Chunk.toArray(chunks2).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8]]
+     * Chunk.toArray(chunks2).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8]]
      *
      * // Split into 1 chunk
      * const chunks3 = Chunk.split(chunk, 1)
-     * console.log(Chunk.toArray(chunks3).map(Chunk.toArray))
-     * // [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+     * Chunk.toArray(chunks3).map(Chunk.toArray) // => [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
      * ```
      *
      * @category splitting
@@ -3013,24 +2871,21 @@ export declare const split: {
      *
      * **Example** (Splitting chunks into groups)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8, 9)
      * const chunks = Chunk.split(chunk, 3)
-     * console.log(Chunk.toArray(chunks).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+     * Chunk.toArray(chunks).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
      *
      * // Uneven split
      * const chunk2 = Chunk.make(1, 2, 3, 4, 5, 6, 7, 8)
      * const chunks2 = Chunk.split(chunk2, 3)
-     * console.log(Chunk.toArray(chunks2).map(Chunk.toArray))
-     * // [[1, 2, 3], [4, 5, 6], [7, 8]]
+     * Chunk.toArray(chunks2).map(Chunk.toArray) // => [[1, 2, 3], [4, 5, 6], [7, 8]]
      *
      * // Split into 1 chunk
      * const chunks3 = Chunk.split(chunk, 1)
-     * console.log(Chunk.toArray(chunks3).map(Chunk.toArray))
-     * // [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+     * Chunk.toArray(chunks3).map(Chunk.toArray) // => [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
      * ```
      *
      * @category splitting
@@ -3044,23 +2899,23 @@ export declare const split: {
  *
  * **Example** (Splitting at a matching element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
  * const [before, fromMatch] = Chunk.splitWhere(chunk, (n) => n > 3)
- * console.log(Chunk.toArray(before)) // [1, 2, 3]
- * console.log(Chunk.toArray(fromMatch)) // [4, 5, 6]
+ * Chunk.toArray(before) // => [1, 2, 3]
+ * Chunk.toArray(fromMatch) // => [4, 5, 6]
  *
  * // No match found
  * const [all, empty] = Chunk.splitWhere(chunk, (n) => n > 10)
- * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
- * console.log(Chunk.toArray(empty)) // []
+ * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(empty) // => []
  *
  * // Match on first element
  * const [emptyBefore, allFromFirst] = Chunk.splitWhere(chunk, (n) => n === 1)
- * console.log(Chunk.toArray(emptyBefore)) // []
- * console.log(Chunk.toArray(allFromFirst)) // [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(emptyBefore) // => []
+ * Chunk.toArray(allFromFirst) // => [1, 2, 3, 4, 5, 6]
  * ```
  *
  * @category splitting
@@ -3073,23 +2928,23 @@ export declare const splitWhere: {
      *
      * **Example** (Splitting at a matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, fromMatch] = Chunk.splitWhere(chunk, (n) => n > 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(fromMatch)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(fromMatch) // => [4, 5, 6]
      *
      * // No match found
      * const [all, empty] = Chunk.splitWhere(chunk, (n) => n > 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
-     * console.log(Chunk.toArray(empty)) // []
+     * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty) // => []
      *
      * // Match on first element
      * const [emptyBefore, allFromFirst] = Chunk.splitWhere(chunk, (n) => n === 1)
-     * console.log(Chunk.toArray(emptyBefore)) // []
-     * console.log(Chunk.toArray(allFromFirst)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(emptyBefore) // => []
+     * Chunk.toArray(allFromFirst) // => [1, 2, 3, 4, 5, 6]
      * ```
      *
      * @category splitting
@@ -3102,23 +2957,23 @@ export declare const splitWhere: {
      *
      * **Example** (Splitting at a matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
      * const [before, fromMatch] = Chunk.splitWhere(chunk, (n) => n > 3)
-     * console.log(Chunk.toArray(before)) // [1, 2, 3]
-     * console.log(Chunk.toArray(fromMatch)) // [4, 5, 6]
+     * Chunk.toArray(before) // => [1, 2, 3]
+     * Chunk.toArray(fromMatch) // => [4, 5, 6]
      *
      * // No match found
      * const [all, empty] = Chunk.splitWhere(chunk, (n) => n > 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
-     * console.log(Chunk.toArray(empty)) // []
+     * Chunk.toArray(all) // => [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(empty) // => []
      *
      * // Match on first element
      * const [emptyBefore, allFromFirst] = Chunk.splitWhere(chunk, (n) => n === 1)
-     * console.log(Chunk.toArray(emptyBefore)) // []
-     * console.log(Chunk.toArray(allFromFirst)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(emptyBefore) // => []
+     * Chunk.toArray(allFromFirst) // => [1, 2, 3, 4, 5, 6]
      * ```
      *
      * @category splitting
@@ -3131,20 +2986,19 @@ export declare const splitWhere: {
  *
  * **Example** (Getting the tail safely)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
- * console.log(Chunk.tail(chunk)) // Option.some(Chunk.make(2, 3, 4))
+ * Chunk.tail(chunk) // => Option.some(Chunk.make(2, 3, 4))
  *
  * const singleElement = Chunk.make(1)
- * console.log(Chunk.tail(singleElement)) // Option.some(Chunk.empty())
+ * Chunk.tail(singleElement) // => Option.some(Chunk.empty())
  *
- * const empty = Chunk.empty<number>()
- * console.log(Chunk.tail(empty)) // Option.none()
+ * Chunk.tail(Chunk.empty<number>()) // => Option.none()
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const tail: <A>(self: Chunk<A>) => O.Option<Chunk<A>>;
@@ -3153,22 +3007,20 @@ export declare const tail: <A>(self: Chunk<A>) => O.Option<Chunk<A>>;
  *
  * **Example** (Getting the tail of a non-empty chunk)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nonEmptyChunk = Chunk.make(1, 2, 3, 4)
- * const result = Chunk.tailNonEmpty(nonEmptyChunk)
- * console.log(Chunk.toArray(result)) // [2, 3, 4]
+ * Chunk.toArray(Chunk.tailNonEmpty(nonEmptyChunk)) // => [2, 3, 4]
  *
  * const singleElement = Chunk.make(1)
- * const resultSingle = Chunk.tailNonEmpty(singleElement)
- * console.log(Chunk.toArray(resultSingle)) // []
+ * Chunk.toArray(Chunk.tailNonEmpty(singleElement)) // => []
  *
  * // Type safety: this function only accepts NonEmptyChunk
  * // Chunk.tailNonEmpty(Chunk.empty()) // TypeScript error
  * ```
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export declare const tailNonEmpty: <A>(self: NonEmptyChunk<A>) => Chunk<A>;
@@ -3177,23 +3029,20 @@ export declare const tailNonEmpty: <A>(self: NonEmptyChunk<A>) => Chunk<A>;
  *
  * **Example** (Taking elements from the end)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
- * const lastThree = Chunk.takeRight(chunk, 3)
- * console.log(Chunk.toArray(lastThree)) // [4, 5, 6]
+ * Chunk.toArray(Chunk.takeRight(chunk, 3)) // => [4, 5, 6]
  *
  * // Take more than available
- * const all = Chunk.takeRight(chunk, 10)
- * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+ * Chunk.toArray(Chunk.takeRight(chunk, 10)) // => [1, 2, 3, 4, 5, 6]
  *
  * // Take zero
- * const none = Chunk.takeRight(chunk, 0)
- * console.log(Chunk.toArray(none)) // []
+ * Chunk.toArray(Chunk.takeRight(chunk, 0)) // => []
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const takeRight: {
@@ -3202,23 +3051,20 @@ export declare const takeRight: {
      *
      * **Example** (Taking elements from the end)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const lastThree = Chunk.takeRight(chunk, 3)
-     * console.log(Chunk.toArray(lastThree)) // [4, 5, 6]
+     * Chunk.toArray(Chunk.takeRight(chunk, 3)) // => [4, 5, 6]
      *
      * // Take more than available
-     * const all = Chunk.takeRight(chunk, 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(Chunk.takeRight(chunk, 10)) // => [1, 2, 3, 4, 5, 6]
      *
      * // Take zero
-     * const none = Chunk.takeRight(chunk, 0)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeRight(chunk, 0)) // => []
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
@@ -3227,23 +3073,20 @@ export declare const takeRight: {
      *
      * **Example** (Taking elements from the end)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const lastThree = Chunk.takeRight(chunk, 3)
-     * console.log(Chunk.toArray(lastThree)) // [4, 5, 6]
+     * Chunk.toArray(Chunk.takeRight(chunk, 3)) // => [4, 5, 6]
      *
      * // Take more than available
-     * const all = Chunk.takeRight(chunk, 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3, 4, 5, 6]
+     * Chunk.toArray(Chunk.takeRight(chunk, 10)) // => [1, 2, 3, 4, 5, 6]
      *
      * // Take zero
-     * const none = Chunk.takeRight(chunk, 0)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeRight(chunk, 0)) // => []
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
@@ -3253,24 +3096,21 @@ export declare const takeRight: {
  *
  * **Example** (Taking elements while a predicate matches)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 3, 2, 1)
- * const result = Chunk.takeWhile(chunk, (n) => n < 4)
- * console.log(Chunk.toArray(result)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n < 4)) // => [1, 2, 3]
  *
  * // Empty if first element doesn't match
- * const none = Chunk.takeWhile(chunk, (n) => n > 5)
- * console.log(Chunk.toArray(none)) // []
+ * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n > 5)) // => []
  *
  * // Takes all if all match
  * const small = Chunk.make(1, 2, 3)
- * const all = Chunk.takeWhile(small, (n) => n < 10)
- * console.log(Chunk.toArray(all)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.takeWhile(small, (n) => n < 10)) // => [1, 2, 3]
  * ```
  *
- * @category elements
+ * @category filtering
  * @since 2.0.0
  */
 export declare const takeWhile: {
@@ -3279,24 +3119,21 @@ export declare const takeWhile: {
      *
      * **Example** (Taking elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 3, 2, 1)
-     * const result = Chunk.takeWhile(chunk, (n) => n < 4)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n < 4)) // => [1, 2, 3]
      *
      * // Empty if first element doesn't match
-     * const none = Chunk.takeWhile(chunk, (n) => n > 5)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n > 5)) // => []
      *
      * // Takes all if all match
      * const small = Chunk.make(1, 2, 3)
-     * const all = Chunk.takeWhile(small, (n) => n < 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(small, (n) => n < 10)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Chunk<B>;
@@ -3305,24 +3142,21 @@ export declare const takeWhile: {
      *
      * **Example** (Taking elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 3, 2, 1)
-     * const result = Chunk.takeWhile(chunk, (n) => n < 4)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n < 4)) // => [1, 2, 3]
      *
      * // Empty if first element doesn't match
-     * const none = Chunk.takeWhile(chunk, (n) => n > 5)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n > 5)) // => []
      *
      * // Takes all if all match
      * const small = Chunk.make(1, 2, 3)
-     * const all = Chunk.takeWhile(small, (n) => n < 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(small, (n) => n < 10)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
@@ -3331,24 +3165,21 @@ export declare const takeWhile: {
      *
      * **Example** (Taking elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 3, 2, 1)
-     * const result = Chunk.takeWhile(chunk, (n) => n < 4)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n < 4)) // => [1, 2, 3]
      *
      * // Empty if first element doesn't match
-     * const none = Chunk.takeWhile(chunk, (n) => n > 5)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n > 5)) // => []
      *
      * // Takes all if all match
      * const small = Chunk.make(1, 2, 3)
-     * const all = Chunk.takeWhile(small, (n) => n < 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(small, (n) => n < 10)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>;
@@ -3357,24 +3188,21 @@ export declare const takeWhile: {
      *
      * **Example** (Taking elements while a predicate matches)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 3, 2, 1)
-     * const result = Chunk.takeWhile(chunk, (n) => n < 4)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n < 4)) // => [1, 2, 3]
      *
      * // Empty if first element doesn't match
-     * const none = Chunk.takeWhile(chunk, (n) => n > 5)
-     * console.log(Chunk.toArray(none)) // []
+     * Chunk.toArray(Chunk.takeWhile(chunk, (n) => n > 5)) // => []
      *
      * // Takes all if all match
      * const small = Chunk.make(1, 2, 3)
-     * const all = Chunk.takeWhile(small, (n) => n < 10)
-     * console.log(Chunk.toArray(all)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.takeWhile(small, (n) => n < 10)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category filtering
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
@@ -3384,22 +3212,20 @@ export declare const takeWhile: {
  *
  * **Example** (Unioning chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk1 = Chunk.make(1, 2, 3)
  * const chunk2 = Chunk.make(3, 4, 5)
- * const result = Chunk.union(chunk1, chunk2)
- * console.log(Chunk.toArray(result)) // [1, 2, 3, 4, 5]
+ * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
  *
  * // Handles duplicates within the same chunk
  * const withDupes1 = Chunk.make(1, 1, 2)
  * const withDupes2 = Chunk.make(2, 3, 3)
- * const unified = Chunk.union(withDupes1, withDupes2)
- * console.log(Chunk.toArray(unified)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
  * ```
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export declare const union: {
@@ -3408,22 +3234,20 @@ export declare const union: {
      *
      * **Example** (Unioning chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3)
      * const chunk2 = Chunk.make(3, 4, 5)
-     * const result = Chunk.union(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3, 4, 5]
+     * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
      *
      * // Handles duplicates within the same chunk
      * const withDupes1 = Chunk.make(1, 1, 2)
      * const withDupes2 = Chunk.make(2, 3, 3)
-     * const unified = Chunk.union(withDupes1, withDupes2)
-     * console.log(Chunk.toArray(unified)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category set operations
      * @since 2.0.0
      */
     <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>;
@@ -3432,22 +3256,20 @@ export declare const union: {
      *
      * **Example** (Unioning chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3)
      * const chunk2 = Chunk.make(3, 4, 5)
-     * const result = Chunk.union(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 3, 4, 5]
+     * Chunk.toArray(Chunk.union(chunk1, chunk2)) // => [1, 2, 3, 4, 5]
      *
      * // Handles duplicates within the same chunk
      * const withDupes1 = Chunk.make(1, 1, 2)
      * const withDupes2 = Chunk.make(2, 3, 3)
-     * const unified = Chunk.union(withDupes1, withDupes2)
-     * console.log(Chunk.toArray(unified)) // [1, 2, 3]
+     * Chunk.toArray(Chunk.union(withDupes1, withDupes2)) // => [1, 2, 3]
      * ```
      *
-     * @category elements
+     * @category set operations
      * @since 2.0.0
      */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
@@ -3458,25 +3280,22 @@ export declare const union: {
  *
  * **Example** (Removing duplicate values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 2, 3, 1, 4, 3)
- * const result = Chunk.dedupe(chunk)
- * console.log(Chunk.toArray(result)) // [1, 2, 3, 4]
+ * Chunk.toArray(Chunk.dedupe(chunk)) // => [1, 2, 3, 4]
  *
  * // Empty chunk
  * const empty = Chunk.empty<number>()
- * const emptyDeduped = Chunk.dedupe(empty)
- * console.log(Chunk.toArray(emptyDeduped)) // []
+ * Chunk.toArray(Chunk.dedupe(empty)) // => []
  *
  * // No duplicates
  * const unique = Chunk.make(1, 2, 3)
- * const uniqueDeduped = Chunk.dedupe(unique)
- * console.log(Chunk.toArray(uniqueDeduped)) // [1, 2, 3]
+ * Chunk.toArray(Chunk.dedupe(unique)) // => [1, 2, 3]
  * ```
  *
- * @category elements
+ * @category deduplication
  * @since 2.0.0
  */
 export declare const dedupe: <A>(self: Chunk<A>) => Chunk<A>;
@@ -3485,17 +3304,15 @@ export declare const dedupe: <A>(self: Chunk<A>) => Chunk<A>;
  *
  * **Example** (Removing adjacent duplicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 1, 2, 2, 2, 3, 1, 1)
- * const result = Chunk.dedupeAdjacent(chunk)
- * console.log(Chunk.toArray(result)) // [1, 2, 3, 1]
+ * Chunk.toArray(Chunk.dedupeAdjacent(chunk)) // => [1, 2, 3, 1]
  *
  * // Only removes adjacent duplicates, not all duplicates
  * const mixed = Chunk.make("a", "a", "b", "a", "a")
- * const mixedResult = Chunk.dedupeAdjacent(mixed)
- * console.log(Chunk.toArray(mixedResult)) // ["a", "b", "a"]
+ * Chunk.toArray(Chunk.dedupeAdjacent(mixed)) // => ["a", "b", "a"]
  * ```
  *
  * @category filtering
@@ -3511,7 +3328,7 @@ export declare const dedupeAdjacent: <A>(self: Chunk<A>) => Chunk<A>;
  *
  * **Example** (Unzipping pairs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const pairs = Chunk.make(
@@ -3520,17 +3337,17 @@ export declare const dedupeAdjacent: <A>(self: Chunk<A>) => Chunk<A>;
  *   [3, "c"] as const
  * )
  * const [numbers, letters] = Chunk.unzip(pairs)
- * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
- * console.log(Chunk.toArray(letters)) // ["a", "b", "c"]
+ * Chunk.toArray(numbers) // => [1, 2, 3]
+ * Chunk.toArray(letters) // => ["a", "b", "c"]
  *
  * // Empty chunk
  * const empty = Chunk.empty<[number, string]>()
  * const [emptyNums, emptyStrs] = Chunk.unzip(empty)
- * console.log(Chunk.toArray(emptyNums)) // []
- * console.log(Chunk.toArray(emptyStrs)) // []
+ * Chunk.toArray(emptyNums) // => []
+ * Chunk.toArray(emptyStrs) // => []
  * ```
  *
- * @category elements
+ * @category splitting
  * @since 2.0.0
  */
 export declare const unzip: <A, B>(self: Chunk<readonly [A, B]>) => [Chunk<A>, Chunk<B>];
@@ -3539,19 +3356,17 @@ export declare const unzip: <A, B>(self: Chunk<readonly [A, B]>) => [Chunk<A>, C
  *
  * **Example** (Zipping chunks with a function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const numbers = Chunk.make(1, 2, 3)
  * const letters = Chunk.make("a", "b", "c")
- * const result = Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)
- * console.log(Chunk.toArray(result)) // ["1-a", "2-b", "3-c"]
+ * Chunk.toArray(Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)) // => ["1-a", "2-b", "3-c"]
  *
  * // Different lengths - takes minimum
  * const short = Chunk.make(1, 2)
  * const long = Chunk.make("a", "b", "c", "d")
- * const mixed = Chunk.zipWith(short, long, (n, l) => [n, l])
- * console.log(Chunk.toArray(mixed)) // [[1, "a"], [2, "b"]]
+ * Chunk.toArray(Chunk.zipWith(short, long, (n, l) => [n, l])) // => [[1, "a"], [2, "b"]]
  * ```
  *
  * @category zipping
@@ -3563,19 +3378,17 @@ export declare const zipWith: {
      *
      * **Example** (Zipping chunks with a function)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const numbers = Chunk.make(1, 2, 3)
      * const letters = Chunk.make("a", "b", "c")
-     * const result = Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)
-     * console.log(Chunk.toArray(result)) // ["1-a", "2-b", "3-c"]
+     * Chunk.toArray(Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)) // => ["1-a", "2-b", "3-c"]
      *
      * // Different lengths - takes minimum
      * const short = Chunk.make(1, 2)
      * const long = Chunk.make("a", "b", "c", "d")
-     * const mixed = Chunk.zipWith(short, long, (n, l) => [n, l])
-     * console.log(Chunk.toArray(mixed)) // [[1, "a"], [2, "b"]]
+     * Chunk.toArray(Chunk.zipWith(short, long, (n, l) => [n, l])) // => [[1, "a"], [2, "b"]]
      * ```
      *
      * @category zipping
@@ -3587,19 +3400,17 @@ export declare const zipWith: {
      *
      * **Example** (Zipping chunks with a function)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const numbers = Chunk.make(1, 2, 3)
      * const letters = Chunk.make("a", "b", "c")
-     * const result = Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)
-     * console.log(Chunk.toArray(result)) // ["1-a", "2-b", "3-c"]
+     * Chunk.toArray(Chunk.zipWith(numbers, letters, (n, l) => `${n}-${l}`)) // => ["1-a", "2-b", "3-c"]
      *
      * // Different lengths - takes minimum
      * const short = Chunk.make(1, 2)
      * const long = Chunk.make("a", "b", "c", "d")
-     * const mixed = Chunk.zipWith(short, long, (n, l) => [n, l])
-     * console.log(Chunk.toArray(mixed)) // [[1, "a"], [2, "b"]]
+     * Chunk.toArray(Chunk.zipWith(short, long, (n, l) => [n, l])) // => [[1, "a"], [2, "b"]]
      * ```
      *
      * @category zipping
@@ -3612,19 +3423,17 @@ export declare const zipWith: {
  *
  * **Example** (Zipping chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const numbers = Chunk.make(1, 2, 3)
  * const letters = Chunk.make("a", "b", "c")
- * const result = Chunk.zip(numbers, letters)
- * console.log(Chunk.toArray(result)) // [[1, "a"], [2, "b"], [3, "c"]]
+ * Chunk.toArray(Chunk.zip(numbers, letters)) // => [[1, "a"], [2, "b"], [3, "c"]]
  *
  * // Different lengths - takes minimum length
  * const short = Chunk.make(1, 2)
  * const long = Chunk.make("a", "b", "c", "d")
- * const zipped = Chunk.zip(short, long)
- * console.log(Chunk.toArray(zipped)) // [[1, "a"], [2, "b"]]
+ * Chunk.toArray(Chunk.zip(short, long)) // => [[1, "a"], [2, "b"]]
  * ```
  *
  * @category zipping
@@ -3636,19 +3445,17 @@ export declare const zip: {
      *
      * **Example** (Zipping chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const numbers = Chunk.make(1, 2, 3)
      * const letters = Chunk.make("a", "b", "c")
-     * const result = Chunk.zip(numbers, letters)
-     * console.log(Chunk.toArray(result)) // [[1, "a"], [2, "b"], [3, "c"]]
+     * Chunk.toArray(Chunk.zip(numbers, letters)) // => [[1, "a"], [2, "b"], [3, "c"]]
      *
      * // Different lengths - takes minimum length
      * const short = Chunk.make(1, 2)
      * const long = Chunk.make("a", "b", "c", "d")
-     * const zipped = Chunk.zip(short, long)
-     * console.log(Chunk.toArray(zipped)) // [[1, "a"], [2, "b"]]
+     * Chunk.toArray(Chunk.zip(short, long)) // => [[1, "a"], [2, "b"]]
      * ```
      *
      * @category zipping
@@ -3660,19 +3467,17 @@ export declare const zip: {
      *
      * **Example** (Zipping chunks)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const numbers = Chunk.make(1, 2, 3)
      * const letters = Chunk.make("a", "b", "c")
-     * const result = Chunk.zip(numbers, letters)
-     * console.log(Chunk.toArray(result)) // [[1, "a"], [2, "b"], [3, "c"]]
+     * Chunk.toArray(Chunk.zip(numbers, letters)) // => [[1, "a"], [2, "b"], [3, "c"]]
      *
      * // Different lengths - takes minimum length
      * const short = Chunk.make(1, 2)
      * const long = Chunk.make("a", "b", "c", "d")
-     * const zipped = Chunk.zip(short, long)
-     * console.log(Chunk.toArray(zipped)) // [[1, "a"], [2, "b"]]
+     * Chunk.toArray(Chunk.zip(short, long)) // => [[1, "a"], [2, "b"]]
      * ```
      *
      * @category zipping
@@ -3685,23 +3490,20 @@ export declare const zip: {
  *
  * **Example** (Removing an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
- * const result = Chunk.remove(chunk, 1)
- * console.log(Chunk.toArray(result)) // ["a", "c", "d"]
+ * Chunk.toArray(Chunk.remove(chunk, 1)) // => ["a", "c", "d"]
  *
  * // Remove first element
- * const removeFirst = Chunk.remove(chunk, 0)
- * console.log(Chunk.toArray(removeFirst)) // ["b", "c", "d"]
+ * Chunk.toArray(Chunk.remove(chunk, 0)) // => ["b", "c", "d"]
  *
  * // Index out of bounds returns same chunk
- * const outOfBounds = Chunk.remove(chunk, 10)
- * console.log(Chunk.toArray(outOfBounds)) // ["a", "b", "c", "d"]
+ * Chunk.toArray(Chunk.remove(chunk, 10)) // => ["a", "b", "c", "d"]
  * ```
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export declare const remove: {
@@ -3710,23 +3512,20 @@ export declare const remove: {
      *
      * **Example** (Removing an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
-     * const result = Chunk.remove(chunk, 1)
-     * console.log(Chunk.toArray(result)) // ["a", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 1)) // => ["a", "c", "d"]
      *
      * // Remove first element
-     * const removeFirst = Chunk.remove(chunk, 0)
-     * console.log(Chunk.toArray(removeFirst)) // ["b", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 0)) // => ["b", "c", "d"]
      *
      * // Index out of bounds returns same chunk
-     * const outOfBounds = Chunk.remove(chunk, 10)
-     * console.log(Chunk.toArray(outOfBounds)) // ["a", "b", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 10)) // => ["a", "b", "c", "d"]
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     (i: number): <A>(self: Chunk<A>) => Chunk<A>;
@@ -3735,23 +3534,20 @@ export declare const remove: {
      *
      * **Example** (Removing an element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
-     * const result = Chunk.remove(chunk, 1)
-     * console.log(Chunk.toArray(result)) // ["a", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 1)) // => ["a", "c", "d"]
      *
      * // Remove first element
-     * const removeFirst = Chunk.remove(chunk, 0)
-     * console.log(Chunk.toArray(removeFirst)) // ["b", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 0)) // => ["b", "c", "d"]
      *
      * // Index out of bounds returns same chunk
-     * const outOfBounds = Chunk.remove(chunk, 10)
-     * console.log(Chunk.toArray(outOfBounds)) // ["a", "b", "c", "d"]
+     * Chunk.toArray(Chunk.remove(chunk, 10)) // => ["a", "b", "c", "d"]
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, i: number): Chunk<A>;
@@ -3762,23 +3558,20 @@ export declare const remove: {
  *
  * **Example** (Modifying an element)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
- * const result = Chunk.modify(chunk, 1, (n) => n * 10)
- * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
+ * Chunk.modify(chunk, 1, (n) => n * 10) // => Option.some(Chunk.make(1, 20, 3, 4))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
- * console.log(outOfBounds) // Option.none()
+ * chunk.pipe(Chunk.modify(10, (n) => n * 10)) // => Option.none()
  *
  * // Negative index returns None
- * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
- * console.log(negative) // Option.none()
+ * chunk.pipe(Chunk.modify(-1, (n) => n * 10)) // => Option.none()
  * ```
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export declare const modify: {
@@ -3788,23 +3581,20 @@ export declare const modify: {
      *
      * **Example** (Modifying an element)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
-     * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-     * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
+     * Chunk.modify(chunk, 1, (n) => n * 10) // => Option.some(Chunk.make(1, 20, 3, 4))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
-     * console.log(outOfBounds) // Option.none()
+     * chunk.pipe(Chunk.modify(10, (n) => n * 10)) // => Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
-     * console.log(negative) // Option.none()
+     * chunk.pipe(Chunk.modify(-1, (n) => n * 10)) // => Option.none()
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => O.Option<Chunk<A | B>>;
@@ -3814,23 +3604,20 @@ export declare const modify: {
      *
      * **Example** (Modifying an element)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
-     * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-     * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
+     * Chunk.modify(chunk, 1, (n) => n * 10) // => Option.some(Chunk.make(1, 20, 3, 4))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
-     * console.log(outOfBounds) // Option.none()
+     * chunk.pipe(Chunk.modify(10, (n) => n * 10)) // => Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
-     * console.log(negative) // Option.none()
+     * chunk.pipe(Chunk.modify(-1, (n) => n * 10)) // => Option.none()
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): O.Option<Chunk<A | B>>;
@@ -3841,23 +3628,20 @@ export declare const modify: {
  *
  * **Example** (Replacing an element)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
- * const result = Chunk.replace(chunk, 1, "X")
- * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
+ * Chunk.replace(chunk, 1, "X") // => Option.some(Chunk.make("a", "X", "c", "d"))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
- * console.log(outOfBounds) // Option.none()
+ * chunk.pipe(Chunk.replace(10, "Y")) // => Option.none()
  *
  * // Negative index returns None
- * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
- * console.log(negative) // Option.none()
+ * chunk.pipe(Chunk.replace(-1, "Z")) // => Option.none()
  * ```
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export declare const replace: {
@@ -3867,23 +3651,20 @@ export declare const replace: {
      *
      * **Example** (Replacing an element)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
-     * const result = Chunk.replace(chunk, 1, "X")
-     * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
+     * Chunk.replace(chunk, 1, "X") // => Option.some(Chunk.make("a", "X", "c", "d"))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
-     * console.log(outOfBounds) // Option.none()
+     * chunk.pipe(Chunk.replace(10, "Y")) // => Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
-     * console.log(negative) // Option.none()
+     * chunk.pipe(Chunk.replace(-1, "Z")) // => Option.none()
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     <B>(i: number, b: B): <A>(self: Chunk<A>) => O.Option<Chunk<B | A>>;
@@ -3893,23 +3674,20 @@ export declare const replace: {
      *
      * **Example** (Replacing an element)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
-     * const result = Chunk.replace(chunk, 1, "X")
-     * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
+     * Chunk.replace(chunk, 1, "X") // => Option.some(Chunk.make("a", "X", "c", "d"))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
-     * console.log(outOfBounds) // Option.none()
+     * chunk.pipe(Chunk.replace(10, "Y")) // => Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
-     * console.log(negative) // Option.none()
+     * chunk.pipe(Chunk.replace(-1, "Z")) // => Option.none()
      * ```
      *
-     * @category elements
+     * @category transforming
      * @since 2.0.0
      */
     <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>>;
@@ -3923,11 +3701,10 @@ export declare const replace: {
  *
  * **Example** (Generating chunks from indices)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.makeBy(5, (i) => i * 2)
- * console.log(Chunk.toArray(chunk)) // [0, 2, 4, 6, 8]
+ * Chunk.toArray(Chunk.makeBy(5, (i) => i * 2)) // => [0, 2, 4, 6, 8]
  * ```
  *
  * @category constructors
@@ -3943,11 +3720,10 @@ export declare const makeBy: {
      *
      * **Example** (Generating chunks from indices)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const chunk = Chunk.makeBy(5, (i) => i * 2)
-     * console.log(Chunk.toArray(chunk)) // [0, 2, 4, 6, 8]
+     * Chunk.toArray(Chunk.makeBy(5, (i) => i * 2)) // => [0, 2, 4, 6, 8]
      * ```
      *
      * @category constructors
@@ -3963,11 +3739,10 @@ export declare const makeBy: {
      *
      * **Example** (Generating chunks from indices)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
-     * const chunk = Chunk.makeBy(5, (i) => i * 2)
-     * console.log(Chunk.toArray(chunk)) // [0, 2, 4, 6, 8]
+     * Chunk.toArray(Chunk.makeBy(5, (i) => i * 2)) // => [0, 2, 4, 6, 8]
      * ```
      *
      * @category constructors
@@ -3986,11 +3761,10 @@ export declare const makeBy: {
  *
  * **Example** (Creating a range)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
- * const chunk = Chunk.range(1, 5)
- * console.log(Chunk.toArray(chunk)) // [1, 2, 3, 4, 5]
+ * Chunk.toArray(Chunk.range(1, 5)) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category constructors
@@ -4002,24 +3776,23 @@ export declare const range: (start: number, end: number) => NonEmptyChunk<number
  *
  * **Example** (Checking membership)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * console.log(Chunk.contains(chunk, 3)) // true
- * console.log(Chunk.contains(chunk, 6)) // false
+ * Chunk.contains(chunk, 3) // => true
+ * Chunk.contains(chunk, 6) // => false
  *
  * // Works with strings
  * const words = Chunk.make("apple", "banana", "cherry")
- * console.log(Chunk.contains(words, "banana")) // true
- * console.log(Chunk.contains(words, "grape")) // false
+ * Chunk.contains(words, "banana") // => true
+ * Chunk.contains(words, "grape") // => false
  *
  * // Empty chunk
- * const empty = Chunk.empty<number>()
- * console.log(Chunk.contains(empty, 1)) // false
+ * Chunk.contains(Chunk.empty<number>(), 1) // => false
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export declare const contains: {
@@ -4028,24 +3801,23 @@ export declare const contains: {
      *
      * **Example** (Checking membership)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.contains(chunk, 3)) // true
-     * console.log(Chunk.contains(chunk, 6)) // false
+     * Chunk.contains(chunk, 3) // => true
+     * Chunk.contains(chunk, 6) // => false
      *
      * // Works with strings
      * const words = Chunk.make("apple", "banana", "cherry")
-     * console.log(Chunk.contains(words, "banana")) // true
-     * console.log(Chunk.contains(words, "grape")) // false
+     * Chunk.contains(words, "banana") // => true
+     * Chunk.contains(words, "grape") // => false
      *
      * // Empty chunk
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.contains(empty, 1)) // false
+     * Chunk.contains(Chunk.empty<number>(), 1) // => false
      * ```
      *
-     * @category elements
+     * @category predicates
      * @since 2.0.0
      */
     <A>(a: A): (self: Chunk<A>) => boolean;
@@ -4054,24 +3826,23 @@ export declare const contains: {
      *
      * **Example** (Checking membership)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.contains(chunk, 3)) // true
-     * console.log(Chunk.contains(chunk, 6)) // false
+     * Chunk.contains(chunk, 3) // => true
+     * Chunk.contains(chunk, 6) // => false
      *
      * // Works with strings
      * const words = Chunk.make("apple", "banana", "cherry")
-     * console.log(Chunk.contains(words, "banana")) // true
-     * console.log(Chunk.contains(words, "grape")) // false
+     * Chunk.contains(words, "banana") // => true
+     * Chunk.contains(words, "grape") // => false
      *
      * // Empty chunk
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.contains(empty, 1)) // false
+     * Chunk.contains(Chunk.empty<number>(), 1) // => false
      * ```
      *
-     * @category elements
+     * @category predicates
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, a: A): boolean;
@@ -4081,7 +3852,7 @@ export declare const contains: {
  *
  * **Example** (Checking membership with custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make({ id: 1, name: "Alice" }, { id: 2, name: "Bob" })
@@ -4090,19 +3861,19 @@ export declare const contains: {
  * const containsById = Chunk.containsWith<{ id: number; name: string }>((a, b) =>
  *   a.id === b.id
  * )
- * console.log(containsById(chunk, { id: 1, name: "Different" })) // true
- * console.log(containsById(chunk, { id: 3, name: "Charlie" })) // false
+ * containsById(chunk, { id: 1, name: "Different" }) // => true
+ * containsById(chunk, { id: 3, name: "Charlie" }) // => false
  *
  * // Case-insensitive string comparison
  * const words = Chunk.make("Apple", "Banana", "Cherry")
  * const containsCaseInsensitive = Chunk.containsWith<string>((a, b) =>
  *   a.toLowerCase() === b.toLowerCase()
  * )
- * console.log(containsCaseInsensitive(words, "apple")) // true
- * console.log(containsCaseInsensitive(words, "grape")) // false
+ * containsCaseInsensitive(words, "apple") // => true
+ * containsCaseInsensitive(words, "grape") // => false
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boolean) => {
@@ -4115,17 +3886,14 @@ export declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boole
  *
  * **Example** (Finding the first matching element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.findFirst(chunk, (n) => n > 3)
- * console.log(Option.isSome(result)) // true
- * console.log(Option.getOrElse(result, () => 0)) // 4
+ * Chunk.findFirst(chunk, (n) => n > 3) // => Option.some(4)
  *
  * // No match found
- * const notFound = Chunk.findFirst(chunk, (n) => n > 10)
- * console.log(Option.isNone(notFound)) // true
+ * Chunk.findFirst(chunk, (n) => n > 10) // => Option.none()
  *
  * // With type refinement
  * const mixed = Chunk.make(1, "hello", 2, "world", 3)
@@ -4133,10 +3901,10 @@ export declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boole
  *   mixed,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(Option.getOrElse(firstString, () => "")) // "hello"
+ * firstString // => Option.some("hello")
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export declare const findFirst: {
@@ -4146,17 +3914,14 @@ export declare const findFirst: {
      *
      * **Example** (Finding the first matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirst(chunk, (n) => n > 3)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 4
+     * Chunk.findFirst(chunk, (n) => n > 3) // => Option.some(4)
      *
      * // No match found
-     * const notFound = Chunk.findFirst(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findFirst(chunk, (n) => n > 10) // => Option.none()
      *
      * // With type refinement
      * const mixed = Chunk.make(1, "hello", 2, "world", 3)
@@ -4164,10 +3929,10 @@ export declare const findFirst: {
      *   mixed,
      *   (x): x is string => typeof x === "string"
      * )
-     * console.log(Option.getOrElse(firstString, () => "")) // "hello"
+     * firstString // => Option.some("hello")
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
@@ -4177,17 +3942,14 @@ export declare const findFirst: {
      *
      * **Example** (Finding the first matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirst(chunk, (n) => n > 3)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 4
+     * Chunk.findFirst(chunk, (n) => n > 3) // => Option.some(4)
      *
      * // No match found
-     * const notFound = Chunk.findFirst(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findFirst(chunk, (n) => n > 10) // => Option.none()
      *
      * // With type refinement
      * const mixed = Chunk.make(1, "hello", 2, "world", 3)
@@ -4195,10 +3957,10 @@ export declare const findFirst: {
      *   mixed,
      *   (x): x is string => typeof x === "string"
      * )
-     * console.log(Option.getOrElse(firstString, () => "")) // "hello"
+     * firstString // => Option.some("hello")
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
@@ -4208,17 +3970,14 @@ export declare const findFirst: {
      *
      * **Example** (Finding the first matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirst(chunk, (n) => n > 3)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 4
+     * Chunk.findFirst(chunk, (n) => n > 3) // => Option.some(4)
      *
      * // No match found
-     * const notFound = Chunk.findFirst(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findFirst(chunk, (n) => n > 10) // => Option.none()
      *
      * // With type refinement
      * const mixed = Chunk.make(1, "hello", 2, "world", 3)
@@ -4226,10 +3985,10 @@ export declare const findFirst: {
      *   mixed,
      *   (x): x is string => typeof x === "string"
      * )
-     * console.log(Option.getOrElse(firstString, () => "")) // "hello"
+     * firstString // => Option.some("hello")
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
@@ -4239,17 +3998,14 @@ export declare const findFirst: {
      *
      * **Example** (Finding the first matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirst(chunk, (n) => n > 3)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 4
+     * Chunk.findFirst(chunk, (n) => n > 3) // => Option.some(4)
      *
      * // No match found
-     * const notFound = Chunk.findFirst(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findFirst(chunk, (n) => n > 10) // => Option.none()
      *
      * // With type refinement
      * const mixed = Chunk.make(1, "hello", 2, "world", 3)
@@ -4257,10 +4013,10 @@ export declare const findFirst: {
      *   mixed,
      *   (x): x is string => typeof x === "string"
      * )
-     * console.log(Option.getOrElse(firstString, () => "")) // "hello"
+     * firstString // => Option.some("hello")
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
@@ -4270,23 +4026,20 @@ export declare const findFirst: {
  *
  * **Example** (Finding the first matching index)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
- * console.log(result) // Option.some(3)
+ * Chunk.findFirstIndex(chunk, (n) => n > 3) // => Option.some(3)
  *
  * // No match found
- * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
- * console.log(notFound) // Option.none()
+ * Chunk.findFirstIndex(chunk, (n) => n > 10) // => Option.none()
  *
  * // Find first even number
- * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
- * console.log(firstEven) // Option.some(1)
+ * Chunk.findFirstIndex(chunk, (n) => n % 2 === 0) // => Option.some(1)
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export declare const findFirstIndex: {
@@ -4295,23 +4048,20 @@ export declare const findFirstIndex: {
      *
      * **Example** (Finding the first matching index)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-     * console.log(result) // Option.some(3)
+     * Chunk.findFirstIndex(chunk, (n) => n > 3) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // Option.none()
+     * Chunk.findFirstIndex(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find first even number
-     * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-     * console.log(firstEven) // Option.some(1)
+     * Chunk.findFirstIndex(chunk, (n) => n % 2 === 0) // => Option.some(1)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>;
@@ -4320,23 +4070,20 @@ export declare const findFirstIndex: {
      *
      * **Example** (Finding the first matching index)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-     * console.log(result) // Option.some(3)
+     * Chunk.findFirstIndex(chunk, (n) => n > 3) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // Option.none()
+     * Chunk.findFirstIndex(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find first even number
-     * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-     * console.log(firstEven) // Option.some(1)
+     * Chunk.findFirstIndex(chunk, (n) => n % 2 === 0) // => Option.some(1)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>;
@@ -4346,24 +4093,20 @@ export declare const findFirstIndex: {
  *
  * **Example** (Finding the last matching element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.findLast(chunk, (n) => n < 4)
- * console.log(Option.isSome(result)) // true
- * console.log(Option.getOrElse(result, () => 0)) // 3
+ * Chunk.findLast(chunk, (n) => n < 4) // => Option.some(3)
  *
  * // No match found
- * const notFound = Chunk.findLast(chunk, (n) => n > 10)
- * console.log(Option.isNone(notFound)) // true
+ * Chunk.findLast(chunk, (n) => n > 10) // => Option.none()
  *
  * // Find last even number
- * const lastEven = Chunk.findLast(chunk, (n) => n % 2 === 0)
- * console.log(Option.getOrElse(lastEven, () => 0)) // 4
+ * Chunk.findLast(chunk, (n) => n % 2 === 0) // => Option.some(4)
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export declare const findLast: {
@@ -4372,24 +4115,20 @@ export declare const findLast: {
      *
      * **Example** (Finding the last matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLast(chunk, (n) => n < 4)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 3
+     * Chunk.findLast(chunk, (n) => n < 4) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findLast(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findLast(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number
-     * const lastEven = Chunk.findLast(chunk, (n) => n % 2 === 0)
-     * console.log(Option.getOrElse(lastEven, () => 0)) // 4
+     * Chunk.findLast(chunk, (n) => n % 2 === 0) // => Option.some(4)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
@@ -4398,24 +4137,20 @@ export declare const findLast: {
      *
      * **Example** (Finding the last matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLast(chunk, (n) => n < 4)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 3
+     * Chunk.findLast(chunk, (n) => n < 4) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findLast(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findLast(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number
-     * const lastEven = Chunk.findLast(chunk, (n) => n % 2 === 0)
-     * console.log(Option.getOrElse(lastEven, () => 0)) // 4
+     * Chunk.findLast(chunk, (n) => n % 2 === 0) // => Option.some(4)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
@@ -4424,24 +4159,20 @@ export declare const findLast: {
      *
      * **Example** (Finding the last matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLast(chunk, (n) => n < 4)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 3
+     * Chunk.findLast(chunk, (n) => n < 4) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findLast(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findLast(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number
-     * const lastEven = Chunk.findLast(chunk, (n) => n % 2 === 0)
-     * console.log(Option.getOrElse(lastEven, () => 0)) // 4
+     * Chunk.findLast(chunk, (n) => n % 2 === 0) // => Option.some(4)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
@@ -4450,24 +4181,20 @@ export declare const findLast: {
      *
      * **Example** (Finding the last matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLast(chunk, (n) => n < 4)
-     * console.log(Option.isSome(result)) // true
-     * console.log(Option.getOrElse(result, () => 0)) // 3
+     * Chunk.findLast(chunk, (n) => n < 4) // => Option.some(3)
      *
      * // No match found
-     * const notFound = Chunk.findLast(chunk, (n) => n > 10)
-     * console.log(Option.isNone(notFound)) // true
+     * Chunk.findLast(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number
-     * const lastEven = Chunk.findLast(chunk, (n) => n % 2 === 0)
-     * console.log(Option.getOrElse(lastEven, () => 0)) // 4
+     * Chunk.findLast(chunk, (n) => n % 2 === 0) // => Option.some(4)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
@@ -4477,23 +4204,20 @@ export declare const findLast: {
  *
  * **Example** (Finding the last matching index)
  *
- * ```ts
- * import { Chunk } from "effect"
+ * ```ts import.meta.vitest
+ * import { Chunk, Option } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
- * console.log(result) // Option.some(2)
+ * Chunk.findLastIndex(chunk, (n) => n < 4) // => Option.some(2)
  *
  * // No match found
- * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
- * console.log(notFound) // Option.none()
+ * Chunk.findLastIndex(chunk, (n) => n > 10) // => Option.none()
  *
  * // Find last even number index
- * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
- * console.log(lastEven) // Option.some(3)
+ * Chunk.findLastIndex(chunk, (n) => n % 2 === 0) // => Option.some(3)
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export declare const findLastIndex: {
@@ -4502,23 +4226,20 @@ export declare const findLastIndex: {
      *
      * **Example** (Finding the last matching index)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-     * console.log(result) // Option.some(2)
+     * Chunk.findLastIndex(chunk, (n) => n < 4) // => Option.some(2)
      *
      * // No match found
-     * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // Option.none()
+     * Chunk.findLastIndex(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number index
-     * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-     * console.log(lastEven) // Option.some(3)
+     * Chunk.findLastIndex(chunk, (n) => n % 2 === 0) // => Option.some(3)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>;
@@ -4527,23 +4248,20 @@ export declare const findLastIndex: {
      *
      * **Example** (Finding the last matching index)
      *
-     * ```ts
-     * import { Chunk } from "effect"
+     * ```ts import.meta.vitest
+     * import { Chunk, Option } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-     * console.log(result) // Option.some(2)
+     * Chunk.findLastIndex(chunk, (n) => n < 4) // => Option.some(2)
      *
      * // No match found
-     * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // Option.none()
+     * Chunk.findLastIndex(chunk, (n) => n > 10) // => Option.none()
      *
      * // Find last even number index
-     * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-     * console.log(lastEven) // Option.some(3)
+     * Chunk.findLastIndex(chunk, (n) => n % 2 === 0) // => Option.some(3)
      * ```
      *
-     * @category elements
+     * @category searching
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>;
@@ -4553,26 +4271,24 @@ export declare const findLastIndex: {
  *
  * **Example** (Checking every element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const allPositive = Chunk.make(1, 2, 3, 4, 5)
- * console.log(Chunk.every(allPositive, (n) => n > 0)) // true
- * console.log(Chunk.every(allPositive, (n) => n > 3)) // false
+ * Chunk.every(allPositive, (n) => n > 0) // => true
+ * Chunk.every(allPositive, (n) => n > 3) // => false
  *
  * // Empty chunk returns true
- * const empty = Chunk.empty<number>()
- * console.log(Chunk.every(empty, (n) => n > 0)) // true
+ * Chunk.every(Chunk.empty<number>(), (n) => n > 0) // => true
  *
  * // Type refinement
  * const mixed = Chunk.make(1, 2, 3)
  * if (Chunk.every(mixed, (x): x is number => typeof x === "number")) {
  *   // mixed is now typed as Chunk<number>
- *   console.log("All elements are numbers")
  * }
  * ```
  *
- * @category elements
+ * @category guards
  * @since 2.0.0
  */
 export declare const every: {
@@ -4581,26 +4297,24 @@ export declare const every: {
      *
      * **Example** (Checking every element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const allPositive = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.every(allPositive, (n) => n > 0)) // true
-     * console.log(Chunk.every(allPositive, (n) => n > 3)) // false
+     * Chunk.every(allPositive, (n) => n > 0) // => true
+     * Chunk.every(allPositive, (n) => n > 3) // => false
      *
      * // Empty chunk returns true
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.every(empty, (n) => n > 0)) // true
+     * Chunk.every(Chunk.empty<number>(), (n) => n > 0) // => true
      *
      * // Type refinement
      * const mixed = Chunk.make(1, 2, 3)
      * if (Chunk.every(mixed, (x): x is number => typeof x === "number")) {
      *   // mixed is now typed as Chunk<number>
-     *   console.log("All elements are numbers")
      * }
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => self is Chunk<B>;
@@ -4609,26 +4323,24 @@ export declare const every: {
      *
      * **Example** (Checking every element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const allPositive = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.every(allPositive, (n) => n > 0)) // true
-     * console.log(Chunk.every(allPositive, (n) => n > 3)) // false
+     * Chunk.every(allPositive, (n) => n > 0) // => true
+     * Chunk.every(allPositive, (n) => n > 3) // => false
      *
      * // Empty chunk returns true
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.every(empty, (n) => n > 0)) // true
+     * Chunk.every(Chunk.empty<number>(), (n) => n > 0) // => true
      *
      * // Type refinement
      * const mixed = Chunk.make(1, 2, 3)
      * if (Chunk.every(mixed, (x): x is number => typeof x === "number")) {
      *   // mixed is now typed as Chunk<number>
-     *   console.log("All elements are numbers")
      * }
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => boolean;
@@ -4637,26 +4349,24 @@ export declare const every: {
      *
      * **Example** (Checking every element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const allPositive = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.every(allPositive, (n) => n > 0)) // true
-     * console.log(Chunk.every(allPositive, (n) => n > 3)) // false
+     * Chunk.every(allPositive, (n) => n > 0) // => true
+     * Chunk.every(allPositive, (n) => n > 3) // => false
      *
      * // Empty chunk returns true
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.every(empty, (n) => n > 0)) // true
+     * Chunk.every(Chunk.empty<number>(), (n) => n > 0) // => true
      *
      * // Type refinement
      * const mixed = Chunk.make(1, 2, 3)
      * if (Chunk.every(mixed, (x): x is number => typeof x === "number")) {
      *   // mixed is now typed as Chunk<number>
-     *   console.log("All elements are numbers")
      * }
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): self is Chunk<B>;
@@ -4665,26 +4375,24 @@ export declare const every: {
      *
      * **Example** (Checking every element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const allPositive = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.every(allPositive, (n) => n > 0)) // true
-     * console.log(Chunk.every(allPositive, (n) => n > 3)) // false
+     * Chunk.every(allPositive, (n) => n > 0) // => true
+     * Chunk.every(allPositive, (n) => n > 3) // => false
      *
      * // Empty chunk returns true
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.every(empty, (n) => n > 0)) // true
+     * Chunk.every(Chunk.empty<number>(), (n) => n > 0) // => true
      *
      * // Type refinement
      * const mixed = Chunk.make(1, 2, 3)
      * if (Chunk.every(mixed, (x): x is number => typeof x === "number")) {
      *   // mixed is now typed as Chunk<number>
-     *   console.log("All elements are numbers")
      * }
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): boolean;
@@ -4694,23 +4402,22 @@ export declare const every: {
  *
  * **Example** (Checking for some matching element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * console.log(Chunk.some(chunk, (n) => n > 4)) // true
- * console.log(Chunk.some(chunk, (n) => n > 10)) // false
+ * Chunk.some(chunk, (n) => n > 4) // => true
+ * Chunk.some(chunk, (n) => n > 10) // => false
  *
  * // Empty chunk returns false
- * const empty = Chunk.empty<number>()
- * console.log(Chunk.some(empty, (n) => n > 0)) // false
+ * Chunk.some(Chunk.empty<number>(), (n) => n > 0) // => false
  *
  * // Check for specific value
  * const words = Chunk.make("apple", "banana", "cherry")
- * console.log(Chunk.some(words, (word) => word.includes("ban"))) // true
+ * Chunk.some(words, (word) => word.includes("ban")) // => true
  * ```
  *
- * @category elements
+ * @category guards
  * @since 2.0.0
  */
 export declare const some: {
@@ -4719,23 +4426,22 @@ export declare const some: {
      *
      * **Example** (Checking for some matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.some(chunk, (n) => n > 4)) // true
-     * console.log(Chunk.some(chunk, (n) => n > 10)) // false
+     * Chunk.some(chunk, (n) => n > 4) // => true
+     * Chunk.some(chunk, (n) => n > 10) // => false
      *
      * // Empty chunk returns false
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.some(empty, (n) => n > 0)) // false
+     * Chunk.some(Chunk.empty<number>(), (n) => n > 0) // => false
      *
      * // Check for specific value
      * const words = Chunk.make("apple", "banana", "cherry")
-     * console.log(Chunk.some(words, (word) => word.includes("ban"))) // true
+     * Chunk.some(words, (word) => word.includes("ban")) // => true
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => self is NonEmptyChunk<A>;
@@ -4744,23 +4450,22 @@ export declare const some: {
      *
      * **Example** (Checking for some matching element)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * console.log(Chunk.some(chunk, (n) => n > 4)) // true
-     * console.log(Chunk.some(chunk, (n) => n > 10)) // false
+     * Chunk.some(chunk, (n) => n > 4) // => true
+     * Chunk.some(chunk, (n) => n > 10) // => false
      *
      * // Empty chunk returns false
-     * const empty = Chunk.empty<number>()
-     * console.log(Chunk.some(empty, (n) => n > 0)) // false
+     * Chunk.some(Chunk.empty<number>(), (n) => n > 0) // => false
      *
      * // Check for specific value
      * const words = Chunk.make("apple", "banana", "cherry")
-     * console.log(Chunk.some(words, (word) => word.includes("ban"))) // true
+     * Chunk.some(words, (word) => word.includes("ban")) // => true
      * ```
      *
-     * @category elements
+     * @category guards
      * @since 2.0.0
      */
     <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A>;
@@ -4770,24 +4475,20 @@ export declare const some: {
  *
  * **Example** (Joining chunks into a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make("apple", "banana", "cherry")
- * const result = Chunk.join(chunk, ", ")
- * console.log(result) // "apple, banana, cherry"
+ * Chunk.join(chunk, ", ") // => "apple, banana, cherry"
  *
  * // With different separator
- * const withPipe = Chunk.join(chunk, " | ")
- * console.log(withPipe) // "apple | banana | cherry"
+ * Chunk.join(chunk, " | ") // => "apple | banana | cherry"
  *
  * // Empty chunk
- * const empty = Chunk.empty<string>()
- * console.log(Chunk.join(empty, ", ")) // ""
+ * Chunk.join(Chunk.empty<string>(), ", ") // => ""
  *
  * // Single element
- * const single = Chunk.make("hello")
- * console.log(Chunk.join(single, ", ")) // "hello"
+ * Chunk.join(Chunk.make("hello"), ", ") // => "hello"
  * ```
  *
  * @category folding
@@ -4799,24 +4500,20 @@ export declare const join: {
      *
      * **Example** (Joining chunks into a string)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make("apple", "banana", "cherry")
-     * const result = Chunk.join(chunk, ", ")
-     * console.log(result) // "apple, banana, cherry"
+     * Chunk.join(chunk, ", ") // => "apple, banana, cherry"
      *
      * // With different separator
-     * const withPipe = Chunk.join(chunk, " | ")
-     * console.log(withPipe) // "apple | banana | cherry"
+     * Chunk.join(chunk, " | ") // => "apple | banana | cherry"
      *
      * // Empty chunk
-     * const empty = Chunk.empty<string>()
-     * console.log(Chunk.join(empty, ", ")) // ""
+     * Chunk.join(Chunk.empty<string>(), ", ") // => ""
      *
      * // Single element
-     * const single = Chunk.make("hello")
-     * console.log(Chunk.join(single, ", ")) // "hello"
+     * Chunk.join(Chunk.make("hello"), ", ") // => "hello"
      * ```
      *
      * @category folding
@@ -4828,24 +4525,20 @@ export declare const join: {
      *
      * **Example** (Joining chunks into a string)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make("apple", "banana", "cherry")
-     * const result = Chunk.join(chunk, ", ")
-     * console.log(result) // "apple, banana, cherry"
+     * Chunk.join(chunk, ", ") // => "apple, banana, cherry"
      *
      * // With different separator
-     * const withPipe = Chunk.join(chunk, " | ")
-     * console.log(withPipe) // "apple | banana | cherry"
+     * Chunk.join(chunk, " | ") // => "apple | banana | cherry"
      *
      * // Empty chunk
-     * const empty = Chunk.empty<string>()
-     * console.log(Chunk.join(empty, ", ")) // ""
+     * Chunk.join(Chunk.empty<string>(), ", ") // => ""
      *
      * // Single element
-     * const single = Chunk.make("hello")
-     * console.log(Chunk.join(single, ", ")) // "hello"
+     * Chunk.join(Chunk.make("hello"), ", ") // => "hello"
      * ```
      *
      * @category folding
@@ -4858,21 +4551,18 @@ export declare const join: {
  *
  * **Example** (Reducing from the left)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
- * const sum = Chunk.reduce(chunk, 0, (acc, n) => acc + n)
- * console.log(sum) // 15
+ * Chunk.reduce(chunk, 0, (acc, n) => acc + n) // => 15
  *
  * // String concatenation with index
  * const words = Chunk.make("a", "b", "c")
- * const result = Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `)
- * console.log(result) // "0:a 1:b 2:c "
+ * Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `).trimEnd() // => "0:a 1:b 2:c"
  *
  * // Find maximum
- * const max = Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n))
- * console.log(max) // 5
+ * Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n)) // => 5
  * ```
  *
  * @category folding
@@ -4884,21 +4574,18 @@ export declare const reduce: {
      *
      * **Example** (Reducing from the left)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const sum = Chunk.reduce(chunk, 0, (acc, n) => acc + n)
-     * console.log(sum) // 15
+     * Chunk.reduce(chunk, 0, (acc, n) => acc + n) // => 15
      *
      * // String concatenation with index
      * const words = Chunk.make("a", "b", "c")
-     * const result = Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `)
-     * console.log(result) // "0:a 1:b 2:c "
+     * Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `).trimEnd() // => "0:a 1:b 2:c"
      *
      * // Find maximum
-     * const max = Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n))
-     * console.log(max) // 5
+     * Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n)) // => 5
      * ```
      *
      * @category folding
@@ -4910,21 +4597,18 @@ export declare const reduce: {
      *
      * **Example** (Reducing from the left)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
-     * const sum = Chunk.reduce(chunk, 0, (acc, n) => acc + n)
-     * console.log(sum) // 15
+     * Chunk.reduce(chunk, 0, (acc, n) => acc + n) // => 15
      *
      * // String concatenation with index
      * const words = Chunk.make("a", "b", "c")
-     * const result = Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `)
-     * console.log(result) // "0:a 1:b 2:c "
+     * Chunk.reduce(words, "", (acc, word, i) => acc + `${i}:${word} `).trimEnd() // => "0:a 1:b 2:c"
      *
      * // Find maximum
-     * const max = Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n))
-     * console.log(max) // 5
+     * Chunk.reduce(chunk, -Infinity, (acc, n) => Math.max(acc, n)) // => 5
      * ```
      *
      * @category folding
@@ -4937,25 +4621,22 @@ export declare const reduce: {
  *
  * **Example** (Reducing from the right)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
- * const result = Chunk.reduceRight(chunk, 0, (acc, n) => acc + n)
- * console.log(result) // 10
+ * Chunk.reduceRight(chunk, 0, (acc, n) => acc + n) // => 10
  *
  * // String building (right to left)
  * const words = Chunk.make("a", "b", "c")
- * const reversed = Chunk.reduceRight(
+ * Chunk.reduceRight(
  *   words,
  *   "",
  *   (acc, word, i) => acc + `${i}:${word} `
- * )
- * console.log(reversed) // "2:c 1:b 0:a "
+ * ).trim() // => "2:c 1:b 0:a"
  *
  * // Subtract from right to left
- * const subtraction = Chunk.reduceRight(chunk, 0, (acc, n) => n - acc)
- * console.log(subtraction) // -2 (4 - (3 - (2 - (1 - 0))))
+ * Chunk.reduceRight(chunk, 0, (acc, n) => n - acc) // => -2
  * ```
  *
  * @category folding
@@ -4967,25 +4648,22 @@ export declare const reduceRight: {
      *
      * **Example** (Reducing from the right)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
-     * const result = Chunk.reduceRight(chunk, 0, (acc, n) => acc + n)
-     * console.log(result) // 10
+     * Chunk.reduceRight(chunk, 0, (acc, n) => acc + n) // => 10
      *
      * // String building (right to left)
      * const words = Chunk.make("a", "b", "c")
-     * const reversed = Chunk.reduceRight(
+     * Chunk.reduceRight(
      *   words,
      *   "",
      *   (acc, word, i) => acc + `${i}:${word} `
-     * )
-     * console.log(reversed) // "2:c 1:b 0:a "
+     * ).trim() // => "2:c 1:b 0:a"
      *
      * // Subtract from right to left
-     * const subtraction = Chunk.reduceRight(chunk, 0, (acc, n) => n - acc)
-     * console.log(subtraction) // -2 (4 - (3 - (2 - (1 - 0))))
+     * Chunk.reduceRight(chunk, 0, (acc, n) => n - acc) // => -2
      * ```
      *
      * @category folding
@@ -4997,25 +4675,22 @@ export declare const reduceRight: {
      *
      * **Example** (Reducing from the right)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
-     * const result = Chunk.reduceRight(chunk, 0, (acc, n) => acc + n)
-     * console.log(result) // 10
+     * Chunk.reduceRight(chunk, 0, (acc, n) => acc + n) // => 10
      *
      * // String building (right to left)
      * const words = Chunk.make("a", "b", "c")
-     * const reversed = Chunk.reduceRight(
+     * Chunk.reduceRight(
      *   words,
      *   "",
      *   (acc, word, i) => acc + `${i}:${word} `
-     * )
-     * console.log(reversed) // "2:c 1:b 0:a "
+     * ).trim() // => "2:c 1:b 0:a"
      *
      * // Subtract from right to left
-     * const subtraction = Chunk.reduceRight(chunk, 0, (acc, n) => n - acc)
-     * console.log(subtraction) // -2 (4 - (3 - (2 - (1 - 0))))
+     * Chunk.reduceRight(chunk, 0, (acc, n) => n - acc) // => -2
      * ```
      *
      * @category folding
@@ -5029,7 +4704,7 @@ export declare const reduceRight: {
  *
  * **Example** (Computing difference with custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk1 = Chunk.make({ id: 1, name: "Alice" }, { id: 2, name: "Bob" })
@@ -5039,8 +4714,7 @@ export declare const reduceRight: {
  * const byId = Chunk.differenceWith<{ id: number; name: string }>((a, b) =>
  *   a.id === b.id
  * )
- * const result = byId(chunk1, chunk2)
- * console.log(Chunk.toArray(result)) // [{ id: 2, name: "Bob" }]
+ * Chunk.toArray(byId(chunk1, chunk2)) // => [{ id: 2, name: "Bob" }]
  *
  * // String comparison case-insensitive
  * const words1 = Chunk.make("Apple", "Banana", "Cherry")
@@ -5048,8 +4722,7 @@ export declare const reduceRight: {
  * const caseInsensitive = Chunk.differenceWith<string>((a, b) =>
  *   a.toLowerCase() === b.toLowerCase()
  * )
- * const wordDiff = caseInsensitive(words1, words2)
- * console.log(Chunk.toArray(wordDiff)) // ["Banana", "Cherry"]
+ * Chunk.toArray(caseInsensitive(words1, words2)) // => ["Banana", "Cherry"]
  * ```
  *
  * @category filtering
@@ -5065,24 +4738,20 @@ export declare const differenceWith: <A>(isEquivalent: (self: A, that: A) => boo
  *
  * **Example** (Computing chunk difference)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const chunk1 = Chunk.make(1, 2, 3, 4, 5)
  * const chunk2 = Chunk.make(3, 4, 6, 7)
- * const result = Chunk.difference(chunk1, chunk2)
- * console.log(Chunk.toArray(result)) // [1, 2, 5]
+ * Chunk.toArray(Chunk.difference(chunk1, chunk2)) // => [1, 2, 5]
  *
  * // String difference
  * const words1 = Chunk.make("apple", "banana", "cherry")
  * const words2 = Chunk.make("banana", "grape")
- * const wordDiff = Chunk.difference(words1, words2)
- * console.log(Chunk.toArray(wordDiff)) // ["apple", "cherry"]
+ * Chunk.toArray(Chunk.difference(words1, words2)) // => ["apple", "cherry"]
  *
  * // Empty second chunk returns original
- * const empty = Chunk.empty<number>()
- * const unchanged = Chunk.difference(chunk1, empty)
- * console.log(Chunk.toArray(unchanged)) // [1, 2, 3, 4, 5]
+ * Chunk.toArray(Chunk.difference(chunk1, Chunk.empty<number>())) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category filtering
@@ -5095,24 +4764,20 @@ export declare const difference: {
      *
      * **Example** (Computing chunk difference)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3, 4, 5)
      * const chunk2 = Chunk.make(3, 4, 6, 7)
-     * const result = Chunk.difference(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 5]
+     * Chunk.toArray(Chunk.difference(chunk1, chunk2)) // => [1, 2, 5]
      *
      * // String difference
      * const words1 = Chunk.make("apple", "banana", "cherry")
      * const words2 = Chunk.make("banana", "grape")
-     * const wordDiff = Chunk.difference(words1, words2)
-     * console.log(Chunk.toArray(wordDiff)) // ["apple", "cherry"]
+     * Chunk.toArray(Chunk.difference(words1, words2)) // => ["apple", "cherry"]
      *
      * // Empty second chunk returns original
-     * const empty = Chunk.empty<number>()
-     * const unchanged = Chunk.difference(chunk1, empty)
-     * console.log(Chunk.toArray(unchanged)) // [1, 2, 3, 4, 5]
+     * Chunk.toArray(Chunk.difference(chunk1, Chunk.empty<number>())) // => [1, 2, 3, 4, 5]
      * ```
      *
      * @category filtering
@@ -5125,24 +4790,20 @@ export declare const difference: {
      *
      * **Example** (Computing chunk difference)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Chunk } from "effect"
      *
      * const chunk1 = Chunk.make(1, 2, 3, 4, 5)
      * const chunk2 = Chunk.make(3, 4, 6, 7)
-     * const result = Chunk.difference(chunk1, chunk2)
-     * console.log(Chunk.toArray(result)) // [1, 2, 5]
+     * Chunk.toArray(Chunk.difference(chunk1, chunk2)) // => [1, 2, 5]
      *
      * // String difference
      * const words1 = Chunk.make("apple", "banana", "cherry")
      * const words2 = Chunk.make("banana", "grape")
-     * const wordDiff = Chunk.difference(words1, words2)
-     * console.log(Chunk.toArray(wordDiff)) // ["apple", "cherry"]
+     * Chunk.toArray(Chunk.difference(words1, words2)) // => ["apple", "cherry"]
      *
      * // Empty second chunk returns original
-     * const empty = Chunk.empty<number>()
-     * const unchanged = Chunk.difference(chunk1, empty)
-     * console.log(Chunk.toArray(unchanged)) // [1, 2, 3, 4, 5]
+     * Chunk.toArray(Chunk.difference(chunk1, Chunk.empty<number>())) // => [1, 2, 3, 4, 5]
      * ```
      *
      * @category filtering