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

package/dist/Record.d.ts

@@ -22,7 +22,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
@@ -32,6 +32,7 @@ import type { NoInfer } from "./Types.ts";
  *   name: "John",
  *   age: 30
  * }
+ * user // => { name: "John", age: 30 }
  * ```
  *
  * @category models
@@ -46,7 +47,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
@@ -54,6 +55,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
@@ -68,7 +72,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'
@@ -76,6 +80,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
@@ -88,7 +96,7 @@ export declare namespace ReadonlyRecord {
      *
      * **Example** (Intersecting record keys)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import type { Record } from "effect"
      *
      * // Intersection of literal keys
@@ -96,6 +104,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
@@ -109,7 +120,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<
@@ -124,9 +135,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 {
@@ -137,16 +149,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
@@ -158,12 +169,11 @@ export declare const empty: <K extends string | symbol = never, V = never>() =>
  *
  * **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
@@ -175,12 +185,11 @@ export declare const isEmptyRecord: <K extends string, A>(self: Record<K, A>) =>
  *
  * **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
@@ -193,16 +202,10 @@ export declare const isEmptyReadonlyRecord: <K extends string, A>(self: Readonly
  *
  * **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
@@ -215,16 +218,10 @@ export declare 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
@@ -237,16 +234,10 @@ export declare 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
@@ -259,22 +250,18 @@ export declare 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
@@ -286,22 +273,18 @@ export declare 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
@@ -313,22 +296,18 @@ export declare 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
@@ -346,13 +325,10 @@ export declare 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
@@ -364,15 +340,11 @@ export declare 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
@@ -384,15 +356,11 @@ export declare 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
@@ -404,15 +372,11 @@ export declare 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
@@ -425,12 +389,11 @@ export declare 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
@@ -442,11 +405,10 @@ export declare const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>
  *
  * **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
@@ -458,15 +420,14 @@ export declare const size: <K extends string, A>(self: ReadonlyRecord<K, A>) =>
  *
  * **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 declare const has: {
@@ -475,15 +436,14 @@ export declare 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;
@@ -492,15 +452,14 @@ export declare 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;
@@ -510,14 +469,13 @@ export declare 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
@@ -529,14 +487,13 @@ export declare 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
@@ -548,14 +505,13 @@ export declare 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
@@ -569,15 +525,15 @@ export declare 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
@@ -590,15 +546,15 @@ export declare 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
@@ -611,15 +567,15 @@ export declare 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
@@ -638,11 +594,11 @@ export declare 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
@@ -660,11 +616,11 @@ export declare 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
@@ -682,11 +638,11 @@ export declare 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
@@ -708,11 +664,10 @@ export declare 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
@@ -733,11 +688,10 @@ export declare 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
@@ -758,11 +712,10 @@ export declare 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
@@ -777,13 +730,13 @@ export declare 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
@@ -797,13 +750,13 @@ export declare 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
@@ -817,13 +770,13 @@ export declare 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
@@ -836,17 +789,16 @@ export declare 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
@@ -858,17 +810,16 @@ export declare 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
@@ -880,17 +831,16 @@ export declare 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
@@ -903,14 +853,10 @@ export declare 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
@@ -922,14 +868,10 @@ export declare 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
@@ -941,14 +883,10 @@ export declare 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
@@ -961,14 +899,10 @@ export declare 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
@@ -980,14 +914,10 @@ export declare 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
@@ -999,14 +929,10 @@ export declare 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
@@ -1020,13 +946,12 @@ export declare 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
@@ -1039,13 +964,12 @@ export declare 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
@@ -1058,13 +982,12 @@ export declare 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
@@ -1077,12 +1000,11 @@ export declare 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
@@ -1094,12 +1016,11 @@ export declare 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
@@ -1111,12 +1032,11 @@ export declare 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
@@ -1128,12 +1048,11 @@ export declare 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
@@ -1145,12 +1064,11 @@ export declare 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
@@ -1164,14 +1082,10 @@ export declare 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
@@ -1184,18 +1098,14 @@ export declare const getSomes: <K extends string, A>(self: ReadonlyRecord<K, Opt
  *
  * **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
@@ -1208,18 +1118,14 @@ export declare const getFailures: <K extends string, A, E>(self: ReadonlyRecord<
  *
  * **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
@@ -1237,13 +1143,12 @@ export declare const getSuccesses: <K extends string, A, E>(self: ReadonlyRecord
  *
  * **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
@@ -1261,13 +1166,12 @@ export declare 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
@@ -1285,13 +1189,12 @@ export declare 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
@@ -1305,14 +1208,10 @@ export declare 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
@@ -1324,11 +1223,10 @@ export declare const separate: <K extends string, A, B>(self: ReadonlyRecord<K,
  *
  * **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
@@ -1340,11 +1238,10 @@ export declare const keys: <K extends string | symbol, A>(self: ReadonlyRecord<K
  *
  * **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
@@ -1356,12 +1253,11 @@ export declare const values: <K extends string, A>(self: ReadonlyRecord<K, 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
@@ -1373,12 +1269,11 @@ export declare 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
@@ -1390,12 +1285,11 @@ export declare 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
@@ -1418,21 +1312,20 @@ export declare 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
@@ -1446,7 +1339,7 @@ export declare const assignProperty: (self: object, key: PropertyKey, value: unk
  *
  * **Example** (Checking subrecords with a custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Record } from "effect"
  *
  * const isSubrecord = Record.isSubrecordBy(
@@ -1459,15 +1352,9 @@ export declare const assignProperty: (self: object, key: PropertyKey, value: unk
  *   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
@@ -1487,18 +1374,11 @@ export declare 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
@@ -1515,18 +1395,11 @@ export declare 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
@@ -1543,18 +1416,11 @@ export declare 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
@@ -1567,14 +1433,10 @@ export declare 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
@@ -1586,14 +1448,10 @@ export declare 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
@@ -1605,14 +1463,10 @@ export declare 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
@@ -1625,15 +1479,14 @@ export declare 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 declare const every: {
@@ -1642,15 +1495,14 @@ export declare 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>;
@@ -1659,15 +1511,14 @@ export declare 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;
@@ -1676,15 +1527,14 @@ export declare 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>;
@@ -1693,15 +1543,14 @@ export declare 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;
@@ -1711,12 +1560,11 @@ export declare 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
@@ -1728,12 +1576,11 @@ export declare 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
@@ -1745,12 +1592,11 @@ export declare 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
@@ -1764,14 +1610,10 @@ export declare 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
@@ -1784,14 +1626,10 @@ export declare 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
@@ -1804,14 +1642,10 @@ export declare 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
@@ -1825,14 +1659,10 @@ export declare 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
@@ -1845,14 +1675,10 @@ export declare 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
@@ -1865,14 +1691,10 @@ export declare 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
@@ -1886,14 +1708,10 @@ export declare 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
@@ -1906,14 +1724,10 @@ export declare 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
@@ -1926,14 +1740,10 @@ export declare 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
@@ -1947,14 +1757,13 @@ export declare 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
@@ -1966,11 +1775,10 @@ export declare const makeEquivalence: <K extends string, A>(equivalence: Equival
  *
  * **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
@@ -2028,18 +1836,17 @@ export declare function makeReducerIntersection<K extends string, A>(combiner: C
  *
  * **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 declare const findFirst: {
@@ -2049,18 +1856,17 @@ export declare 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]>;
@@ -2070,18 +1876,17 @@ export declare 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]>;
@@ -2091,18 +1896,17 @@ export declare 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>(self: ReadonlyRecord<K, V>, refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): Option.Option<[K, V2]>;
@@ -2112,18 +1916,17 @@ export declare 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>(self: ReadonlyRecord<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): Option.Option<[K, V]>;