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

package/src/Chunk.ts

@@ -37,12 +37,12 @@ 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
@@ -64,12 +64,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
@@ -82,7 +82,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
@@ -90,7 +90,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 {
@@ -152,7 +152,7 @@ const emptyArray: ReadonlyArray<never> = []
  *
  * **Example** (Comparing chunks for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Equivalence } from "effect"
  *
  * const chunk1 = Chunk.make(1, 2, 3)
@@ -160,8 +160,8 @@ const emptyArray: ReadonlyArray<never> = []
  * 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
@@ -262,18 +262,18 @@ const makeChunk = <A>(backing: Backing<A>): Chunk<A> => {
  *
  * **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 const isChunk: {
@@ -282,18 +282,18 @@ export 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>
@@ -302,18 +302,18 @@ export 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>
@@ -326,11 +326,10 @@ const _empty = makeChunk<never>({ _tag: "IEmpty" })
  *
  * **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
@@ -343,11 +342,10 @@ export const empty: <A = never>() => Chunk<A> = () => _empty
  *
  * **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
@@ -361,11 +359,10 @@ export const make = <As extends readonly [any, ...Array<any>]>(...as: As): NonEm
  *
  * **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
@@ -378,11 +375,10 @@ export const of = <A>(a: A): NonEmptyChunk<A> => makeChunk({ _tag: "ISingleton",
  *
  * **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
@@ -428,17 +424,16 @@ const toArray_ = <A>(self: Chunk<A>): Array<A> => toReadonlyArray(self).slice()
  *
  * **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
@@ -478,19 +473,18 @@ const toReadonlyArray_ = <A>(self: Chunk<A>): ReadonlyArray<A> => {
  *
  * **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
@@ -531,16 +525,14 @@ const reverseChunk = <A>(self: Chunk<A>): Chunk<A> => {
  *
  * **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 const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Infer<S>> = reverseChunk as any
@@ -551,21 +543,20 @@ export const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, Chunk.Inf
  *
  * **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 const get: {
@@ -575,21 +566,20 @@ export 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>
@@ -599,21 +589,20 @@ export 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>
@@ -637,16 +626,16 @@ export 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
@@ -669,15 +658,15 @@ export 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
@@ -700,16 +689,16 @@ export const fromNonEmptyArrayUnsafe = <A>(self: NonEmptyReadonlyArray<A>): NonE
  *
  * **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
@@ -730,16 +719,16 @@ export 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
@@ -760,16 +749,16 @@ export 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
@@ -815,17 +804,15 @@ export 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
@@ -845,17 +832,15 @@ export 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
@@ -875,17 +860,15 @@ export 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
@@ -902,17 +885,15 @@ export 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
@@ -924,17 +905,15 @@ export 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
@@ -946,17 +925,15 @@ export 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
@@ -970,15 +947,14 @@ export 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 const take: {
@@ -987,15 +963,14 @@ export 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>
@@ -1004,19 +979,19 @@ export 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>
-} = dual(2, <A>(self: Chunk<A>, n: number): Chunk<A> => {
+} = dual(2, <A>(self: Chunk<A>, _n: number): Chunk<A> => {
+  const n = Math.floor(_n)
   if (n <= 0) {
     return _empty
   } else if (n >= self.length) {
@@ -1059,15 +1034,14 @@ export 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 const drop: {
@@ -1076,15 +1050,14 @@ export 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>
@@ -1093,19 +1066,19 @@ export 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>
-} = dual(2, <A>(self: Chunk<A>, n: number): Chunk<A> => {
+} = dual(2, <A>(self: Chunk<A>, _n: number): Chunk<A> => {
+  const n = Math.floor(_n)
   if (n <= 0) {
     return self
   } else if (n >= self.length) {
@@ -1147,15 +1120,14 @@ export 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 const dropRight: {
@@ -1164,15 +1136,14 @@ export 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>
@@ -1181,15 +1152,14 @@ export 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>
@@ -1200,15 +1170,14 @@ export 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 const dropWhile: {
@@ -1217,15 +1186,14 @@ export 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>
@@ -1234,15 +1202,14 @@ export 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>
@@ -1262,16 +1229,13 @@ export 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
@@ -1284,16 +1248,13 @@ export 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
@@ -1306,16 +1267,13 @@ export 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
@@ -1328,16 +1286,13 @@ export 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
@@ -1350,16 +1305,13 @@ export 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
@@ -1379,16 +1331,13 @@ export 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
@@ -1409,16 +1358,13 @@ export 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
@@ -1439,16 +1385,13 @@ export 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
@@ -1469,16 +1412,13 @@ export 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
@@ -1499,16 +1439,13 @@ export 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
@@ -1538,16 +1475,13 @@ export 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
@@ -1593,7 +1527,7 @@ export 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")
@@ -1601,14 +1535,14 @@ export 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
@@ -1620,7 +1554,7 @@ export 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")
@@ -1628,14 +1562,14 @@ export 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
@@ -1647,7 +1581,7 @@ export 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")
@@ -1655,14 +1589,14 @@ export 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
@@ -1689,17 +1623,17 @@ export 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
@@ -1711,17 +1645,17 @@ export 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
@@ -1733,17 +1667,17 @@ export 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
@@ -1755,17 +1689,17 @@ export 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
@@ -1777,17 +1711,17 @@ export 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
@@ -1804,23 +1738,19 @@ export 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
@@ -1832,23 +1762,19 @@ export 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
@@ -1860,23 +1786,19 @@ export 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
@@ -1901,12 +1823,11 @@ export 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
@@ -1927,12 +1848,12 @@ export 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")
@@ -1940,11 +1861,11 @@ export 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
@@ -1956,12 +1877,12 @@ export 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")
@@ -1969,11 +1890,11 @@ export 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
@@ -1985,12 +1906,12 @@ export 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")
@@ -1998,11 +1919,11 @@ export 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
@@ -2014,12 +1935,12 @@ export 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")
@@ -2027,11 +1948,11 @@ export 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
@@ -2062,26 +1983,19 @@ export 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
@@ -2100,26 +2014,19 @@ export 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
@@ -2138,26 +2045,19 @@ export 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
@@ -2171,7 +2071,7 @@ export const forEach: {
  *
  * **Example** (Flattening nested chunks)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const nested = Chunk.make(
@@ -2179,8 +2079,7 @@ export 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(
@@ -2188,7 +2087,7 @@ export 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
@@ -2215,25 +2114,23 @@ export const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Flatten<S>
  *
  * **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 const chunksOf: {
@@ -2256,25 +2153,23 @@ export 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>>
@@ -2297,25 +2192,23 @@ export 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>>
@@ -2344,26 +2237,25 @@ export 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 const intersection: {
@@ -2376,26 +2268,25 @@ export 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>
@@ -2408,26 +2299,25 @@ export 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>
@@ -2442,14 +2332,14 @@ export 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 const isEmpty = <A>(self: Chunk<A>): boolean => self.length === 0
@@ -2459,14 +2349,14 @@ export const isEmpty = <A>(self: Chunk<A>): boolean => self.length === 0
  *
  * **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 const isNonEmpty = <A>(self: Chunk<A>): self is NonEmptyChunk<A> => self.length > 0
@@ -2476,14 +2366,14 @@ export const isNonEmpty = <A>(self: Chunk<A>): self is NonEmptyChunk<A> => self.
  *
  * **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 const head: <A>(self: Chunk<A>) => Option<A> = get(0)
@@ -2502,17 +2392,17 @@ export const head: <A>(self: Chunk<A>) => Option<A> = get(0)
  *
  * **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
@@ -2525,20 +2415,20 @@ export const headUnsafe = <A>(self: Chunk<A>): A => getUnsafe(self, 0)
  *
  * **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 const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A = headUnsafe
@@ -2548,14 +2438,14 @@ export const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A = headUnsafe
  *
  * **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 const last = <A>(self: Chunk<A>): Option<A> => get(self, self.length - 1)
@@ -2574,17 +2464,17 @@ export const last = <A>(self: Chunk<A>): Option<A> => get(self, self.length - 1)
  *
  * **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
@@ -2597,20 +2487,20 @@ export const lastUnsafe = <A>(self: Chunk<A>): A => getUnsafe(self, self.length
  *
  * **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 const lastNonEmpty: <A>(self: NonEmptyChunk<A>) => A = lastUnsafe
@@ -2620,7 +2510,7 @@ export const lastNonEmpty: <A>(self: NonEmptyChunk<A>) => A = lastUnsafe
  *
  * **Example** (Working with Chunk utility types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Chunk } from "effect"
  *
  * // Extract the element type from a Chunk
@@ -2640,7 +2530,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>
@@ -2650,7 +2540,7 @@ export declare namespace Chunk {
    * type StringType = Chunk.Chunk.Infer<typeof stringChunk> // string
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 2.0.0
    */
   export type Infer<S extends Chunk<any>> = S extends Chunk<infer A> ? A : never
@@ -2660,7 +2550,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>
@@ -2670,7 +2560,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
    */
   export type With<S extends Chunk<any>, A> = S extends NonEmptyChunk<any> ? NonEmptyChunk<A> : Chunk<A>
@@ -2680,7 +2570,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>
@@ -2703,7 +2593,7 @@ export declare namespace Chunk {
    * > // Chunk.NonEmptyChunk<string>
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 2.0.0
    */
   export type OrNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ?
@@ -2716,7 +2606,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>
@@ -2739,7 +2629,7 @@ export declare namespace Chunk {
    * > // Chunk.NonEmptyChunk<string>
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 2.0.0
    */
   export type AndNonEmpty<S extends Chunk<any>, T extends Chunk<any>, A> = S extends NonEmptyChunk<any> ?
@@ -2752,7 +2642,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>>
@@ -2762,7 +2652,7 @@ export declare namespace Chunk {
    * type Flattened2 = Chunk.Chunk.Flatten<typeof nestedNonEmpty> // Chunk.NonEmptyChunk<string>
    * ```
    *
-   * @category types
+   * @category utility types
    * @since 2.0.0
    */
   export type Flatten<T extends Chunk<Chunk<any>>> = T extends NonEmptyChunk<NonEmptyChunk<infer A>> ? NonEmptyChunk<A>
@@ -2776,12 +2666,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
@@ -2794,12 +2682,10 @@ export 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
@@ -2812,12 +2698,10 @@ export 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
@@ -2830,12 +2714,10 @@ export 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
@@ -2852,7 +2734,7 @@ export 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)
@@ -2861,8 +2743,8 @@ export 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")
@@ -2870,8 +2752,8 @@ export 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
@@ -2883,7 +2765,7 @@ export 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)
@@ -2892,8 +2774,8 @@ export 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")
@@ -2901,8 +2783,8 @@ export 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
@@ -2914,7 +2796,7 @@ export 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)
@@ -2923,8 +2805,8 @@ export 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")
@@ -2932,8 +2814,8 @@ export 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
@@ -2954,15 +2836,15 @@ export 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
@@ -2978,15 +2860,15 @@ export 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
@@ -3002,15 +2884,15 @@ export 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
@@ -3039,7 +2921,7 @@ export const partition: {
  *
  * **Example** (Separating failures and successes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Result } from "effect"
  *
  * const chunk = Chunk.make(
@@ -3051,14 +2933,14 @@ export 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
@@ -3075,14 +2957,13 @@ export const separate = <A, B>(self: Chunk<Result<B, A>>): [Chunk<A>, Chunk<B>]
  *
  * **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 const size = <A>(self: Chunk<A>): number => self.length
@@ -3092,21 +2973,18 @@ export const size = <A>(self: Chunk<A>): number => self.length
  *
  * **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
@@ -3118,21 +2996,18 @@ export 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
@@ -3144,21 +3019,18 @@ export 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
@@ -3175,7 +3047,7 @@ export const sort: {
  *
  * **Example** (Sorting chunks by a derived value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk, Order } from "effect"
  *
  * const people = Chunk.make(
@@ -3186,18 +3058,15 @@ export 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
@@ -3209,7 +3078,7 @@ export const sortWith: {
    *
    * **Example** (Sorting chunks by a derived value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Chunk, Order } from "effect"
    *
    * const people = Chunk.make(
@@ -3220,18 +3089,15 @@ export 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
@@ -3243,7 +3109,7 @@ export const sortWith: {
    *
    * **Example** (Sorting chunks by a derived value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Chunk, Order } from "effect"
    *
    * const people = Chunk.make(
@@ -3254,18 +3120,15 @@ export 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
@@ -3282,23 +3145,23 @@ export 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
@@ -3310,23 +3173,23 @@ export 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
@@ -3338,23 +3201,23 @@ export 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
@@ -3375,18 +3238,18 @@ export 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
@@ -3408,18 +3271,18 @@ export 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
@@ -3441,18 +3304,18 @@ export 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
@@ -3479,24 +3342,21 @@ export 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
@@ -3513,24 +3373,21 @@ export 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
@@ -3547,24 +3404,21 @@ export 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
@@ -3579,23 +3433,23 @@ export 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
@@ -3608,23 +3462,23 @@ export 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
@@ -3637,23 +3491,23 @@ export 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
@@ -3677,20 +3531,19 @@ export 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 const tail = <A>(self: Chunk<A>): O.Option<Chunk<A>> => self.length > 0 ? O.some(drop(self, 1)) : O.none()
@@ -3700,22 +3553,20 @@ export const tail = <A>(self: Chunk<A>): O.Option<Chunk<A>> => self.length > 0 ?
  *
  * **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 const tailNonEmpty = <A>(self: NonEmptyChunk<A>): Chunk<A> => drop(self, 1)
@@ -3725,23 +3576,20 @@ export const tailNonEmpty = <A>(self: NonEmptyChunk<A>): Chunk<A> => drop(self,
  *
  * **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 const takeRight: {
@@ -3750,23 +3598,20 @@ export 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>
@@ -3775,23 +3620,20 @@ export 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>
@@ -3802,24 +3644,21 @@ export 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 const takeWhile: {
@@ -3828,24 +3667,21 @@ export 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>
@@ -3854,24 +3690,21 @@ export 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>
@@ -3880,24 +3713,21 @@ export 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>
@@ -3906,24 +3736,21 @@ export 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>
@@ -3944,22 +3771,20 @@ export 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 const union: {
@@ -3968,22 +3793,20 @@ export 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>
@@ -3992,22 +3815,20 @@ export 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>
@@ -4022,25 +3843,22 @@ export 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 const dedupe = <A>(self: Chunk<A>): Chunk<A> => fromArrayUnsafe(RA.dedupe(toReadonlyArray(self)))
@@ -4050,17 +3868,15 @@ export const dedupe = <A>(self: Chunk<A>): Chunk<A> => fromArrayUnsafe(RA.dedupe
  *
  * **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
@@ -4077,7 +3893,7 @@ export const dedupeAdjacent = <A>(self: Chunk<A>): Chunk<A> => fromArrayUnsafe(R
  *
  * **Example** (Unzipping pairs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Chunk } from "effect"
  *
  * const pairs = Chunk.make(
@@ -4086,17 +3902,17 @@ export const dedupeAdjacent = <A>(self: Chunk<A>): Chunk<A> => fromArrayUnsafe(R
  *   [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 const unzip = <A, B>(self: Chunk<readonly [A, B]>): [Chunk<A>, Chunk<B>] => {
@@ -4109,19 +3925,17 @@ export const unzip = <A, B>(self: Chunk<readonly [A, B]>): [Chunk<A>, Chunk<B>]
  *
  * **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
@@ -4133,19 +3947,17 @@ export 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
@@ -4157,19 +3969,17 @@ export 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
@@ -4187,19 +3997,17 @@ export 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
@@ -4211,19 +4019,17 @@ export 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
@@ -4235,19 +4041,17 @@ export 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
@@ -4264,23 +4068,20 @@ export 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 const remove: {
@@ -4289,23 +4090,20 @@ export 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>
@@ -4314,23 +4112,20 @@ export 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>
@@ -4345,23 +4140,20 @@ export 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 const modify: {
@@ -4371,23 +4163,20 @@ export 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>>
@@ -4397,23 +4186,20 @@ export 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>>
@@ -4429,23 +4215,20 @@ export 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 const replace: {
@@ -4455,23 +4238,20 @@ export 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>>
@@ -4481,23 +4261,20 @@ export 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>>
@@ -4512,11 +4289,10 @@ export 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
@@ -4532,11 +4308,10 @@ export 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
@@ -4552,11 +4327,10 @@ export 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
@@ -4576,11 +4350,10 @@ export 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
@@ -4598,24 +4371,23 @@ export 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 const contains: {
@@ -4628,24 +4400,23 @@ export 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
@@ -4658,24 +4429,23 @@ export 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
@@ -4686,7 +4456,7 @@ export 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" })
@@ -4695,19 +4465,19 @@ export 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 const containsWith: <A>(
@@ -4723,17 +4493,14 @@ export const containsWith: <A>(
  *
  * **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)
@@ -4741,10 +4508,10 @@ export const containsWith: <A>(
  *   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 const findFirst: {
@@ -4754,17 +4521,14 @@ export 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)
@@ -4772,10 +4536,10 @@ export 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>
@@ -4785,17 +4549,14 @@ export 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)
@@ -4803,10 +4564,10 @@ export 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>
@@ -4816,17 +4577,14 @@ export 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)
@@ -4834,10 +4592,10 @@ export 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>
@@ -4847,17 +4605,14 @@ export 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)
@@ -4865,10 +4620,10 @@ export 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>
@@ -4879,23 +4634,20 @@ export 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 const findFirstIndex: {
@@ -4904,23 +4656,20 @@ export 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>
@@ -4929,23 +4678,20 @@ export 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>
@@ -4959,24 +4705,20 @@ export 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 const findLast: {
@@ -4985,24 +4727,20 @@ export 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>
@@ -5011,24 +4749,20 @@ export 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>
@@ -5037,24 +4771,20 @@ export 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>
@@ -5063,24 +4793,20 @@ export 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>
@@ -5091,23 +4817,20 @@ export 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 const findLastIndex: {
@@ -5116,23 +4839,20 @@ export 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>
@@ -5141,23 +4861,20 @@ export 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>
@@ -5171,26 +4888,24 @@ export 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 const every: {
@@ -5199,26 +4914,24 @@ export 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>
@@ -5227,26 +4940,24 @@ export 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
@@ -5255,26 +4966,24 @@ export 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>
@@ -5283,26 +4992,24 @@ export 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
@@ -5317,23 +5024,22 @@ export 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 const some: {
@@ -5342,23 +5048,22 @@ export 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>
@@ -5367,23 +5072,22 @@ export 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>
@@ -5397,24 +5101,20 @@ export 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
@@ -5426,24 +5126,20 @@ export 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
@@ -5455,24 +5151,20 @@ export 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
@@ -5486,21 +5178,18 @@ export 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
@@ -5512,21 +5201,18 @@ export 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
@@ -5538,21 +5224,18 @@ export 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
@@ -5566,25 +5249,22 @@ export 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
@@ -5596,25 +5276,22 @@ export 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
@@ -5626,25 +5303,22 @@ export 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
@@ -5659,7 +5333,7 @@ export 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" })
@@ -5669,8 +5343,7 @@ export 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")
@@ -5678,8 +5351,7 @@ export 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
@@ -5701,24 +5373,20 @@ export const differenceWith = <A>(isEquivalent: (self: A, that: A) => boolean):
  *
  * **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
@@ -5731,24 +5399,20 @@ export 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
@@ -5761,24 +5425,20 @@ export 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