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

package/src/Record.ts

@@ -28,7 +28,7 @@ import type { NoInfer } from "./Types.ts"
  *
  * **Example** (Defining a readonly record type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Record } from "effect"
  *
  * // Creating a readonly record type
@@ -38,6 +38,7 @@ import type { NoInfer } from "./Types.ts"
  *   name: "John",
  *   age: 30
  * }
+ * user // => { name: "John", age: 30 }
  * ```
  *
  * @category models
@@ -53,7 +54,7 @@ export type ReadonlyRecord<in out K extends string | symbol, out A> = {
  *
  * **Example** (Using readonly record helper types)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { Record } from "effect"
  *
  * // Using NonLiteralKey to convert literal keys to generic types
@@ -61,6 +62,9 @@ export type ReadonlyRecord<in out K extends string | symbol, out A> = {
  *
  * // Using IntersectKeys to find common keys between record types
  * type CommonKeys = Record.ReadonlyRecord.IntersectKeys<"a" | "b", "b" | "c"> // "b"
+ *
+ * "key" satisfies GenericKey
+ * "b" satisfies CommonKeys
  * ```
  *
  * @since 2.0.0
@@ -77,7 +81,7 @@ export declare namespace ReadonlyRecord {
    *
    * **Example** (Converting literal keys to non-literal keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Record } from "effect"
    *
    * // For literal string keys, this becomes 'string'
@@ -85,6 +89,10 @@ export declare namespace ReadonlyRecord {
    *
    * // For symbol keys, this becomes 'symbol'
    * type Example2 = Record.ReadonlyRecord.NonLiteralKey<symbol> // symbol
+   *
+   * const symbol: Example2 = Symbol.for("key")
+   * "key" satisfies Example1
+   * symbol
    * ```
    *
    * @category models
@@ -99,7 +107,7 @@ export declare namespace ReadonlyRecord {
    *
    * **Example** (Intersecting record keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import type { Record } from "effect"
    *
    * // Intersection of literal keys
@@ -107,6 +115,9 @@ export declare namespace ReadonlyRecord {
    *
    * // Intersection with generic string
    * type Example2 = Record.ReadonlyRecord.IntersectKeys<string, "a" | "b"> // string
+   *
+   * "b" satisfies Example1
+   * "a" satisfies Example2
    * ```
    *
    * @category models
@@ -123,7 +134,7 @@ export declare namespace ReadonlyRecord {
  *
  * **Example** (Applying a readonly record type lambda)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import type { HKT, Record } from "effect"
  *
  * type Settings = HKT.Kind<
@@ -138,9 +149,10 @@ export declare namespace ReadonlyRecord {
  *   port: 3000,
  *   retries: 3
  * }
+ * defaults // => { port: 3000, retries: 3 }
  * ```
  *
- * @category type lambdas
+ * @category utility types
  * @since 2.0.0
  */
 export interface ReadonlyRecordTypeLambda<K extends string = string> extends TypeLambda {
@@ -152,16 +164,15 @@ export interface ReadonlyRecordTypeLambda<K extends string = string> extends Typ
  *
  * **Example** (Creating an empty record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
  *
  * // Create an empty record
  * const emptyRecord = Record.empty<string, number>()
- * console.log(emptyRecord) // {}
+ * emptyRecord // => {}
  *
  * // The type ensures type safety for future operations
- * const withValue = Record.set(emptyRecord, "count", 42)
- * console.log(withValue) // { count: 42 }
+ * Record.set(emptyRecord, "count", 42) // => { count: 42 }
  * ```
  *
  * @category constructors
@@ -177,12 +188,11 @@ export const empty = <K extends string | symbol = never, V = never>(): Record<
  *
  * **Example** (Checking for an empty record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.isEmptyRecord({}), true)
- * assert.deepStrictEqual(Record.isEmptyRecord({ a: 3 }), false)
+ * Record.isEmptyRecord({}) // => true
+ * Record.isEmptyRecord({ a: 3 }) // => false
  * ```
  *
  * @category guards
@@ -196,12 +206,11 @@ export const isEmptyRecord = <K extends string, A>(self: Record<K, A>): self is
  *
  * **Example** (Checking for an empty readonly record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.isEmptyReadonlyRecord({}), true)
- * assert.deepStrictEqual(Record.isEmptyReadonlyRecord({ a: 3 }), false)
+ * Record.isEmptyReadonlyRecord({}) // => true
+ * Record.isEmptyReadonlyRecord({ a: 3 }) // => false
  * ```
  *
  * @category guards
@@ -217,16 +226,10 @@ export const isEmptyReadonlyRecord: <K extends string, A>(
  *
  * **Example** (Building a record from mapped iterable values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
- *
- * const input = [1, 2, 3, 4]
  *
- * assert.deepStrictEqual(
- *   Record.fromIterableWith(input, (a) => [String(a), a * 2]),
- *   { "1": 2, "2": 4, "3": 6, "4": 8 }
- * )
+ * Record.fromIterableWith([1, 2, 3, 4], (a) => [String(a), a * 2]) // => { "1": 2, "2": 4, "3": 6, "4": 8 }
  * ```
  *
  * @category constructors
@@ -239,16 +242,10 @@ export const fromIterableWith: {
    *
    * **Example** (Building a record from mapped iterable values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * const input = [1, 2, 3, 4]
    *
-   * assert.deepStrictEqual(
-   *   Record.fromIterableWith(input, (a) => [String(a), a * 2]),
-   *   { "1": 2, "2": 4, "3": 6, "4": 8 }
-   * )
+   * Record.fromIterableWith([1, 2, 3, 4], (a) => [String(a), a * 2]) // => { "1": 2, "2": 4, "3": 6, "4": 8 }
    * ```
    *
    * @category constructors
@@ -261,16 +258,10 @@ export const fromIterableWith: {
    *
    * **Example** (Building a record from mapped iterable values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * const input = [1, 2, 3, 4]
-   *
-   * assert.deepStrictEqual(
-   *   Record.fromIterableWith(input, (a) => [String(a), a * 2]),
-   *   { "1": 2, "2": 4, "3": 6, "4": 8 }
-   * )
+   * Record.fromIterableWith([1, 2, 3, 4], (a) => [String(a), a * 2]) // => { "1": 2, "2": 4, "3": 6, "4": 8 }
    * ```
    *
    * @category constructors
@@ -297,22 +288,18 @@ export const fromIterableWith: {
  *
  * **Example** (Building a record keyed by iterable values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const users = [
  *   { id: "2", name: "name2" },
  *   { id: "1", name: "name1" }
  * ]
  *
- * assert.deepStrictEqual(
- *   Record.fromIterableBy(users, (user) => user.id),
- *   {
- *     "2": { id: "2", name: "name2" },
- *     "1": { id: "1", name: "name1" }
- *   }
- * )
+ * Record.fromIterableBy(
+ *   users,
+ *   (user) => user.id
+ * ) // => { "1": { id: "1", name: "name1" }, "2": { id: "2", name: "name2" } }
  * ```
  *
  * @category constructors
@@ -324,22 +311,18 @@ export const fromIterableBy: {
    *
    * **Example** (Building a record keyed by iterable values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const users = [
    *   { id: "2", name: "name2" },
    *   { id: "1", name: "name1" }
    * ]
    *
-   * assert.deepStrictEqual(
-   *   Record.fromIterableBy(users, (user) => user.id),
-   *   {
-   *     "2": { id: "2", name: "name2" },
-   *     "1": { id: "1", name: "name1" }
-   *   }
-   * )
+   * Record.fromIterableBy(
+   *   users,
+   *   (user) => user.id
+   * ) // => { "1": { id: "1", name: "name1" }, "2": { id: "2", name: "name2" } }
    * ```
    *
    * @category constructors
@@ -351,22 +334,18 @@ export const fromIterableBy: {
    *
    * **Example** (Building a record keyed by iterable values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const users = [
    *   { id: "2", name: "name2" },
    *   { id: "1", name: "name1" }
    * ]
    *
-   * assert.deepStrictEqual(
-   *   Record.fromIterableBy(users, (user) => user.id),
-   *   {
-   *     "2": { id: "2", name: "name2" },
-   *     "1": { id: "1", name: "name1" }
-   *   }
-   * )
+   * Record.fromIterableBy(
+   *   users,
+   *   (user) => user.id
+   * ) // => { "1": { id: "1", name: "name1" }, "2": { id: "2", name: "name2" } }
    * ```
    *
    * @category constructors
@@ -391,13 +370,10 @@ export const fromIterableBy: {
  *
  * **Example** (Building a record from entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
- *
- * assert.deepStrictEqual(Record.fromEntries(input), { a: 1, b: 2 })
+ * Record.fromEntries([["a", 1], ["b", 2]]) // => { a: 1, b: 2 }
  * ```
  *
  * @category constructors
@@ -412,15 +388,11 @@ export const fromEntries: <Entry extends readonly [string | symbol, any]>(
  *
  * **Example** (Collecting mapped record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(Record.collect(x, (key, n) => [key, n]), [["a", 1], [
- *   "b",
- *   2
- * ], ["c", 3]])
+ * Record.collect(x, (key, n) => [key, n]) // => [["a", 1], ["b", 2], ["c", 3]]
  * ```
  *
  * @category converting
@@ -432,15 +404,11 @@ export const collect: {
    *
    * **Example** (Collecting mapped record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * assert.deepStrictEqual(Record.collect(x, (key, n) => [key, n]), [["a", 1], [
-   *   "b",
-   *   2
-   * ], ["c", 3]])
+   * Record.collect(x, (key, n) => [key, n]) // => [["a", 1], ["b", 2], ["c", 3]]
    * ```
    *
    * @category converting
@@ -452,15 +420,11 @@ export const collect: {
    *
    * **Example** (Collecting mapped record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * assert.deepStrictEqual(Record.collect(x, (key, n) => [key, n]), [["a", 1], [
-   *   "b",
-   *   2
-   * ], ["c", 3]])
+   * Record.collect(x, (key, n) => [key, n]) // => [["a", 1], ["b", 2], ["c", 3]]
    * ```
    *
    * @category converting
@@ -483,12 +447,11 @@ export const collect: {
  *
  * **Example** (Converting a record to entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(Record.toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
+ * Record.toEntries(x) // => [["a", 1], ["b", 2], ["c", 3]]
  * ```
  *
  * @category converting
@@ -504,11 +467,10 @@ export const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>) => Arr
  *
  * **Example** (Getting the record size)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.size({ a: "a", b: 1, c: true }), 3)
+ * Record.size({ a: "a", b: 1, c: true }) // => 3
  * ```
  *
  * @category getters
@@ -521,15 +483,14 @@ export const size = <K extends string, A>(self: ReadonlyRecord<K, A>): number =>
  *
  * **Example** (Checking key membership)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.has({ a: 1, b: 2 }, "a"), true)
- * assert.deepStrictEqual(Record.has(Record.empty<string>(), "c"), false)
+ * Record.has({ a: 1, b: 2 }, "a") // => true
+ * Record.has(Record.empty<string>(), "c") // => false
  * ```
  *
- * @category guards
+ * @category predicates
  * @since 2.0.0
  */
 export const has: {
@@ -538,15 +499,14 @@ export const has: {
    *
    * **Example** (Checking key membership)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.has({ a: 1, b: 2 }, "a"), true)
-   * assert.deepStrictEqual(Record.has(Record.empty<string>(), "c"), false)
+   * Record.has({ a: 1, b: 2 }, "a") // => true
+   * Record.has(Record.empty<string>(), "c") // => false
    * ```
    *
-   * @category guards
+   * @category predicates
    * @since 2.0.0
    */
   <K extends string | symbol>(key: NoInfer<K>): <A>(self: ReadonlyRecord<K, A>) => boolean
@@ -555,15 +515,14 @@ export const has: {
    *
    * **Example** (Checking key membership)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.has({ a: 1, b: 2 }, "a"), true)
-   * assert.deepStrictEqual(Record.has(Record.empty<string>(), "c"), false)
+   * Record.has({ a: 1, b: 2 }, "a") // => true
+   * Record.has(Record.empty<string>(), "c") // => false
    * ```
    *
-   * @category guards
+   * @category predicates
    * @since 2.0.0
    */
   <K extends string | symbol, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): boolean
@@ -580,14 +539,13 @@ export const has: {
  *
  * **Example** (Getting a value as an Option)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Record as R } from "effect"
- * import * as assert from "node:assert"
  *
  * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
  *
- * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe"))
- * assert.deepStrictEqual(R.get(person, "email"), Option.none())
+ * R.get(person, "name") // => Option.some("John Doe")
+ * R.get(person, "email") // => Option.none()
  * ```
  *
  * @category getters
@@ -599,14 +557,13 @@ export const get: {
    *
    * **Example** (Getting a value as an Option)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Option, Record as R } from "effect"
-   * import * as assert from "node:assert"
    *
    * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
    *
-   * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe"))
-   * assert.deepStrictEqual(R.get(person, "email"), Option.none())
+   * R.get(person, "name") // => Option.some("John Doe")
+   * R.get(person, "email") // => Option.none()
    * ```
    *
    * @category getters
@@ -618,14 +575,13 @@ export const get: {
    *
    * **Example** (Getting a value as an Option)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Option, Record as R } from "effect"
-   * import * as assert from "node:assert"
    *
    * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
    *
-   * assert.deepStrictEqual(R.get(person, "name"), Option.some("John Doe"))
-   * assert.deepStrictEqual(R.get(person, "email"), Option.none())
+   * R.get(person, "name") // => Option.some("John Doe")
+   * R.get(person, "email") // => Option.none()
    * ```
    *
    * @category getters
@@ -644,15 +600,15 @@ export const get: {
  *
  * **Example** (Modifying a value at a key)
  *
- * ```ts
- * import { Record } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Record } from "effect"
  *
  * const f = (x: number) => x * 2
  *
  * const input: Record<string, number> = { a: 3 }
  *
- * Record.modify(input, "a", f) // Option.some({ a: 6 })
- * Record.modify(input, "b", f) // Option.none()
+ * Record.modify(input, "a", f) // => Option.some({ a: 6 })
+ * Record.modify(input, "b", f) // => Option.none()
  * ```
  *
  * @category mutations
@@ -665,15 +621,15 @@ export const modify: {
    *
    * **Example** (Modifying a value at a key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const f = (x: number) => x * 2
    *
    * const input: Record<string, number> = { a: 3 }
    *
-   * Record.modify(input, "a", f) // Option.some({ a: 6 })
-   * Record.modify(input, "b", f) // Option.none()
+   * Record.modify(input, "a", f) // => Option.some({ a: 6 })
+   * Record.modify(input, "b", f) // => Option.none()
    * ```
    *
    * @category mutations
@@ -686,15 +642,15 @@ export const modify: {
    *
    * **Example** (Modifying a value at a key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const f = (x: number) => x * 2
    *
    * const input: Record<string, number> = { a: 3 }
    *
-   * Record.modify(input, "a", f) // Option.some({ a: 6 })
-   * Record.modify(input, "b", f) // Option.none()
+   * Record.modify(input, "a", f) // => Option.some({ a: 6 })
+   * Record.modify(input, "b", f) // => Option.none()
    * ```
    *
    * @category mutations
@@ -724,11 +680,11 @@ export const modify: {
  *
  * **Example** (Replacing a value at a key)
  *
- * ```ts
- * import { Record } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Record } from "effect"
  *
- * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
- * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
+ * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // => Option.some({ a: 10, b: 2, c: 3 })
+ * Record.replace(Record.empty<string>(), "a", 10) // => Option.none()
  * ```
  *
  * @category mutations
@@ -746,11 +702,11 @@ export const replace: {
    *
    * **Example** (Replacing a value at a key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
-   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
-   * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
+   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // => Option.some({ a: 10, b: 2, c: 3 })
+   * Record.replace(Record.empty<string>(), "a", 10) // => Option.none()
    * ```
    *
    * @category mutations
@@ -768,11 +724,11 @@ export const replace: {
    *
    * **Example** (Replacing a value at a key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
-   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
-   * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
+   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // => Option.some({ a: 10, b: 2, c: 3 })
+   * Record.replace(Record.empty<string>(), "a", 10) // => Option.none()
    * ```
    *
    * @category mutations
@@ -802,11 +758,10 @@ export const replace: {
  *
  * **Example** (Removing a key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.remove({ a: 1, b: 2 }, "a"), { b: 2 })
+ * Record.remove({ a: 1, b: 2 }, "a") // => { b: 2 }
  * ```
  *
  * @category mutations
@@ -827,11 +782,10 @@ export const remove: {
    *
    * **Example** (Removing a key)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.remove({ a: 1, b: 2 }, "a"), { b: 2 })
+   * Record.remove({ a: 1, b: 2 }, "a") // => { b: 2 }
    * ```
    *
    * @category mutations
@@ -852,11 +806,10 @@ export const remove: {
    *
    * **Example** (Removing a key)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.remove({ a: 1, b: 2 }, "a"), { b: 2 })
+   * Record.remove({ a: 1, b: 2 }, "a") // => { b: 2 }
    * ```
    *
    * @category mutations
@@ -882,13 +835,13 @@ export const remove: {
  *
  * **Example** (Popping a value and removing its key)
  *
- * ```ts
- * import { Record } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Record } from "effect"
  *
  * const input: Record<string, number> = { a: 1, b: 2 }
  *
- * Record.pop(input, "a") // Option.some([1, { b: 2 }])
- * Record.pop(input, "c") // Option.none()
+ * Record.pop(input, "a") // => Option.some([1, { b: 2 }])
+ * Record.pop(input, "c") // => Option.none()
  * ```
  *
  * @category mutations
@@ -902,13 +855,13 @@ export const pop: {
    *
    * **Example** (Popping a value and removing its key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const input: Record<string, number> = { a: 1, b: 2 }
    *
-   * Record.pop(input, "a") // Option.some([1, { b: 2 }])
-   * Record.pop(input, "c") // Option.none()
+   * Record.pop(input, "a") // => Option.some([1, { b: 2 }])
+   * Record.pop(input, "c") // => Option.none()
    * ```
    *
    * @category mutations
@@ -922,13 +875,13 @@ export const pop: {
    *
    * **Example** (Popping a value and removing its key)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const input: Record<string, number> = { a: 1, b: 2 }
    *
-   * Record.pop(input, "a") // Option.some([1, { b: 2 }])
-   * Record.pop(input, "c") // Option.none()
+   * Record.pop(input, "a") // => Option.some([1, { b: 2 }])
+   * Record.pop(input, "c") // => Option.none()
    * ```
    *
    * @category mutations
@@ -946,17 +899,16 @@ export const pop: {
  *
  * **Example** (Mapping record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const f = (n: number) => `-${n}`
  *
- * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" })
+ * Record.map({ a: 3, b: 5 }, f) // => { a: "-3", b: "-5" }
  *
  * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}`
  *
- * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
+ * Record.map({ a: 3, b: 5 }, g) // => { a: "A-3", b: "B-5" }
  * ```
  *
  * @category mapping
@@ -968,17 +920,16 @@ export const map: {
    *
    * **Example** (Mapping record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const f = (n: number) => `-${n}`
    *
-   * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" })
+   * Record.map({ a: 3, b: 5 }, f) // => { a: "-3", b: "-5" }
    *
    * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}`
    *
-   * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
+   * Record.map({ a: 3, b: 5 }, g) // => { a: "A-3", b: "B-5" }
    * ```
    *
    * @category mapping
@@ -990,17 +941,16 @@ export const map: {
    *
    * **Example** (Mapping record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const f = (n: number) => `-${n}`
    *
-   * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" })
+   * Record.map({ a: 3, b: 5 }, f) // => { a: "-3", b: "-5" }
    *
    * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}`
    *
-   * assert.deepStrictEqual(Record.map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
+   * Record.map({ a: 3, b: 5 }, g) // => { a: "A-3", b: "B-5" }
    * ```
    *
    * @category mapping
@@ -1023,14 +973,10 @@ export const map: {
  *
  * **Example** (Mapping record keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()),
- *   { A: 3, B: 5 }
- * )
+ * Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()) // => { A: 3, B: 5 }
  * ```
  *
  * @category mapping
@@ -1042,14 +988,10 @@ export const mapKeys: {
    *
    * **Example** (Mapping record keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()),
-   *   { A: 3, B: 5 }
-   * )
+   * Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()) // => { A: 3, B: 5 }
    * ```
    *
    * @category mapping
@@ -1061,14 +1003,10 @@ export const mapKeys: {
    *
    * **Example** (Mapping record keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()),
-   *   { A: 3, B: 5 }
-   * )
+   * Record.mapKeys({ a: 3, b: 5 }, (key) => key.toUpperCase()) // => { A: 3, B: 5 }
    * ```
    *
    * @category mapping
@@ -1095,14 +1033,10 @@ export const mapKeys: {
  *
  * **Example** (Mapping record entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]),
- *   { A: 4, B: 6 }
- * )
+ * Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]) // => { A: 4, B: 6 }
  * ```
  *
  * @category mapping
@@ -1114,14 +1048,10 @@ export const mapEntries: {
    *
    * **Example** (Mapping record entries)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]),
-   *   { A: 4, B: 6 }
-   * )
+   * Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]) // => { A: 4, B: 6 }
    * ```
    *
    * @category mapping
@@ -1133,14 +1063,10 @@ export const mapEntries: {
    *
    * **Example** (Mapping record entries)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]),
-   *   { A: 4, B: 6 }
-   * )
+   * Record.mapEntries({ a: 3, b: 5 }, (a, key) => [key.toUpperCase(), a + 1]) // => { A: 4, B: 6 }
    * ```
    *
    * @category mapping
@@ -1168,13 +1094,12 @@ export const mapEntries: {
  *
  * **Example** (Filtering and mapping with Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record, Result } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
- * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
+ * Record.filterMap(x, f) // => { c: 6 }
  * ```
  *
  * @category filtering
@@ -1187,13 +1112,12 @@ export const filterMap: {
    *
    * **Example** (Filtering and mapping with Result)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record, Result } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
-   * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
+   * Record.filterMap(x, f) // => { c: 6 }
    * ```
    *
    * @category filtering
@@ -1206,13 +1130,12 @@ export const filterMap: {
    *
    * **Example** (Filtering and mapping with Result)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record, Result } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
-   * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
+   * Record.filterMap(x, f) // => { c: 6 }
    * ```
    *
    * @category filtering
@@ -1241,12 +1164,11 @@ export const filterMap: {
  *
  * **Example** (Filtering record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3, d: 4 }
- * assert.deepStrictEqual(Record.filter(x, (n) => n > 2), { c: 3, d: 4 })
+ * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }
  * ```
  *
  * @category filtering
@@ -1258,12 +1180,11 @@ export const filter: {
    *
    * **Example** (Filtering record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3, d: 4 }
-   * assert.deepStrictEqual(Record.filter(x, (n) => n > 2), { c: 3, d: 4 })
+   * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }
    * ```
    *
    * @category filtering
@@ -1275,12 +1196,11 @@ export const filter: {
    *
    * **Example** (Filtering record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3, d: 4 }
-   * assert.deepStrictEqual(Record.filter(x, (n) => n > 2), { c: 3, d: 4 })
+   * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }
    * ```
    *
    * @category filtering
@@ -1292,12 +1212,11 @@ export const filter: {
    *
    * **Example** (Filtering record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3, d: 4 }
-   * assert.deepStrictEqual(Record.filter(x, (n) => n > 2), { c: 3, d: 4 })
+   * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }
    * ```
    *
    * @category filtering
@@ -1309,12 +1228,11 @@ export const filter: {
    *
    * **Example** (Filtering record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3, d: 4 }
-   * assert.deepStrictEqual(Record.filter(x, (n) => n > 2), { c: 3, d: 4 })
+   * Record.filter(x, (n) => n > 2) // => { c: 3, d: 4 }
    * ```
    *
    * @category filtering
@@ -1343,14 +1261,10 @@ export const filter: {
  *
  * **Example** (Extracting Some values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.getSomes({ a: Option.some(1), b: Option.none(), c: Option.some(2) }),
- *   { a: 1, c: 2 }
- * )
+ * Record.getSomes({ a: Option.some(1), b: Option.none(), c: Option.some(2) }) // => { a: 1, c: 2 }
  * ```
  *
  * @category filtering
@@ -1377,18 +1291,14 @@ export const getSomes: <K extends string, A>(
  *
  * **Example** (Extracting Result failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record, Result } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.getFailures({
+ * Record.getFailures({
  *     a: Result.succeed(1),
  *     b: Result.fail("err"),
  *     c: Result.succeed(2)
- *   }),
- *   { b: "err" }
- * )
+ * }) // => { b: "err" }
  * ```
  *
  * @category filtering
@@ -1414,18 +1324,14 @@ export const getFailures = <K extends string, A, E>(
  *
  * **Example** (Extracting Result successes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record, Result } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.getSuccesses({
+ * Record.getSuccesses({
  *     a: Result.succeed(1),
  *     b: Result.fail("err"),
  *     c: Result.succeed(2)
- *   }),
- *   { a: 1, c: 2 }
- * )
+ * }) // => { a: 1, c: 2 }
  * ```
  *
  * @category filtering
@@ -1456,13 +1362,12 @@ export const getSuccesses = <K extends string, A, E>(
  *
  * **Example** (Partitioning with Result)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record, Result } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
  * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+ * Record.partition(x, f) // => [{ a: 1, c: 3 }, { b: 2 }]
  * ```
  *
  * @category filtering
@@ -1480,13 +1385,12 @@ export const partition: {
    *
    * **Example** (Partitioning with Result)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record, Result } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * Record.partition(x, f) // => [{ a: 1, c: 3 }, { b: 2 }]
    * ```
    *
    * @category filtering
@@ -1506,13 +1410,12 @@ export const partition: {
    *
    * **Example** (Partitioning with Result)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record, Result } from "effect"
-   * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * Record.partition(x, f) // => [{ a: 1, c: 3 }, { b: 2 }]
    * ```
    *
    * @category filtering
@@ -1545,14 +1448,10 @@ export const partition: {
  *
  * **Example** (Separating Result values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record, Result } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.separate({ a: Result.fail("e"), b: Result.succeed(1) }),
- *   [{ a: "e" }, { b: 1 }]
- * )
+ * Record.separate({ a: Result.fail("e"), b: Result.succeed(1) }) // => [{ a: "e" }, { b: 1 }]
  * ```
  *
  * @category filtering
@@ -1567,11 +1466,10 @@ export const separate: <K extends string, A, B>(
  *
  * **Example** (Getting record keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.keys({ a: 1, b: 2, c: 3 }), ["a", "b", "c"])
+ * Record.keys({ a: 1, b: 2, c: 3 }) // => ["a", "b", "c"]
  * ```
  *
  * @category getters
@@ -1585,11 +1483,10 @@ export const keys = <K extends string | symbol, A>(self: ReadonlyRecord<K, A>):
  *
  * **Example** (Getting record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.values({ a: 1, b: 2, c: 3 }), [1, 2, 3])
+ * Record.values({ a: 1, b: 2, c: 3 }) // => [1, 2, 3]
  * ```
  *
  * @category getters
@@ -1602,12 +1499,11 @@ export const values = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<A
  *
  * **Example** (Setting a record value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 })
- * assert.deepStrictEqual(Record.set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 })
+ * Record.set("a", 5)({ a: 1, b: 2 }) // => { a: 5, b: 2 }
+ * Record.set("c", 5)({ a: 1, b: 2 }) // => { a: 1, b: 2, c: 5 }
  * ```
  *
  * @category mutations
@@ -1619,12 +1515,11 @@ export const set: {
    *
    * **Example** (Setting a record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 })
-   * assert.deepStrictEqual(Record.set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 })
+   * Record.set("a", 5)({ a: 1, b: 2 }) // => { a: 5, b: 2 }
+   * Record.set("c", 5)({ a: 1, b: 2 }) // => { a: 1, b: 2, c: 5 }
    * ```
    *
    * @category mutations
@@ -1636,12 +1531,11 @@ export const set: {
    *
    * **Example** (Setting a record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.set("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 })
-   * assert.deepStrictEqual(Record.set("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 })
+   * Record.set("a", 5)({ a: 1, b: 2 }) // => { a: 5, b: 2 }
+   * Record.set("c", 5)({ a: 1, b: 2 }) // => { a: 1, b: 2, c: 5 }
    * ```
    *
    * @category mutations
@@ -1674,21 +1568,20 @@ export const set: {
  *
  * **Example** (Assigning an external key safely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const key: string = "__proto__" // Assume this comes from external input
  * const value = { polluted: true }
  *
  * const unsafe: Record<string, unknown> = {}
  * unsafe[key] = value
- * assert.strictEqual(Object.getPrototypeOf(unsafe), value)
+ * Object.getPrototypeOf(unsafe) === value // => true
  *
  * const safe: Record<string, unknown> = {}
  * Record.assignProperty(safe, key, value)
- * assert.strictEqual(Object.getPrototypeOf(safe), Object.prototype)
- * assert.strictEqual(safe[key], value)
+ * Object.getPrototypeOf(safe) === Object.prototype // => true
+ * safe[key] === value // => true
  * ```
  *
  * @see {@link set} for an immutable update
@@ -1703,7 +1596,7 @@ export const assignProperty: (self: object, key: PropertyKey, value: unknown) =>
  *
  * **Example** (Checking subrecords with a custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Record } from "effect"
  *
  * const isSubrecord = Record.isSubrecordBy(
@@ -1716,15 +1609,9 @@ export const assignProperty: (self: object, key: PropertyKey, value: unknown) =>
  *   status: "active"
  * }
  *
- * console.log(
- *   isSubrecord(required, available)
- * ) // true
- * console.log(
- *   isSubrecord({ role: "Admin", status: "inactive" }, available)
- * ) // false
- * console.log(
- *   isSubrecord(required, { role: "editor", status: "active" })
- * ) // false
+ * isSubrecord(required, available) // => true
+ * isSubrecord({ role: "Admin", status: "inactive" }, available) // => false
+ * isSubrecord(required, { role: "editor", status: "active" }) // => false
  * ```
  *
  * @category predicates
@@ -1753,18 +1640,11 @@ export const isSubrecordBy = <A>(equivalence: Equivalence<A>): {
  *
  * **Example** (Checking subrecords)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }),
- *   true
- * )
- * assert.deepStrictEqual(
- *   Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>),
- *   false
- * )
+ * Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }) // => true
+ * Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>) // => false
  * ```
  *
  * @category predicates
@@ -1781,18 +1661,11 @@ export const isSubrecord: {
    *
    * **Example** (Checking subrecords)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }),
-   *   true
-   * )
-   * assert.deepStrictEqual(
-   *   Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>),
-   *   false
-   * )
+   *
+   * Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }) // => true
+   * Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>) // => false
    * ```
    *
    * @category predicates
@@ -1809,18 +1682,11 @@ export const isSubrecord: {
    *
    * **Example** (Checking subrecords)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }),
-   *   true
-   * )
-   * assert.deepStrictEqual(
-   *   Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>),
-   *   false
-   * )
+   *
+   * Record.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 }) // => true
+   * Record.isSubrecord({ a: 1, b: 2 }, { a: 1 } as Record<string, number>) // => false
    * ```
    *
    * @category predicates
@@ -1834,14 +1700,10 @@ export const isSubrecord: {
  *
  * **Example** (Reducing record values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value, key) => acc + value),
- *   6
- * )
+ * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
  * ```
  *
  * @category folding
@@ -1853,14 +1715,10 @@ export const reduce: {
    *
    * **Example** (Reducing record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value, key) => acc + value),
-   *   6
-   * )
+   * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
    * ```
    *
    * @category folding
@@ -1872,14 +1730,10 @@ export const reduce: {
    *
    * **Example** (Reducing record values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value, key) => acc + value),
-   *   6
-   * )
+   * Record.reduce({ a: 1, b: 2, c: 3 }, 0, (acc, value) => acc + value) // => 6
    * ```
    *
    * @category folding
@@ -1910,15 +1764,14 @@ export const reduce: {
  *
  * **Example** (Checking every record value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.every({ a: 1, b: 2 }, (n) => n > 0), true)
- * assert.deepStrictEqual(Record.every({ a: 1, b: -1 }, (n) => n > 0), false)
+ * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true
+ * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false
  * ```
  *
- * @category predicates
+ * @category guards
  * @since 2.0.0
  */
 export const every: {
@@ -1927,15 +1780,14 @@ export const every: {
    *
    * **Example** (Checking every record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.every({ a: 1, b: 2 }, (n) => n > 0), true)
-   * assert.deepStrictEqual(Record.every({ a: 1, b: -1 }, (n) => n > 0), false)
+   * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true
+   * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false
    * ```
    *
-   * @category predicates
+   * @category guards
    * @since 2.0.0
    */
   <A, K extends string, B extends A>(refinement: (value: A, key: K) => value is B): (self: ReadonlyRecord<K, A>) => self is ReadonlyRecord<K, B>
@@ -1944,15 +1796,14 @@ export const every: {
    *
    * **Example** (Checking every record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.every({ a: 1, b: 2 }, (n) => n > 0), true)
-   * assert.deepStrictEqual(Record.every({ a: 1, b: -1 }, (n) => n > 0), false)
+   * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true
+   * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false
    * ```
    *
-   * @category predicates
+   * @category guards
    * @since 2.0.0
    */
   <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord<K, A>) => boolean
@@ -1961,15 +1812,14 @@ export const every: {
    *
    * **Example** (Checking every record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.every({ a: 1, b: 2 }, (n) => n > 0), true)
-   * assert.deepStrictEqual(Record.every({ a: 1, b: -1 }, (n) => n > 0), false)
+   * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true
+   * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false
    * ```
    *
-   * @category predicates
+   * @category guards
    * @since 2.0.0
    */
   <A, K extends string, B extends A>(self: ReadonlyRecord<K, A>, refinement: (value: A, key: K) => value is B): self is ReadonlyRecord<K, B>
@@ -1978,15 +1828,14 @@ export const every: {
    *
    * **Example** (Checking every record value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.every({ a: 1, b: 2 }, (n) => n > 0), true)
-   * assert.deepStrictEqual(Record.every({ a: 1, b: -1 }, (n) => n > 0), false)
+   * Record.every({ a: 1, b: 2 }, (n) => n > 0) // => true
+   * Record.every({ a: 1, b: -1 }, (n) => n > 0) // => false
    * ```
    *
-   * @category predicates
+   * @category guards
    * @since 2.0.0
    */
   <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean
@@ -2010,12 +1859,11 @@ export const every: {
  *
  * **Example** (Checking for any matching value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 1), true)
- * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 2), false)
+ * Record.some({ a: 1, b: 2 }, (n) => n > 1) // => true
+ * Record.some({ a: 1, b: 2 }, (n) => n > 2) // => false
  * ```
  *
  * @category predicates
@@ -2027,12 +1875,11 @@ export const some: {
    *
    * **Example** (Checking for any matching value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 1), true)
-   * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 2), false)
+   * Record.some({ a: 1, b: 2 }, (n) => n > 1) // => true
+   * Record.some({ a: 1, b: 2 }, (n) => n > 2) // => false
    * ```
    *
    * @category predicates
@@ -2044,12 +1891,11 @@ export const some: {
    *
    * **Example** (Checking for any matching value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 1), true)
-   * assert.deepStrictEqual(Record.some({ a: 1, b: 2 }, (n) => n > 2), false)
+   * Record.some({ a: 1, b: 2 }, (n) => n > 1) // => true
+   * Record.some({ a: 1, b: 2 }, (n) => n > 2) // => false
    * ```
    *
    * @category predicates
@@ -2074,14 +1920,10 @@ export const some: {
  *
  * **Example** (Merging records with union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
- *   { a: 1, b: 5, c: 4 }
- * )
+ * Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { a: 1, b: 5, c: 4 }
  * ```
  *
  * @category combining
@@ -2094,14 +1936,10 @@ export const union: {
    *
    * **Example** (Merging records with union)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
-   *   { a: 1, b: 5, c: 4 }
-   * )
+   * Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { a: 1, b: 5, c: 4 }
    * ```
    *
    * @category combining
@@ -2114,14 +1952,10 @@ export const union: {
    *
    * **Example** (Merging records with union)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
-   *   { a: 1, b: 5, c: 4 }
-   * )
+   * Record.union({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { a: 1, b: 5, c: 4 }
    * ```
    *
    * @category combining
@@ -2168,14 +2002,10 @@ export const union: {
  *
  * **Example** (Merging intersecting keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
- *   { b: 5 }
- * )
+ * Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { b: 5 }
  * ```
  *
  * @category combining
@@ -2188,14 +2018,10 @@ export const intersection: {
    *
    * **Example** (Merging intersecting keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
-   *   { b: 5 }
-   * )
+   * Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { b: 5 }
    * ```
    *
    * @category combining
@@ -2208,14 +2034,10 @@ export const intersection: {
    *
    * **Example** (Merging intersecting keys)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b),
-   *   { b: 5 }
-   * )
+   * Record.intersection({ a: 1, b: 2 }, { b: 3, c: 4 }, (a, b) => a + b) // => { b: 5 }
    * ```
    *
    * @category combining
@@ -2252,14 +2074,10 @@ export const intersection: {
  *
  * **Example** (Keeping keys unique to each record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }),
- *   { a: 1, c: 4 }
- * )
+ * Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }) // => { a: 1, c: 4 }
  * ```
  *
  * @category combining
@@ -2272,14 +2090,10 @@ export const difference: {
    *
    * **Example** (Keeping keys unique to each record)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }),
-   *   { a: 1, c: 4 }
-   * )
+   * Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }) // => { a: 1, c: 4 }
    * ```
    *
    * @category combining
@@ -2292,14 +2106,10 @@ export const difference: {
    *
    * **Example** (Keeping keys unique to each record)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Record } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }),
-   *   { a: 1, c: 4 }
-   * )
+   * Record.difference({ a: 1, b: 2 }, { b: 3, c: 4 }) // => { a: 1, c: 4 }
    * ```
    *
    * @category combining
@@ -2336,14 +2146,13 @@ export const difference: {
  *
  * **Example** (Comparing records with a value equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equal, Record } from "effect"
- * import * as assert from "node:assert"
  *
  * const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence<number>())
  *
- * assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }), true)
- * assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }), false)
+ * recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true
+ * recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }) // => false
  * ```
  *
  * @category instances
@@ -2361,11 +2170,10 @@ export const makeEquivalence = <K extends string, A>(
  *
  * **Example** (Creating a singleton record)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Record } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Record.singleton("a", 1), { a: 1 })
+ * Record.singleton("a", 1) // => { a: 1 }
  * ```
  *
  * @category constructors
@@ -2440,18 +2248,17 @@ export function makeReducerIntersection<K extends string, A>(
  *
  * **Example** (Finding the first matching entry)
  *
- * ```ts
- * import { Record } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Record } from "effect"
  *
  * const record = { a: 1, b: 2, c: 3 }
- * const result = Record.findFirst(
+ * Record.findFirst(
  *   record,
  *   (value, key) => value > 1 && key !== "b"
- * )
- * console.log(result) // Option.Some(["c", 3])
+ * ) // => Option.some(["c", 3])
  * ```
  *
- * @category elements
+ * @category searching
  * @since 3.14.0
  */
 export const findFirst: {
@@ -2461,18 +2268,17 @@ export const findFirst: {
    *
    * **Example** (Finding the first matching entry)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const record = { a: 1, b: 2, c: 3 }
-   * const result = Record.findFirst(
+   * Record.findFirst(
    *   record,
    *   (value, key) => value > 1 && key !== "b"
-   * )
-   * console.log(result) // Option.Some(["c", 3])
+   * ) // => Option.some(["c", 3])
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 3.14.0
    */
   <K extends string | symbol, V, V2 extends V>(refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): (self: ReadonlyRecord<K, V>) => Option.Option<[K, V2]>
@@ -2482,18 +2288,17 @@ export const findFirst: {
    *
    * **Example** (Finding the first matching entry)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const record = { a: 1, b: 2, c: 3 }
-   * const result = Record.findFirst(
+   * Record.findFirst(
    *   record,
    *   (value, key) => value > 1 && key !== "b"
-   * )
-   * console.log(result) // Option.Some(["c", 3])
+   * ) // => Option.some(["c", 3])
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 3.14.0
    */
   <K extends string | symbol, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: ReadonlyRecord<K, V>) => Option.Option<[K, V]>
@@ -2503,18 +2308,17 @@ export const findFirst: {
    *
    * **Example** (Finding the first matching entry)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const record = { a: 1, b: 2, c: 3 }
-   * const result = Record.findFirst(
+   * Record.findFirst(
    *   record,
    *   (value, key) => value > 1 && key !== "b"
-   * )
-   * console.log(result) // Option.Some(["c", 3])
+   * ) // => Option.some(["c", 3])
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 3.14.0
    */
   <K extends string | symbol, V, V2 extends V>(
@@ -2527,18 +2331,17 @@ export const findFirst: {
    *
    * **Example** (Finding the first matching entry)
    *
-   * ```ts
-   * import { Record } from "effect"
+   * ```ts import.meta.vitest
+   * import { Option, Record } from "effect"
    *
    * const record = { a: 1, b: 2, c: 3 }
-   * const result = Record.findFirst(
+   * Record.findFirst(
    *   record,
    *   (value, key) => value > 1 && key !== "b"
-   * )
-   * console.log(result) // Option.Some(["c", 3])
+   * ) // => Option.some(["c", 3])
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 3.14.0
    */
   <K extends string | symbol, V>(