effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/Record.ts

@@ -15,6 +15,7 @@ import * as Equal from "./Equal.ts"
 import type { Equivalence } from "./Equivalence.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Option from "./Option.ts"
 import * as Reducer from "./Reducer.ts"
 import type { Result } from "./Result.ts"
@@ -27,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
@@ -37,6 +38,7 @@ import type { NoInfer } from "./Types.ts"
  *   name: "John",
  *   age: 30
  * }
+ * user // => { name: "John", age: 30 }
  * ```
  *
  * @category models
@@ -52,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
@@ -60,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
@@ -76,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'
@@ -84,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
@@ -98,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
@@ -106,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
@@ -122,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<
@@ -137,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 {
@@ -151,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
@@ -176,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
@@ -195,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
@@ -216,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
@@ -238,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
@@ -260,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
@@ -285,7 +277,7 @@ export const fromIterableWith: {
     const out: Record<string, B> = empty()
     for (const a of self) {
       const [k, b] = f(a)
-      out[k] = b
+      InternalRecord.assignProperty(out, k, b)
     }
     return out
   }
@@ -296,31 +288,77 @@ 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
  * @since 2.0.0
  */
-export const fromIterableBy = <A, K extends string | symbol>(
-  items: Iterable<A>,
-  f: (a: A) => K
-): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
+export const fromIterableBy: {
+  /**
+   * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
+   *
+   * **Example** (Building a record keyed by iterable values)
+   *
+   * ```ts import.meta.vitest
+   * import { Record } from "effect"
+   *
+   * const users = [
+   *   { id: "2", name: "name2" },
+   *   { id: "1", name: "name1" }
+   * ]
+   *
+   * Record.fromIterableBy(
+   *   users,
+   *   (user) => user.id
+   * ) // => { "1": { id: "1", name: "name1" }, "2": { id: "2", name: "name2" } }
+   * ```
+   *
+   * @category constructors
+   * @since 2.0.0
+   */
+  <A, K extends string | symbol>(f: (a: A) => K): (items: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  /**
+   * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
+   *
+   * **Example** (Building a record keyed by iterable values)
+   *
+   * ```ts import.meta.vitest
+   * import { Record } from "effect"
+   *
+   * const users = [
+   *   { id: "2", name: "name2" },
+   *   { id: "1", name: "name1" }
+   * ]
+   *
+   * Record.fromIterableBy(
+   *   users,
+   *   (user) => user.id
+   * ) // => { "1": { id: "1", name: "name1" }, "2": { id: "2", name: "name2" } }
+   * ```
+   *
+   * @category constructors
+   * @since 2.0.0
+   */
+  <A, K extends string | symbol>(items: Iterable<A>, f: (a: A) => K): Record<ReadonlyRecord.NonLiteralKey<K>, A>
+} = dual(
+  2,
+  <A, K extends string | symbol>(
+    items: Iterable<A>,
+    f: (a: A) => K
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
+)
 
 /**
  * Builds a record from an iterable of key-value pairs.
@@ -332,13 +370,10 @@ export const fromIterableBy = <A, K extends string | symbol>(
  *
  * **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
@@ -353,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
@@ -373,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
@@ -393,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
@@ -424,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
@@ -445,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
@@ -462,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: {
@@ -479,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
@@ -496,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
@@ -521,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
@@ -540,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
@@ -559,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
@@ -576,7 +591,7 @@ export const get: {
 } = dual(
   2,
   <K extends string | symbol, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A> =>
-    has(self, key) ? Option.some(self[key]) : Option.none()
+    Object.hasOwn(self, key) ? Option.some(self[key]) : Option.none()
 )
 
 /**
@@ -585,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
@@ -606,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
@@ -627,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
@@ -665,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
@@ -687,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
@@ -709,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
@@ -743,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
@@ -768,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
@@ -793,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
@@ -823,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
@@ -843,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
@@ -863,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
@@ -887,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
@@ -909,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
@@ -931,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
@@ -953,7 +962,7 @@ export const map: {
   <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B> => {
     const out: Record<K, B> = { ...self } as any
     for (const key of keys(self)) {
-      out[key] = f(self[key], key)
+      InternalRecord.assignProperty(out, key, f(self[key], key))
     }
     return out
   }
@@ -964,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
@@ -983,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
@@ -1002,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
@@ -1025,7 +1022,7 @@ export const mapKeys: {
     const out: Record<K2, A> = {} as any
     for (const key of keys(self)) {
       const a = self[key]
-      out[f(key, a)] = a
+      InternalRecord.assignProperty(out, f(key, a), a)
     }
     return out
   }
@@ -1036,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
@@ -1055,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
@@ -1074,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
@@ -1097,7 +1082,7 @@ export const mapEntries: {
     const out = {} as Record<K2, B>
     for (const key of keys(self)) {
       const [k, b] = f(self[key], key)
-      out[k] = b
+      InternalRecord.assignProperty(out, k, b)
     }
     return out
   }
@@ -1109,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
@@ -1128,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
@@ -1147,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
@@ -1170,7 +1152,7 @@ export const filterMap: {
     for (const key of keys(self)) {
       const result = f(self[key], key)
       if (R.isSuccess(result)) {
-        out[key] = result.success
+        InternalRecord.assignProperty(out, key, result.success)
       }
     }
     return out
@@ -1182,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
@@ -1199,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
@@ -1216,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
@@ -1233,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
@@ -1250,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
@@ -1271,7 +1248,7 @@ export const filter: {
     const out: Record<string, A> = empty()
     for (const key of keys(self)) {
       if (predicate(self[key], key)) {
-        out[key] = self[key]
+        InternalRecord.assignProperty(out, key, self[key])
       }
     }
     return out
@@ -1284,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
@@ -1306,7 +1279,7 @@ export const getSomes: <K extends string, A>(
   for (const key of keys(self)) {
     const option = self[key]
     if (Option.isSome(option)) {
-      out[key] = option.value
+      InternalRecord.assignProperty(out, key, option.value)
     }
   }
   return out
@@ -1318,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
@@ -1342,7 +1311,7 @@ export const getFailures = <K extends string, A, E>(
   for (const key of keys(self)) {
     const value = self[key]
     if (R.isFailure(value)) {
-      out[key] = value.failure
+      InternalRecord.assignProperty(out, key, value.failure)
     }
   }
 
@@ -1355,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
@@ -1379,7 +1344,7 @@ export const getSuccesses = <K extends string, A, E>(
   for (const key of keys(self)) {
     const value = self[key]
     if (R.isSuccess(value)) {
-      out[key] = value.success
+      InternalRecord.assignProperty(out, key, value.success)
     }
   }
 
@@ -1397,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
@@ -1421,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
@@ -1447,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
@@ -1471,9 +1433,9 @@ export const partition: {
     for (const key of keys(self)) {
       const e = f(self[key], key)
       if (R.isFailure(e)) {
-        left[key] = e.failure
+        InternalRecord.assignProperty(left, key, e.failure)
       } else {
-        right[key] = e.success
+        InternalRecord.assignProperty(right, key, e.success)
       }
     }
     return [left, right]
@@ -1486,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
@@ -1508,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
@@ -1526,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
@@ -1543,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
@@ -1560,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
@@ -1577,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
@@ -1600,13 +1553,50 @@ export const set: {
   }
 )
 
+/**
+ * Mutates a record by assigning a value to a property.
+ *
+ * **When to use**
+ *
+ * Use when incrementally constructing a new record and copying it for every
+ * property would be unnecessary.
+ *
+ * **Gotchas**
+ *
+ * This function mutates `self`. When `key` is `"__proto__"`, it creates an
+ * own data property instead of changing the object's prototype.
+ *
+ * **Example** (Assigning an external key safely)
+ *
+ * ```ts import.meta.vitest
+ * import { Record } from "effect"
+ *
+ * const key: string = "__proto__" // Assume this comes from external input
+ * const value = { polluted: true }
+ *
+ * const unsafe: Record<string, unknown> = {}
+ * unsafe[key] = value
+ * Object.getPrototypeOf(unsafe) === value // => true
+ *
+ * const safe: Record<string, unknown> = {}
+ * Record.assignProperty(safe, key, value)
+ * Object.getPrototypeOf(safe) === Object.prototype // => true
+ * safe[key] === value // => true
+ * ```
+ *
+ * @see {@link set} for an immutable update
+ * @category mutations
+ * @since 4.0.0
+ */
+export const assignProperty: (self: object, key: PropertyKey, value: unknown) => void = InternalRecord.assignProperty
+
 /**
  * Checks whether all the keys and values in one record are also found in another record.
  * Uses the provided equivalence function to compare values.
  *
  * **Example** (Checking subrecords with a custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Record } from "effect"
  *
  * const isSubrecord = Record.isSubrecordBy(
@@ -1619,15 +1609,9 @@ export const set: {
  *   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
@@ -1656,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
@@ -1684,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
@@ -1712,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
@@ -1737,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
@@ -1756,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
@@ -1775,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
@@ -1813,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: {
@@ -1830,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>
@@ -1847,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
@@ -1864,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>
@@ -1881,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
@@ -1913,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
@@ -1930,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
@@ -1947,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
@@ -1977,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
@@ -1997,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
@@ -2017,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
@@ -2051,14 +1982,14 @@ export const union: {
     const out: Record<string, A | B | C> = empty()
     for (const key of keys(self)) {
       if (has(that, key as any)) {
-        out[key] = combine(self[key], that[key as unknown as K1])
+        InternalRecord.assignProperty(out, key, combine(self[key], that[key as unknown as K1]))
       } else {
-        out[key] = self[key]
+        InternalRecord.assignProperty(out, key, self[key])
       }
     }
     for (const key of keys(that)) {
       if (!has(out, key)) {
-        out[key] = that[key]
+        InternalRecord.assignProperty(out, key, that[key])
       }
     }
     return out
@@ -2071,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
@@ -2091,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
@@ -2111,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
@@ -2142,7 +2061,7 @@ export const intersection: {
     }
     for (const key of keys(self)) {
       if (has(that, key as any)) {
-        out[key] = combine(self[key], that[key as unknown as K1])
+        InternalRecord.assignProperty(out, key, combine(self[key], that[key as unknown as K1]))
       }
     }
     return out
@@ -2155,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
@@ -2175,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
@@ -2195,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
@@ -2222,12 +2129,12 @@ export const difference: {
   const out = {} as Record<K0 | K1, A | B>
   for (const key of keys(self)) {
     if (!has(that, key as any)) {
-      out[key] = self[key]
+      InternalRecord.assignProperty(out, key, self[key])
     }
   }
   for (const key of keys(that)) {
     if (!has(self, key as any)) {
-      out[key] = that[key]
+      InternalRecord.assignProperty(out, key, that[key])
     }
   }
   return out
@@ -2239,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
@@ -2264,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
@@ -2343,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: {
@@ -2364,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]>
@@ -2385,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]>
@@ -2406,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>(
@@ -2430,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>(