footprintjs 9.44.1 → 9.44.2

package/dist/esm/lib/memory/equality.d.ts

@@ -1,8 +1,10 @@
 /**
- * equality.ts — structural equality of committed-state values. A leaf (L0,
- * imports nothing): what `TransactionBuffer`'s net-change filter, the admitted
- * record's compare and the borrowed-mutation guard all ask. Re-exported from
- * `utils.ts`, so no importer moved.
+ * equality.ts — structural equality of committed-state values: THE owner of
+ * "what counts as a change". What `TransactionBuffer`'s net-change filter, the
+ * admitted record's compare, the read model's writer rule and the
+ * borrowed-mutation guard all ask. Its one import is the classifier of value
+ * kinds (`capture/valueKinds.ts`, a leaf); re-exported from `utils.ts`, so no
+ * importer moved.
  */
 /**
  * Structural deep equality for committed-state values.
@@ -10,26 +12,42 @@
  * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED
  * a path or merely re-wrote / reverted it to the value it already held (a
  * "no-op write"), and by `borrowedMutation.firstDifferingPath` to find where a
- * borrowed read moved. Committed state must survive `structuredClone`, and
- * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state
- * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must
- * tell two of them apart. Before 9.22.0 it compared them as plain objects, and
- * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was "equal", so
- * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —
- * no trace row, state unchanged — and a `setFullYear` in place slipped past
- * the dev-mode guard.
+ * borrowed read moved. Committed state must survive `structuredClone`, so the
+ * values it can hold are the kinds the clone keeps, and two values are equal
+ * when a record holds the same thing for both. Every kind has ONE arm below
+ * (`equalPairs`' switch over `ValueKind` — a kind added to the union does not
+ * compile until it is compared). Before 9.22.0 a Date, Map or Set was compared
+ * as an object with no own keys, and until 9.44.2 so were a RegExp, an Error,
+ * a boxed primitive, an ArrayBuffer, a DataView and a Blob: any two of a kind
+ * were "equal", so `$setValue('re', /y/g)` over `/x/g` committed no row and
+ * live state kept the OLD value.
  *
  * Semantics:
  *   - reference / identical-primitive short-circuits first (cheap fast path)
  *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)
+ *   - two values of different KINDS are never equal (a `Date` is never `{}`,
+ *     an array never `{ 0: … }`)
  *   - `Date`: same `getTime()` (two invalid dates are equal)
+ *   - `RegExp`: same `source` and `flags` (the clone resets `lastIndex`)
+ *   - `Error`: the same restored kind (one of the six built-in error names,
+ *     else `Error`), own `message`, `stack` and own `cause` (deep) — what the
+ *     clone keeps; any other own field is dropped by it, so it never counts
+ *     (the admitted record's law)
+ *   - a boxed primitive: the same wrapper type and the same primitive inside
+ *   - an `ArrayBuffer`: length, resizability and bytes; a typed array or a
+ *     `DataView`: its type and the bytes IT views — never the rest of its
+ *     buffer (a Node `Buffer` views a slice of a shared pool, and the record
+ *     keeps the view's bytes only: `capture/freeze.ts · freezeRecord`)
  *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —
  *     keys by `Map` identity (`SameValueZero`), values deep
  *   - `Set`: same size AND every member of `a` is deep-equal to SOME member
  *     of `b` (order-insensitive — a Set has no order to compare by)
- *   - a typed value against a plain value, or two different typed kinds → not
- *     equal (a `Date` is never `{}`)
- *   - arrays: equal length AND deep-equal element-wise (order-sensitive)
+ *   - an OPAQUE value (a Blob, a `DOMException` — content this library cannot
+ *     read): by the caller's {@link OpaqueRule} — equal only to itself by
+ *     default (replacing one is always a change), or, when both sides are
+ *     copies of one record, equal to any other of its kind
+ *   - arrays: equal length AND deep-equal element-wise (order-sensitive; an
+ *     array's expando keys are out of contract and not compared)
  *   - objects: identical set of keys that HOLD a value AND deep-equal per key.
  *     An own key whose value is `undefined` counts as ABSENT: it is this
  *     library's other spelling of a deleted key (`'full'` mode flattens
@@ -38,11 +56,13 @@
  *     mirror — reads the two spellings as one state. So must the net-change
  *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays
  *     are untouched — a slot holding `undefined` is still a slot.
- *   - mismatched kinds (array vs object, object vs null) → not equal
  *
  * Cost & safety:
- *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is
- *     strictly cheaper than the `structuredClone` the commit already performs.
+ *   - Allocates only transient `Object.keys` arrays, an error's property
+ *     descriptors and a byte view per compared buffer — no clones (but one
+ *     probe clone per class prototype, remembered: `capture/valueKinds.ts ·
+ *     kindOf`). It is strictly cheaper than the `structuredClone` the commit
+ *     already performs.
  *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /
  *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded
  *     by the value's own size.
@@ -54,4 +74,20 @@
  *     change. Dev mode still warns about cycles at write time
  *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.
  */
-export declare function deepEqual(a: any, b: any): boolean;
+export declare function deepEqual(a: any, b: any, opaque?: OpaqueRule): boolean;
+/**
+ * How {@link deepEqual} compares two OPAQUE values (a Blob, a `DOMException` —
+ * content this library cannot read):
+ *
+ *   - `'identity'` (the default) — equal only to itself. The answer when one
+ *     side is a value a stage handed in: the net-change filter
+ *     (`TransactionBuffer`), the append check (`deltaEncoding`). A new object
+ *     is a change, because nothing can say it is not.
+ *   - `'copies'` — equal to any other of its kind. The answer when BOTH sides
+ *     are copies of one recorded value — a fold's generations (`logModel`,
+ *     `elementProvenance`), a retained read against live state
+ *     (`borrowedMutation`), the record replayed against the read-back
+ *     (`admission`): copies never share identity, so identity would call every
+ *     opaque value changed.
+ */
+export type OpaqueRule = 'identity' | 'copies';

package/dist/esm/lib/memory/equality.js

@@ -1,35 +1,54 @@
 /**
- * equality.ts — structural equality of committed-state values. A leaf (L0,
- * imports nothing): what `TransactionBuffer`'s net-change filter, the admitted
- * record's compare and the borrowed-mutation guard all ask. Re-exported from
- * `utils.ts`, so no importer moved.
+ * equality.ts — structural equality of committed-state values: THE owner of
+ * "what counts as a change". What `TransactionBuffer`'s net-change filter, the
+ * admitted record's compare, the read model's writer rule and the
+ * borrowed-mutation guard all ask. Its one import is the classifier of value
+ * kinds (`capture/valueKinds.ts`, a leaf); re-exported from `utils.ts`, so no
+ * importer moved.
  */
+import { kindOf } from '../capture/valueKinds.js';
 /**
  * Structural deep equality for committed-state values.
  *
  * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED
  * a path or merely re-wrote / reverted it to the value it already held (a
  * "no-op write"), and by `borrowedMutation.firstDifferingPath` to find where a
- * borrowed read moved. Committed state must survive `structuredClone`, and
- * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state
- * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must
- * tell two of them apart. Before 9.22.0 it compared them as plain objects, and
- * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was "equal", so
- * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —
- * no trace row, state unchanged — and a `setFullYear` in place slipped past
- * the dev-mode guard.
+ * borrowed read moved. Committed state must survive `structuredClone`, so the
+ * values it can hold are the kinds the clone keeps, and two values are equal
+ * when a record holds the same thing for both. Every kind has ONE arm below
+ * (`equalPairs`' switch over `ValueKind` — a kind added to the union does not
+ * compile until it is compared). Before 9.22.0 a Date, Map or Set was compared
+ * as an object with no own keys, and until 9.44.2 so were a RegExp, an Error,
+ * a boxed primitive, an ArrayBuffer, a DataView and a Blob: any two of a kind
+ * were "equal", so `$setValue('re', /y/g)` over `/x/g` committed no row and
+ * live state kept the OLD value.
  *
  * Semantics:
  *   - reference / identical-primitive short-circuits first (cheap fast path)
  *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)
+ *   - two values of different KINDS are never equal (a `Date` is never `{}`,
+ *     an array never `{ 0: … }`)
  *   - `Date`: same `getTime()` (two invalid dates are equal)
+ *   - `RegExp`: same `source` and `flags` (the clone resets `lastIndex`)
+ *   - `Error`: the same restored kind (one of the six built-in error names,
+ *     else `Error`), own `message`, `stack` and own `cause` (deep) — what the
+ *     clone keeps; any other own field is dropped by it, so it never counts
+ *     (the admitted record's law)
+ *   - a boxed primitive: the same wrapper type and the same primitive inside
+ *   - an `ArrayBuffer`: length, resizability and bytes; a typed array or a
+ *     `DataView`: its type and the bytes IT views — never the rest of its
+ *     buffer (a Node `Buffer` views a slice of a shared pool, and the record
+ *     keeps the view's bytes only: `capture/freeze.ts · freezeRecord`)
  *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —
  *     keys by `Map` identity (`SameValueZero`), values deep
  *   - `Set`: same size AND every member of `a` is deep-equal to SOME member
  *     of `b` (order-insensitive — a Set has no order to compare by)
- *   - a typed value against a plain value, or two different typed kinds → not
- *     equal (a `Date` is never `{}`)
- *   - arrays: equal length AND deep-equal element-wise (order-sensitive)
+ *   - an OPAQUE value (a Blob, a `DOMException` — content this library cannot
+ *     read): by the caller's {@link OpaqueRule} — equal only to itself by
+ *     default (replacing one is always a change), or, when both sides are
+ *     copies of one record, equal to any other of its kind
+ *   - arrays: equal length AND deep-equal element-wise (order-sensitive; an
+ *     array's expando keys are out of contract and not compared)
  *   - objects: identical set of keys that HOLD a value AND deep-equal per key.
  *     An own key whose value is `undefined` counts as ABSENT: it is this
  *     library's other spelling of a deleted key (`'full'` mode flattens
@@ -38,11 +57,13 @@
  *     mirror — reads the two spellings as one state. So must the net-change
  *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays
  *     are untouched — a slot holding `undefined` is still a slot.
- *   - mismatched kinds (array vs object, object vs null) → not equal
  *
  * Cost & safety:
- *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is
- *     strictly cheaper than the `structuredClone` the commit already performs.
+ *   - Allocates only transient `Object.keys` arrays, an error's property
+ *     descriptors and a byte view per compared buffer — no clones (but one
+ *     probe clone per class prototype, remembered: `capture/valueKinds.ts ·
+ *     kindOf`). It is strictly cheaper than the `structuredClone` the commit
+ *     already performs.
  *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /
  *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded
  *     by the value's own size.
@@ -54,10 +75,10 @@
  *     change. Dev mode still warns about cycles at write time
  *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.
  */
-export function deepEqual(a, b) {
-    return equalPairs(a, b, undefined);
+export function deepEqual(a, b, opaque = 'identity') {
+    return equalPairs(a, b, undefined, opaque);
 }
-function equalPairs(a, b, seen) {
+function equalPairs(a, b, seen, opaque) {
     if (a === b)
         return true; // same reference or identical primitive
     if (typeof a !== typeof b)
@@ -66,16 +87,35 @@ function equalPairs(a, b, seen) {
         return a === b; // one is null, the other isn't
     if (typeof a !== 'object')
         return Object.is(a, b); // NaN-safe primitive compare
-    // Typed arms first — a Date/Map/Set has no own enumerable keys, so the
-    // plain-object walk below would call any two of them equal.
-    const aKind = typedKind(a);
-    if (aKind !== typedKind(b))
+    const kind = kindOf(a);
+    if (kind !== kindOf(b))
         return false;
-    if (aKind === 'date')
-        return Object.is(a.getTime(), b.getTime());
-    const aIsArray = Array.isArray(a);
-    if (aIsArray !== Array.isArray(b))
-        return false; // array vs plain object
+    switch (kind) {
+        // Atoms: their content is a slot, not their keys.
+        case 'date':
+            return Object.is(Date.prototype.getTime.call(a), Date.prototype.getTime.call(b));
+        case 'regexp':
+            return a.source === b.source && a.flags === b.flags;
+        case 'boxed':
+            return tagOf(a) === tagOf(b) && equalPairs(a.valueOf(), b.valueOf(), seen, opaque);
+        case 'buffer':
+            return equalBuffers(a, b);
+        case 'view':
+            return equalViews(a, b);
+        case 'opaque':
+            return opaque === 'copies' && tagOf(a) === tagOf(b); // `a === b` was answered above
+        case 'plain':
+        case 'array':
+        case 'map':
+        case 'set':
+        case 'error':
+            return equalContainers(a, b, kind, seen, opaque);
+        default:
+            return unknownKind(kind);
+    }
+}
+/** The kinds whose content is other values: compared part by part, under the cycle guard. */
+function equalContainers(a, b, kind, seen, opaque) {
     // Cycle guard — a pair we are already inside is equal by assumption.
     seen ??= new WeakMap();
     let partners = seen.get(a);
@@ -84,15 +124,17 @@ function equalPairs(a, b, seen) {
     if (!partners)
         seen.set(a, (partners = new WeakSet()));
     partners.add(b);
-    if (aKind === 'map')
-        return equalMaps(a, b, seen);
-    if (aKind === 'set')
-        return equalSets(a, b, seen);
-    if (aIsArray) {
+    if (kind === 'map')
+        return equalMaps(a, b, seen, opaque);
+    if (kind === 'set')
+        return equalSets(a, b, seen, opaque);
+    if (kind === 'error')
+        return equalErrors(a, b, seen, opaque);
+    if (kind === 'array') {
         if (a.length !== b.length)
             return false;
         for (let i = 0; i < a.length; i++) {
-            if (!equalPairs(a[i], b[i], seen))
+            if (!equalPairs(a[i], b[i], seen, opaque))
                 return false;
         }
         return true;
@@ -106,7 +148,7 @@ function equalPairs(a, b, seen) {
         aHeld++;
         if (!Object.prototype.hasOwnProperty.call(b, key))
             return false;
-        if (!equalPairs(a[key], b[key], seen))
+        if (!equalPairs(a[key], b[key], seen, opaque))
             return false;
     }
     let bHeld = 0;
@@ -115,23 +157,84 @@ function equalPairs(a, b, seen) {
             bHeld++;
     return aHeld === bHeld;
 }
-/** The typed state values `structuredClone` keeps and a key walk cannot see. */
-function typedKind(value) {
-    if (value instanceof Date)
-        return 'date';
-    if (value instanceof Map)
-        return 'map';
-    if (value instanceof Set)
-        return 'set';
-    return undefined;
+function unknownKind(kind) {
+    throw new TypeError(`deepEqual: no comparison for the value kind '${String(kind)}'`);
+}
+/** `[object Number]`, `[object Uint8Array]` … — the built-in type a boxed value or a view carries. */
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+/** The same view type over the same bytes — the bytes the view sees, wherever they sit in its buffer. */
+function equalViews(a, b) {
+    if (tagOf(a) !== tagOf(b) || a.byteLength !== b.byteLength)
+        return false;
+    if (a.buffer === b.buffer && a.byteOffset === b.byteOffset)
+        return true;
+    const p = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+    const q = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+    for (let i = 0; i < p.length; i++)
+        if (p[i] !== q[i])
+            return false;
+    return true;
+}
+/** The same length, resizability and bytes. */
+function equalBuffers(a, b) {
+    if (a === b)
+        return true;
+    const x = a;
+    const y = b;
+    if (x.byteLength !== y.byteLength || x.resizable !== y.resizable || x.maxByteLength !== y.maxByteLength) {
+        return false;
+    }
+    const p = new Uint8Array(a);
+    const q = new Uint8Array(b);
+    for (let i = 0; i < p.length; i++)
+        if (p[i] !== q[i])
+            return false;
+    return true;
+}
+/** The six error names `structuredClone` restores; any other name comes back an `Error`. */
+const ERROR_NAMES = new Set(['EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError']);
+/**
+ * Two errors as the clone keeps them: the restored kind, the own `message`,
+ * the `stack` and the own `cause` (deep). Any other own field is dropped by
+ * the clone, so it never counts.
+ */
+function equalErrors(a, b, seen, opaque) {
+    if (errorKindOf(a) !== errorKindOf(b) || stackOf(a) !== stackOf(b))
+        return false;
+    const aMessage = ownData(a, 'message');
+    const bMessage = ownData(b, 'message');
+    if (String(aMessage?.value) !== String(bMessage?.value) || !aMessage !== !bMessage)
+        return false;
+    const aCause = ownData(a, 'cause');
+    const bCause = ownData(b, 'cause');
+    if (!aCause || !bCause)
+        return !aCause === !bCause;
+    return equalPairs(aCause.value, bCause.value, seen, opaque);
+}
+function errorKindOf(error) {
+    const name = String(error.name);
+    return ERROR_NAMES.has(name) ? name : 'Error';
+}
+function stackOf(error) {
+    const stack = error.stack;
+    return typeof stack === 'string' ? stack : undefined;
+}
+/** An own DATA property, boxed — how the clone reads an error's `message` and `cause`. */
+function ownData(value, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+        ? { value: descriptor.value }
+        : undefined;
 }
-function equalMaps(a, b, seen) {
+function equalMaps(a, b, seen, opaque) {
     if (a.size !== b.size)
         return false;
     for (const [key, value] of a) {
         if (!b.has(key))
             return false;
-        if (!equalPairs(value, b.get(key), seen))
+        if (!equalPairs(value, b.get(key), seen, opaque))
             return false;
     }
     return true;
@@ -140,7 +243,7 @@ function equalMaps(a, b, seen) {
  * Order-insensitive, deep per member. Quadratic in the worst case for sets of
  * objects — a set of primitives (the common shape) is one `has` per member.
  */
-function equalSets(a, b, seen) {
+function equalSets(a, b, seen, opaque) {
     if (a.size !== b.size)
         return false;
     const unmatched = [...b];
@@ -149,11 +252,11 @@ function equalSets(a, b, seen) {
         // Each match retires its slot so two structurally-equal members of `a`
         // cannot both claim the same member of `b`.
         const at = unmatched.indexOf(member);
-        const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));
+        const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen, opaque));
         if (found < 0)
             return false;
         unmatched.splice(found, 1);
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"equality.js","sourceRoot":"","sources":["../../../../src/lib/memory/equality.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * equality.ts — structural equality of committed-state values. A leaf (L0,\n * imports nothing): what `TransactionBuffer`'s net-change filter, the admitted\n * record's compare and the borrowed-mutation guard all ask. Re-exported from\n * `utils.ts`, so no importer moved.\n */\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, and\n * `structuredClone` keeps `Date`, `Map` and `Set` — so those are legal state\n * values (a `$setValue` bypasses the proxy's JSON round-trip) and this must\n * tell two of them apart. Before 9.22.0 it compared them as plain objects, and\n * a `Date`/`Map`/`Set` has no own enumerable keys: every pair was \"equal\", so\n * `$setValue('k', new Date(1999))` over a 2020 date was dropped as a no-op —\n * no trace row, state unchanged — and a `setFullYear` in place slipped past\n * the dev-mode guard.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - a typed value against a plain value, or two different typed kinds → not\n *     equal (a `Date` is never `{}`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  // Typed arms first — a Date/Map/Set has no own enumerable keys, so the\n  // plain-object walk below would call any two of them equal.\n  const aKind = typedKind(a);\n  if (aKind !== typedKind(b)) return false;\n  if (aKind === 'date') return Object.is(a.getTime(), b.getTime());\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aKind === 'map') return equalMaps(a, b, seen);\n  if (aKind === 'set') return equalSets(a, b, seen);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\n/** The typed state values `structuredClone` keeps and a key walk cannot see. */\nfunction typedKind(value: object): 'date' | 'map' | 'set' | undefined {\n  if (value instanceof Date) return 'date';\n  if (value instanceof Map) return 'map';\n  if (value instanceof Set) return 'set';\n  return undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"equality.js","sourceRoot":"","sources":["../../../../src/lib/memory/equality.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * equality.ts — structural equality of committed-state values: THE owner of\n * \"what counts as a change\". What `TransactionBuffer`'s net-change filter, the\n * admitted record's compare, the read model's writer rule and the\n * borrowed-mutation guard all ask. Its one import is the classifier of value\n * kinds (`capture/valueKinds.ts`, a leaf); re-exported from `utils.ts`, so no\n * importer moved.\n */\n\nimport { type ValueKind, kindOf } from '../capture/valueKinds.js';\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"), and by `borrowedMutation.firstDifferingPath` to find where a\n * borrowed read moved. Committed state must survive `structuredClone`, so the\n * values it can hold are the kinds the clone keeps, and two values are equal\n * when a record holds the same thing for both. Every kind has ONE arm below\n * (`equalPairs`' switch over `ValueKind` — a kind added to the union does not\n * compile until it is compared). Before 9.22.0 a Date, Map or Set was compared\n * as an object with no own keys, and until 9.44.2 so were a RegExp, an Error,\n * a boxed primitive, an ArrayBuffer, a DataView and a Blob: any two of a kind\n * were \"equal\", so `$setValue('re', /y/g)` over `/x/g` committed no row and\n * live state kept the OLD value.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - two values of different KINDS are never equal (a `Date` is never `{}`,\n *     an array never `{ 0: … }`)\n *   - `Date`: same `getTime()` (two invalid dates are equal)\n *   - `RegExp`: same `source` and `flags` (the clone resets `lastIndex`)\n *   - `Error`: the same restored kind (one of the six built-in error names,\n *     else `Error`), own `message`, `stack` and own `cause` (deep) — what the\n *     clone keeps; any other own field is dropped by it, so it never counts\n *     (the admitted record's law)\n *   - a boxed primitive: the same wrapper type and the same primitive inside\n *   - an `ArrayBuffer`: length, resizability and bytes; a typed array or a\n *     `DataView`: its type and the bytes IT views — never the rest of its\n *     buffer (a Node `Buffer` views a slice of a shared pool, and the record\n *     keeps the view's bytes only: `capture/freeze.ts · freezeRecord`)\n *   - `Map`: same size AND, per key of `a`, `b` holds a deep-equal value —\n *     keys by `Map` identity (`SameValueZero`), values deep\n *   - `Set`: same size AND every member of `a` is deep-equal to SOME member\n *     of `b` (order-insensitive — a Set has no order to compare by)\n *   - an OPAQUE value (a Blob, a `DOMException` — content this library cannot\n *     read): by the caller's {@link OpaqueRule} — equal only to itself by\n *     default (replacing one is always a change), or, when both sides are\n *     copies of one record, equal to any other of its kind\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive; an\n *     array's expando keys are out of contract and not compared)\n *   - objects: identical set of keys that HOLD a value AND deep-equal per key.\n *     An own key whose value is `undefined` counts as ABSENT: it is this\n *     library's other spelling of a deleted key (`'full'` mode flattens\n *     `delete` into `key: undefined`; `'delta'` mode's `delete` verb removes\n *     the key), and every consumer — JSON, the fold, `commitValueAt`, the\n *     mirror — reads the two spellings as one state. So must the net-change\n *     filter (9.19.1): `{}` and `{ k: undefined }` are not a change. Arrays\n *     are untouched — a slot holding `undefined` is still a slot.\n *\n * Cost & safety:\n *   - Allocates only transient `Object.keys` arrays, an error's property\n *     descriptors and a byte view per compared buffer — no clones (but one\n *     probe clone per class prototype, remembered: `capture/valueKinds.ts ·\n *     kindOf`). It is strictly cheaper than the `structuredClone` the commit\n *     already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any, opaque: OpaqueRule = 'identity'): boolean {\n  return equalPairs(a, b, undefined, opaque);\n}\n\n/**\n * How {@link deepEqual} compares two OPAQUE values (a Blob, a `DOMException` —\n * content this library cannot read):\n *\n *   - `'identity'` (the default) — equal only to itself. The answer when one\n *     side is a value a stage handed in: the net-change filter\n *     (`TransactionBuffer`), the append check (`deltaEncoding`). A new object\n *     is a change, because nothing can say it is not.\n *   - `'copies'` — equal to any other of its kind. The answer when BOTH sides\n *     are copies of one recorded value — a fold's generations (`logModel`,\n *     `elementProvenance`), a retained read against live state\n *     (`borrowedMutation`), the record replayed against the read-back\n *     (`admission`): copies never share identity, so identity would call every\n *     opaque value changed.\n */\nexport type OpaqueRule = 'identity' | 'copies';\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined, opaque: OpaqueRule): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  const kind = kindOf(a);\n  if (kind !== kindOf(b)) return false;\n  switch (kind) {\n    // Atoms: their content is a slot, not their keys.\n    case 'date':\n      return Object.is(Date.prototype.getTime.call(a), Date.prototype.getTime.call(b));\n    case 'regexp':\n      return a.source === b.source && a.flags === b.flags;\n    case 'boxed':\n      return tagOf(a) === tagOf(b) && equalPairs(a.valueOf(), b.valueOf(), seen, opaque);\n    case 'buffer':\n      return equalBuffers(a, b);\n    case 'view':\n      return equalViews(a, b);\n    case 'opaque':\n      return opaque === 'copies' && tagOf(a) === tagOf(b); // `a === b` was answered above\n    case 'plain':\n    case 'array':\n    case 'map':\n    case 'set':\n    case 'error':\n      return equalContainers(a, b, kind, seen, opaque);\n    default:\n      return unknownKind(kind);\n  }\n}\n\n/** The kinds whose content is other values: compared part by part, under the cycle guard. */\nfunction equalContainers(a: any, b: any, kind: ValueKind, seen: SeenPairs | undefined, opaque: OpaqueRule): boolean {\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (kind === 'map') return equalMaps(a, b, seen, opaque);\n  if (kind === 'set') return equalSets(a, b, seen, opaque);\n  if (kind === 'error') return equalErrors(a, b, seen, opaque);\n  if (kind === 'array') {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen, opaque)) return false;\n    }\n    return true;\n  }\n\n  // Objects: only keys that HOLD a value take part — an own `undefined` is a\n  // deleted key, the same state as an absent one (see the contract above).\n  let aHeld = 0;\n  for (const key of Object.keys(a)) {\n    if (a[key] === undefined) continue;\n    aHeld++;\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen, opaque)) return false;\n  }\n  let bHeld = 0;\n  for (const key of Object.keys(b)) if (b[key] !== undefined) bHeld++;\n  return aHeld === bHeld;\n}\n\nfunction unknownKind(kind: never): never {\n  throw new TypeError(`deepEqual: no comparison for the value kind '${String(kind)}'`);\n}\n\n/** `[object Number]`, `[object Uint8Array]` … — the built-in type a boxed value or a view carries. */\nfunction tagOf(value: object): string {\n  return Object.prototype.toString.call(value);\n}\n\n/** The same view type over the same bytes — the bytes the view sees, wherever they sit in its buffer. */\nfunction equalViews(a: ArrayBufferView, b: ArrayBufferView): boolean {\n  if (tagOf(a) !== tagOf(b) || a.byteLength !== b.byteLength) return false;\n  if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;\n  const p = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);\n  const q = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);\n  for (let i = 0; i < p.length; i++) if (p[i] !== q[i]) return false;\n  return true;\n}\n\n/** The same length, resizability and bytes. */\nfunction equalBuffers(a: ArrayBufferLike, b: ArrayBufferLike): boolean {\n  if (a === b) return true;\n  const x = a as ArrayBufferLike & { resizable?: boolean; maxByteLength?: number };\n  const y = b as typeof x;\n  if (x.byteLength !== y.byteLength || x.resizable !== y.resizable || x.maxByteLength !== y.maxByteLength) {\n    return false;\n  }\n  const p = new Uint8Array(a);\n  const q = new Uint8Array(b);\n  for (let i = 0; i < p.length; i++) if (p[i] !== q[i]) return false;\n  return true;\n}\n\n/** The six error names `structuredClone` restores; any other name comes back an `Error`. */\nconst ERROR_NAMES = new Set(['EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError']);\n\n/**\n * Two errors as the clone keeps them: the restored kind, the own `message`,\n * the `stack` and the own `cause` (deep). Any other own field is dropped by\n * the clone, so it never counts.\n */\nfunction equalErrors(a: Error, b: Error, seen: SeenPairs, opaque: OpaqueRule): boolean {\n  if (errorKindOf(a) !== errorKindOf(b) || stackOf(a) !== stackOf(b)) return false;\n  const aMessage = ownData(a, 'message');\n  const bMessage = ownData(b, 'message');\n  if (String(aMessage?.value) !== String(bMessage?.value) || !aMessage !== !bMessage) return false;\n  const aCause = ownData(a, 'cause');\n  const bCause = ownData(b, 'cause');\n  if (!aCause || !bCause) return !aCause === !bCause;\n  return equalPairs(aCause.value, bCause.value, seen, opaque);\n}\n\nfunction errorKindOf(error: Error): string {\n  const name = String(error.name);\n  return ERROR_NAMES.has(name) ? name : 'Error';\n}\n\nfunction stackOf(error: Error): string | undefined {\n  const stack = error.stack;\n  return typeof stack === 'string' ? stack : undefined;\n}\n\n/** An own DATA property, boxed — how the clone reads an error's `message` and `cause`. */\nfunction ownData(value: object, key: string): { value: unknown } | undefined {\n  const descriptor = Object.getOwnPropertyDescriptor(value, key);\n  return descriptor !== undefined && Object.prototype.hasOwnProperty.call(descriptor, 'value')\n    ? { value: descriptor.value }\n    : undefined;\n}\n\nfunction equalMaps(a: Map<unknown, unknown>, b: Map<unknown, unknown>, seen: SeenPairs, opaque: OpaqueRule): boolean {\n  if (a.size !== b.size) return false;\n  for (const [key, value] of a) {\n    if (!b.has(key)) return false;\n    if (!equalPairs(value, b.get(key), seen, opaque)) return false;\n  }\n  return true;\n}\n\n/**\n * Order-insensitive, deep per member. Quadratic in the worst case for sets of\n * objects — a set of primitives (the common shape) is one `has` per member.\n */\nfunction equalSets(a: Set<unknown>, b: Set<unknown>, seen: SeenPairs, opaque: OpaqueRule): boolean {\n  if (a.size !== b.size) return false;\n  const unmatched = [...b];\n  for (const member of a) {\n    // SameValueZero first — primitives and shared references, one `has`.\n    // Each match retires its slot so two structurally-equal members of `a`\n    // cannot both claim the same member of `b`.\n    const at = unmatched.indexOf(member);\n    const found = at >= 0 ? at : unmatched.findIndex((candidate) => equalPairs(member, candidate, seen, opaque));\n    if (found < 0) return false;\n    unmatched.splice(found, 1);\n  }\n  return true;\n}\n"]}