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

package/dist/Record.js

@@ -11,6 +11,7 @@
  */
 import * as Equal from "./Equal.js";
 import { dual, identity } from "./Function.js";
+import * as InternalRecord from "./internal/record.js";
 import * as Option from "./Option.js";
 import * as Reducer from "./Reducer.js";
 import * as R from "./Result.js";
@@ -19,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
@@ -40,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
@@ -57,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
@@ -75,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
@@ -94,7 +86,7 @@ export const fromIterableWith = /*#__PURE__*/dual(2, (self, f) => {
   const out = empty();
   for (const a of self) {
     const [k, b] = f(a);
-    out[k] = b;
+    InternalRecord.assignProperty(out, k, b);
   }
   return out;
 });
@@ -103,28 +95,24 @@ 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
  * @since 2.0.0
  */
-export const fromIterableBy = (items, f) => fromIterableWith(items, a => [f(a), a]);
+export const fromIterableBy = /*#__PURE__*/dual(2, (items, f) => fromIterableWith(items, a => [f(a), a]));
 /**
  * Builds a record from an iterable of key-value pairs.
  *
@@ -135,13 +123,10 @@ export const fromIterableBy = (items, f) => fromIterableWith(items, a => [f(a),
  *
  * **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
@@ -153,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
@@ -179,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
@@ -196,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
@@ -212,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));
@@ -229,35 +207,34 @@ 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
  * @since 2.0.0
  */
-export const get = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? Option.some(self[key]) : Option.none());
+export const get = /*#__PURE__*/dual(2, (self, key) => Object.hasOwn(self, key) ? Option.some(self[key]) : Option.none());
 /**
  * Applies a function to the element at the specified key safely, creating a new record,
  * or return `Option.none()` if the key doesn't exist.
  *
  * **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
@@ -281,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
@@ -306,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
@@ -335,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
@@ -353,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
@@ -374,7 +349,7 @@ export const map = /*#__PURE__*/dual(2, (self, f) => {
     ...self
   };
   for (const key of keys(self)) {
-    out[key] = f(self[key], key);
+    InternalRecord.assignProperty(out, key, f(self[key], key));
   }
   return out;
 });
@@ -383,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
@@ -400,7 +371,7 @@ export const mapKeys = /*#__PURE__*/dual(2, (self, f) => {
   const out = {};
   for (const key of keys(self)) {
     const a = self[key];
-    out[f(key, a)] = a;
+    InternalRecord.assignProperty(out, f(key, a), a);
   }
   return out;
 });
@@ -409,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
@@ -426,7 +393,7 @@ export const mapEntries = /*#__PURE__*/dual(2, (self, f) => {
   const out = {};
   for (const key of keys(self)) {
     const [k, b] = f(self[key], key);
-    out[k] = b;
+    InternalRecord.assignProperty(out, k, b);
   }
   return out;
 });
@@ -436,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
@@ -453,7 +419,7 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
   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;
@@ -463,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
@@ -478,7 +443,7 @@ export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
   const out = empty();
   for (const key of keys(self)) {
     if (predicate(self[key], key)) {
-      out[key] = self[key];
+      InternalRecord.assignProperty(out, key, self[key]);
     }
   }
   return out;
@@ -489,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
@@ -507,7 +468,7 @@ export const getSomes = self => {
   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;
@@ -518,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
@@ -540,7 +497,7 @@ export const getFailures = self => {
   for (const key of keys(self)) {
     const value = self[key];
     if (R.isFailure(value)) {
-      out[key] = value.failure;
+      InternalRecord.assignProperty(out, key, value.failure);
     }
   }
   return out;
@@ -551,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
@@ -573,7 +526,7 @@ export const getSuccesses = self => {
   for (const key of keys(self)) {
     const value = self[key];
     if (R.isSuccess(value)) {
-      out[key] = value.success;
+      InternalRecord.assignProperty(out, key, value.success);
     }
   }
   return out;
@@ -589,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
@@ -607,9 +559,9 @@ export const partition = /*#__PURE__*/dual(2, (self, f) => {
   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];
@@ -620,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
@@ -639,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
@@ -655,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
@@ -671,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
@@ -688,13 +633,49 @@ export const set = /*#__PURE__*/dual(3, (self, key, value) => {
     [key]: value
   };
 });
+/**
+ * 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 = 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(
@@ -707,15 +688,9 @@ export const set = /*#__PURE__*/dual(3, (self, key, value) => {
  *   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
@@ -739,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
@@ -762,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
@@ -787,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) => {
@@ -811,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
@@ -836,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
@@ -863,14 +821,14 @@ export const union = /*#__PURE__*/dual(3, (self, that, combine) => {
   const out = empty();
   for (const key of keys(self)) {
     if (has(that, key)) {
-      out[key] = combine(self[key], that[key]);
+      InternalRecord.assignProperty(out, key, combine(self[key], that[key]));
     } 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;
@@ -881,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
@@ -901,7 +855,7 @@ export const intersection = /*#__PURE__*/dual(3, (self, that, combine) => {
   }
   for (const key of keys(self)) {
     if (has(that, key)) {
-      out[key] = combine(self[key], that[key]);
+      InternalRecord.assignProperty(out, key, combine(self[key], that[key]));
     }
   }
   return out;
@@ -912,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
@@ -939,12 +889,12 @@ export const difference = /*#__PURE__*/dual(2, (self, that) => {
   const out = {};
   for (const key of keys(self)) {
     if (!has(that, key)) {
-      out[key] = self[key];
+      InternalRecord.assignProperty(out, key, self[key]);
     }
   }
   for (const key of keys(that)) {
     if (!has(self, key)) {
-      out[key] = that[key];
+      InternalRecord.assignProperty(out, key, that[key]);
     }
   }
   return out;
@@ -955,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
@@ -977,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
@@ -1045,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) => {