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

package/dist/Record.js

@@ -20,16 +20,15 @@ import * as R from "./Result.js";
  *
  * **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
@@ -41,12 +40,11 @@ export const empty = () => ({});
  *
  * **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
@@ -58,12 +56,11 @@ export const isEmptyRecord = self => Object.keys(self).length === 0;
  *
  * **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
@@ -76,16 +73,10 @@ export const isEmptyReadonlyRecord = isEmptyRecord;
  *
  * **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
@@ -104,22 +95,18 @@ export const fromIterableWith = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -136,13 +123,10 @@ export const fromIterableBy = /*#__PURE__*/dual(2, (items, f) => fromIterableWit
  *
  * **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
@@ -154,15 +138,11 @@ export const fromEntries = Object.fromEntries;
  *
  * **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
@@ -180,12 +160,11 @@ export const collect = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -197,11 +176,10 @@ export const toEntries = /*#__PURE__*/collect((key, value) => [key, value]);
  *
  * **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
@@ -213,15 +191,14 @@ export const size = self => keys(self).length;
  *
  * **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 = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key));
@@ -230,14 +207,13 @@ export const has = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key))
  *
  * **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
@@ -250,15 +226,15 @@ export const get = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key)
  *
  * **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
@@ -282,11 +258,11 @@ export const modify = /*#__PURE__*/dual(3, (self, key, f) => {
  *
  * **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
@@ -307,11 +283,10 @@ export const replace = /*#__PURE__*/dual(3, (self, key, b) => modify(self, key,
  *
  * **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
@@ -336,13 +311,13 @@ export const remove = /*#__PURE__*/dual(2, (self, key) => {
  *
  * **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
@@ -354,17 +329,16 @@ export const pop = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? Option.s
  *
  * **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
@@ -384,14 +358,10 @@ export const map = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -410,14 +380,10 @@ export const mapKeys = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -437,13 +403,12 @@ export const mapEntries = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -464,12 +429,11 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -490,14 +454,10 @@ export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **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
@@ -519,18 +479,14 @@ export const getSomes = self => {
  *
  * **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
@@ -552,18 +508,14 @@ export const getFailures = self => {
  *
  * **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
@@ -590,13 +542,12 @@ export const getSuccesses = self => {
  *
  * **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
@@ -621,14 +572,10 @@ export const partition = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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
@@ -640,11 +587,10 @@ export const separate = /*#__PURE__*/partition(identity);
  *
  * **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
@@ -656,11 +602,10 @@ export const keys = self => Object.keys(self);
  *
  * **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
@@ -672,12 +617,11 @@ export const values = self => collect(self, (_, a) => 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
@@ -704,21 +648,20 @@ export const set = /*#__PURE__*/dual(3, (self, key, value) => {
  *
  * **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
@@ -732,7 +675,7 @@ export const assignProperty = InternalRecord.assignProperty;
  *
  * **Example** (Checking subrecords with a custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Record } from "effect"
  *
  * const isSubrecord = Record.isSubrecordBy(
@@ -745,15 +688,9 @@ export const assignProperty = InternalRecord.assignProperty;
  *   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
@@ -777,18 +714,11 @@ export const isSubrecordBy = equivalence => dual(2, (self, that) => {
  *
  * **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
@@ -800,14 +730,10 @@ export const isSubrecord = /*#__PURE__*/isSubrecordBy(/*#__PURE__*/Equal.asEquiv
  *
  * **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
@@ -825,15 +751,14 @@ export const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {
  *
  * **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 = /*#__PURE__*/dual(2, (self, refinement) => {
@@ -849,12 +774,11 @@ export const every = /*#__PURE__*/dual(2, (self, refinement) => {
  *
  * **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
@@ -874,14 +798,10 @@ export const some = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **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
@@ -919,14 +839,10 @@ export const union = /*#__PURE__*/dual(3, (self, that, combine) => {
  *
  * **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
@@ -950,14 +866,10 @@ export const intersection = /*#__PURE__*/dual(3, (self, that, combine) => {
  *
  * **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
@@ -993,14 +905,13 @@ export const difference = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **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
@@ -1015,11 +926,10 @@ export const makeEquivalence = equivalence => {
  *
  * **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
@@ -1083,18 +993,17 @@ export function makeReducerIntersection(combiner) {
  *
  * **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 = /*#__PURE__*/dual(2, (self, f) => {