footprintjs 9.44.0 → 9.44.2

package/dist/lib/capture/freeze.js

@@ -1,26 +1,48 @@
 "use strict";
 /**
- * freeze.ts — the ONE deep-freeze walk (moved here from `scope/protection/readonlyInput.ts` in F3).
+ * freeze.ts — the ONE deep-freeze walk (moved here from `scope/protection/readonlyInput.ts` in F3),
+ * and the serve-time law for the commit log (9.44.2).
  *
  * WHY HERE. Saved trees freeze through this walk: the fold base served as
  * `initialState` (`ExecutionRuntime · getFoldBase`), the
  * dev-mode snapshot (`runner/snapshot.ts · servedSnapshot`), every state `stateAt` hands out
  * (`time-travel/stateAt.ts`) and, since F3, every commit bundle (`EventLog · record`). `memory/` must
  * not import `scope/` (that edge closed the memory ⇄ scope ⇄ recorder module cycle F0 removed), so the
- * walk lives in this leaf, which imports nothing. Args use an ownership snapshot instead
- * (`scope/protection/readonlyInput.ts · createFrozenArgs`): never freeze borrowed caller values.
+ * walk lives in this leaf folder, which imports nothing outside itself. Args use an ownership snapshot
+ * instead (`scope/protection/readonlyInput.ts · createFrozenArgs`): never freeze borrowed caller values.
+ *
+ * FREEZE WHAT CAN BE FROZEN, COPY WHAT CAN'T (9.44.2). `Object.freeze` cannot seal a Date's time, a
+ * Map's or Set's entries, a buffer's bytes, a RegExp (`compile()` rewrites a frozen one) or an Error
+ * (V8's own `stack` accessor writes through a frozen one). A fresh tree handed to one caller (a `stateAt`
+ * state, the dev-mode snapshot) is that caller's own, so freezing it is a guard and nothing more. The
+ * COMMIT LOG — each bundle, and the fold base — is served to every reader, so {@link freezeRecord}
+ * remembers that a record holds such a value, its first serve maps the containers on the way to each
+ * one (its open PATHS), and {@link serveRecord} hands a reader a copy of those paths only: a fresh copy
+ * of each such value, fresh frozen containers on the way to it, and every other part shared, frozen, as
+ * it is. Until 9.44.2 `snapshot.commitLog[i].overwrite.when.setTime(0)` rewrote every later snapshot,
+ * `stateAt`, `commitValueAt`, slice and cursor answer.
+ *
+ * Every walk here is ITERATIVE (an explicit stack): a record's depth is not bounded by the call stack.
  *
  * @example
  * ```typescript
- * import { deepFreeze } from './freeze.js';
+ * import { deepFreeze, freezeRecord, serveRecord } from './freeze.js';
  *
  * const args = deepFreeze({ order: { lines: [{ sku: 'A' }] }, bytes: new Uint8Array([1]) });
  * Object.isFrozen(args.order.lines[0]); // true
  * Object.isFrozen(args.bytes); // false — a typed array cannot be frozen; it is skipped
+ *
+ * const record = freezeRecord({ when: new Date(0), tags: ['a'] });
+ * const served = serveRecord(record);
+ * served.when.setTime(5); // changes the reader's copy
+ * serveRecord(record).when.getTime(); // 0 — every serve is the record as recorded
+ * served.tags === record.tags; // true — the sealed part is shared, not copied
+ * serveRecord(freezeRecord({ n: 1 })); // a record freezing sealed whole: served as itself
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepFreeze = void 0;
+exports.serveRecord = exports.freezeRecord = exports.deepFreeze = void 0;
+const valueKinds_js_1 = require("./valueKinds.js");
 /**
  * Freezes `obj` and every object reachable through its own properties, and returns `obj`.
  *
@@ -33,33 +55,278 @@ exports.deepFreeze = void 0;
  *   snapshot here.
  * - What `Object.freeze` cannot reach stays mutable — Map and Set contents, a Date's time, the
  *   bytes behind a buffer. A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y` regex
- *   taken from a frozen tree throws when `exec` or `replace` advance it.
+ *   taken from a frozen tree throws when `exec` or `replace` advance it. The commit log goes through
+ *   {@link freezeRecord} and {@link serveRecord} instead.
  * - Functions are not descended (they are not values the engine stores).
  */
 function deepFreeze(obj, arrays = 'every-key') {
-    freezeValue(obj, arrays === 'indices');
+    if (obj !== null && typeof obj === 'object')
+        walkAndFreeze(obj, arrays === 'indices', false);
     return obj;
 }
 exports.deepFreeze = deepFreeze;
-function freezeValue(value, indices) {
-    if (value === null || typeof value !== 'object' || ArrayBuffer.isView(value) || Object.isFrozen(value))
-        return;
-    Object.freeze(value);
-    // The two loops are written out rather than shared through a callback: this runs once per object of
-    // every commit, and a closure per object is measurable.
-    if (indices && Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            const child = value[i];
-            if (child !== null && typeof child === 'object')
-                freezeValue(child, indices);
+/**
+ * Containers of a record that hold — on some path below them — a value freezing cannot seal: `true` once
+ * mapped (the container is on an open path), `false` for a record {@link freezeRecord} found open whose
+ * paths no serve has mapped yet. A container absent here is sealed whole.
+ */
+const OPEN = new WeakMap();
+/**
+ * {@link deepFreeze} for a record many readers are SERVED (a commit bundle, the fold base), and two more
+ * things on the same walk:
+ *
+ *   - it remembers THAT the record holds a value freezing cannot seal — one flag; the record's first
+ *     serve maps WHERE (the containers on the way to each such value, its open paths), so the run pays
+ *     nothing more and {@link serveRecord} copies those paths and nothing else;
+ *   - a typed array or `DataView` that views a SLICE of a bigger buffer (a Node `Buffer` views its
+ *     shared pool) is replaced, in the record, by a copy of the bytes it views — the record keeps the
+ *     view's bytes, never the rest of the buffer (a resizable or shared buffer is kept as it is).
+ *
+ * A part frozen before is not frozen past (deepFreeze's contract) but is looked through, so a value
+ * freezing cannot seal inside it still opens the record. Returns `record`.
+ */
+function freezeRecord(record, arrays = 'every-key') {
+    if (!OPEN.has(record) && walkAndFreeze(record, arrays === 'indices', true))
+        OPEN.set(record, false);
+    return record;
+}
+exports.freezeRecord = freezeRecord;
+/**
+ * The record as a reader may hold it — THE serve-time law: a record freezing sealed whole is served as
+ * itself (shared, no cost); any other as a copy of its open paths ({@link freezeRecord}): fresh frozen
+ * containers down to each value freezing cannot seal, a fresh copy of that value, and every other part
+ * shared, frozen, as it is. A copy is served the same way again.
+ */
+function serveRecord(record) {
+    if (record === null || typeof record !== 'object')
+        return record;
+    const mapped = OPEN.get(record);
+    if (mapped === undefined)
+        return record;
+    if (!mapped)
+        mapOpenPaths(record);
+    return OPEN.get(record) === true ? copyOpenPaths(record) : record;
+}
+exports.serveRecord = serveRecord;
+/** A value freezing cannot seal — a view, or a kind `SEALABLE` says no to (a Date, a Map, an Error …). */
+function isUnsealable(value) {
+    return ArrayBuffer.isView(value) || !valueKinds_js_1.SEALABLE[(0, valueKinds_js_1.kindOf)(value)];
+}
+/**
+ * Freeze `root` and every container under it, iteratively; `record` adds the look-through of parts
+ * frozen before and the compaction of views over a slice. `true` when something under `root` (or `root`
+ * itself) cannot be sealed.
+ */
+function walkAndFreeze(root, indices, record) {
+    let open = false;
+    let lookedThrough;
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (ArrayBuffer.isView(node)) {
+            open = true; // its bytes — and a non-empty one cannot be frozen at all
+            continue;
+        }
+        const frozenBefore = Object.isFrozen(node);
+        if (frozenBefore) {
+            if (!record || OPEN.has(node)) {
+                open ||= record;
+                continue;
+            }
+            if ((lookedThrough ??= new Set()).has(node))
+                continue;
+            lookedThrough.add(node); // a part frozen before: looked through, never frozen past
+        }
+        if (record && !open && !valueKinds_js_1.SEALABLE[(0, valueKinds_js_1.kindOf)(node)])
+            open = true;
+        // Children first, while `node` is still open to the compaction below; then the freeze.
+        const compacting = record && !frozenBefore;
+        if (indices && Array.isArray(node)) {
+            for (let i = 0; i < node.length; i++) {
+                const child = node[i];
+                if (child === null || typeof child !== 'object')
+                    continue;
+                stack.push(compacting && ArrayBuffer.isView(child) ? compact(node, i, child) : child);
+            }
         }
-        return;
+        else {
+            const names = Object.getOwnPropertyNames(node);
+            for (let i = 0; i < names.length; i++) {
+                const child = node[names[i]];
+                if (child === null || typeof child !== 'object')
+                    continue;
+                stack.push(compacting && ArrayBuffer.isView(child) ? compact(node, names[i], child) : child);
+            }
+        }
+        if (!frozenBefore)
+            Object.freeze(node);
+    }
+    return open;
+}
+/**
+ * A view over a SLICE of a bigger buffer, replaced in `container` by a copy of the bytes it views
+ * (the type it is — a Node `Buffer` comes out a `Uint8Array`, as a clone of it does). Anything else is
+ * returned as it is. A resizable or shared buffer is kept: a copy would change what it is.
+ */
+function compact(container, key, child) {
+    const buffer = child.buffer;
+    if (child.byteOffset === 0 && child.byteLength === buffer.byteLength)
+        return child;
+    if (buffer.resizable === true || !(buffer instanceof ArrayBuffer))
+        return child;
+    const bytes = buffer.slice(child.byteOffset, child.byteOffset + child.byteLength);
+    const tag = Object.prototype.toString.call(child).slice(8, -1);
+    const Ctor = globalThis[tag];
+    if (typeof Ctor !== 'function')
+        return child;
+    const copy = new Ctor(bytes);
+    try {
+        container[key] = copy;
+    }
+    catch {
+        return child; // a property the record does not let be replaced (a hand-built bundle)
+    }
+    return copy;
+}
+/**
+ * Map the open paths of `root` — mark every container that reaches a value freezing cannot seal, so a
+ * serve copies exactly those (DAGs and cycles included: the marks run UP the reverse edges from each
+ * such value). Runs once per open record, at its first serve. A node's first holder is kept in one map;
+ * any other holder (a shared part, a cycle) in a second, made only when there is one.
+ */
+function mapOpenPaths(root) {
+    const holder = new Map();
+    let moreHolders;
+    const leaves = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (isUnsealable(node)) {
+            leaves.push(node); // a leaf: its contents are copied with it
+            continue;
+        }
+        const names = Object.keys(node);
+        for (let i = 0; i < names.length; i++) {
+            const child = node[names[i]];
+            if (child === null || typeof child !== 'object')
+                continue;
+            if (child !== root && !holder.has(child)) {
+                holder.set(child, node);
+                stack.push(child);
+                continue;
+            }
+            const more = (moreHolders ??= new Map()).get(child);
+            if (more === undefined)
+                moreHolders.set(child, [node]);
+            else
+                more.push(node);
+        }
+    }
+    // Marked in THIS map, not by an earlier one: a part another record already mapped still opens
+    // every container of this record on the way to it.
+    const marked = new Set();
+    const up = [];
+    const holdersOf = (node) => {
+        const first = holder.get(node);
+        if (first !== undefined)
+            up.push(first);
+        const more = moreHolders?.get(node);
+        // One push per holder: a spread passes every holder as a call argument, and one object held by
+        // 120,000 containers overflowed the stack.
+        if (more !== undefined)
+            for (let i = 0; i < more.length; i++)
+                up.push(more[i]);
+    };
+    for (const leaf of leaves) {
+        if (leaf === root)
+            marked.add(root);
+        holdersOf(leaf);
+    }
+    while (up.length > 0) {
+        const node = up.pop();
+        if (marked.has(node))
+            continue;
+        marked.add(node);
+        holdersOf(node);
+    }
+    // Only now, the walk done, does the record's flag give way to its map: a mapping that throws leaves
+    // the record flagged, so the next serve maps again — it never hands out the record itself.
+    if (!marked.has(root))
+        OPEN.delete(root);
+    for (const node of marked)
+        OPEN.set(node, true);
+}
+/**
+ * The served copy of an open record: its open containers copied (fresh, then frozen, and themselves
+ * open — a copy is served by copy again), each value freezing cannot seal copied, every sealed part
+ * shared. Iterative; one copy per original, so containers shared or cyclic stay shared in the copy. The
+ * values freezing cannot seal are copied ONE BY ONE: two of them that share a part (an `ArrayBuffer`
+ * and a view of it, an error whose `cause` is another key's Date) come out as separate copies — equal
+ * values, the sharing between them not kept.
+ */
+function copyOpenPaths(root) {
+    const copies = new Map();
+    const shells = [];
+    const copyOf = (value, pending) => {
+        const done = copies.get(value);
+        if (done !== undefined)
+            return done;
+        let copy;
+        if (isUnsealable(value)) {
+            copy = copyLeaf(value);
+        }
+        else {
+            copy = Array.isArray(value) ? new Array(value.length) : {};
+            shells.push(copy);
+            pending.push(value);
+        }
+        copies.set(value, copy);
+        return copy;
+    };
+    const pending = [];
+    const out = copyOf(root, pending);
+    while (pending.length > 0) {
+        const node = pending.pop();
+        const copy = copies.get(node);
+        for (const name of Object.keys(node)) {
+            const child = node[name];
+            putOwn(copy, name, child !== null && typeof child === 'object' && (OPEN.has(child) || isUnsealable(child))
+                ? copyOf(child, pending)
+                : child);
+        }
+    }
+    for (const shell of shells) {
+        Object.freeze(shell);
+        OPEN.set(shell, true);
+    }
+    // A leaf copy is the reader's own; frozen where freezing reaches, as the record's parts are.
+    for (const copy of copies.values())
+        if (!ArrayBuffer.isView(copy))
+            Object.freeze(copy);
+    return out;
+}
+/**
+ * `target[name] = value`, as an OWN data property. A key the shell only inherits — an own `"__proto__"`
+ * of the record (`JSON.parse` makes one) — would call the inherited setter and re-parent the copy; it is
+ * defined as data instead, as `memory/merge.ts · mergeGuarded` keeps it.
+ */
+function putOwn(target, name, value) {
+    if (!Object.prototype.hasOwnProperty.call(target, name) && Reflect.has(target, name)) {
+        Object.defineProperty(target, name, { value, enumerable: true, writable: true, configurable: true });
+    }
+    else {
+        target[name] = value;
+    }
+}
+/** A fresh copy of a value freezing cannot seal. One the clone refuses (hand-built) is served as it is. */
+function copyLeaf(value) {
+    if ((0, valueKinds_js_1.kindOf)(value) === 'date')
+        return new Date(Date.prototype.getTime.call(value));
+    try {
+        return structuredClone(value);
     }
-    const names = Object.getOwnPropertyNames(value);
-    for (let i = 0; i < names.length; i++) {
-        const child = value[names[i]];
-        if (child !== null && typeof child === 'object')
-            freezeValue(child, indices);
+    catch {
+        return value;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"freeze.js","sourceRoot":"","sources":["../../../src/lib/capture/freeze.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * freeze.ts — the ONE deep-freeze walk (moved here from `scope/protection/readonlyInput.ts` in F3),\n * and the serve-time law for the commit log (9.44.2).\n *\n * WHY HERE. Saved trees freeze through this walk: the fold base served as\n * `initialState` (`ExecutionRuntime · getFoldBase`), the\n * dev-mode snapshot (`runner/snapshot.ts · servedSnapshot`), every state `stateAt` hands out\n * (`time-travel/stateAt.ts`) and, since F3, every commit bundle (`EventLog · record`). `memory/` must\n * not import `scope/` (that edge closed the memory ⇄ scope ⇄ recorder module cycle F0 removed), so the\n * walk lives in this leaf folder, which imports nothing outside itself. Args use an ownership snapshot\n * instead (`scope/protection/readonlyInput.ts · createFrozenArgs`): never freeze borrowed caller values.\n *\n * FREEZE WHAT CAN BE FROZEN, COPY WHAT CAN'T (9.44.2). `Object.freeze` cannot seal a Date's time, a\n * Map's or Set's entries, a buffer's bytes, a RegExp (`compile()` rewrites a frozen one) or an Error\n * (V8's own `stack` accessor writes through a frozen one). A fresh tree handed to one caller (a `stateAt`\n * state, the dev-mode snapshot) is that caller's own, so freezing it is a guard and nothing more. The\n * COMMIT LOG — each bundle, and the fold base — is served to every reader, so {@link freezeRecord}\n * remembers that a record holds such a value, its first serve maps the containers on the way to each\n * one (its open PATHS), and {@link serveRecord} hands a reader a copy of those paths only: a fresh copy\n * of each such value, fresh frozen containers on the way to it, and every other part shared, frozen, as\n * it is. Until 9.44.2 `snapshot.commitLog[i].overwrite.when.setTime(0)` rewrote every later snapshot,\n * `stateAt`, `commitValueAt`, slice and cursor answer.\n *\n * Every walk here is ITERATIVE (an explicit stack): a record's depth is not bounded by the call stack.\n *\n * @example\n * ```typescript\n * import { deepFreeze, freezeRecord, serveRecord } from './freeze.js';\n *\n * const args = deepFreeze({ order: { lines: [{ sku: 'A' }] }, bytes: new Uint8Array([1]) });\n * Object.isFrozen(args.order.lines[0]); // true\n * Object.isFrozen(args.bytes); // false — a typed array cannot be frozen; it is skipped\n *\n * const record = freezeRecord({ when: new Date(0), tags: ['a'] });\n * const served = serveRecord(record);\n * served.when.setTime(5); // changes the reader's copy\n * serveRecord(record).when.getTime(); // 0 — every serve is the record as recorded\n * served.tags === record.tags; // true — the sealed part is shared, not copied\n * serveRecord(freezeRecord({ n: 1 })); // a record freezing sealed whole: served as itself\n * ```\n */\n\nimport { kindOf, SEALABLE } from './valueKinds.js';\n\n/**\n * How {@link deepFreeze} walks an ARRAY.\n *\n * - `'every-key'` (the default) — every own property, as for any other object: the index elements\n *   AND any expando (`arr.note = { … }`). The dev-mode snapshot relies on this contract.\n * - `'indices'` — the index elements only, so no key string is allocated per element; this is what\n *   keeps freezing a 10,000-element commit inside its budget (`bench/element-writes.ts`). An object\n *   hung on an array EXPANDO is then left unfrozen, and unseen by {@link serveRecord} — the commit\n *   log's named hole (`EventLog · record`; an array expando is out of contract for state).\n */\nexport type ArrayWalk = 'every-key' | 'indices';\n\n/**\n * Freezes `obj` and every object reachable through its own properties, and returns `obj`.\n *\n * - An object that is ALREADY frozen is left as it is, and not descended — 9.32.0's contract, kept:\n *   args may hold a caller's frozen object with live parts inside (a class instance a stage calls),\n *   and freezing past it would break them. It is also what ends a cycle. The commit log never meets\n *   one: its payloads are fresh `structuredClone`s.\n * - ArrayBuffer views (typed arrays, `DataView`) are skipped: `Object.freeze` throws on a non-empty\n *   typed array, so a `Uint8Array` in state, args or the fold base used to fail the run or the\n *   snapshot here.\n * - What `Object.freeze` cannot reach stays mutable — Map and Set contents, a Date's time, the\n *   bytes behind a buffer. A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y` regex\n *   taken from a frozen tree throws when `exec` or `replace` advance it. The commit log goes through\n *   {@link freezeRecord} and {@link serveRecord} instead.\n * - Functions are not descended (they are not values the engine stores).\n */\nexport function deepFreeze<T>(obj: T, arrays: ArrayWalk = 'every-key'): T {\n  if (obj !== null && typeof obj === 'object') walkAndFreeze(obj, arrays === 'indices', false);\n  return obj;\n}\n\n/**\n * Containers of a record that hold — on some path below them — a value freezing cannot seal: `true` once\n * mapped (the container is on an open path), `false` for a record {@link freezeRecord} found open whose\n * paths no serve has mapped yet. A container absent here is sealed whole.\n */\nconst OPEN = new WeakMap<object, boolean>();\n\n/**\n * {@link deepFreeze} for a record many readers are SERVED (a commit bundle, the fold base), and two more\n * things on the same walk:\n *\n *   - it remembers THAT the record holds a value freezing cannot seal — one flag; the record's first\n *     serve maps WHERE (the containers on the way to each such value, its open paths), so the run pays\n *     nothing more and {@link serveRecord} copies those paths and nothing else;\n *   - a typed array or `DataView` that views a SLICE of a bigger buffer (a Node `Buffer` views its\n *     shared pool) is replaced, in the record, by a copy of the bytes it views — the record keeps the\n *     view's bytes, never the rest of the buffer (a resizable or shared buffer is kept as it is).\n *\n * A part frozen before is not frozen past (deepFreeze's contract) but is looked through, so a value\n * freezing cannot seal inside it still opens the record. Returns `record`.\n */\nexport function freezeRecord<T extends object>(record: T, arrays: ArrayWalk = 'every-key'): T {\n  if (!OPEN.has(record) && walkAndFreeze(record, arrays === 'indices', true)) OPEN.set(record, false);\n  return record;\n}\n\n/**\n * The record as a reader may hold it — THE serve-time law: a record freezing sealed whole is served as\n * itself (shared, no cost); any other as a copy of its open paths ({@link freezeRecord}): fresh frozen\n * containers down to each value freezing cannot seal, a fresh copy of that value, and every other part\n * shared, frozen, as it is. A copy is served the same way again.\n */\nexport function serveRecord<T>(record: T): T {\n  if (record === null || typeof record !== 'object') return record;\n  const mapped = OPEN.get(record);\n  if (mapped === undefined) return record;\n  if (!mapped) mapOpenPaths(record);\n  return OPEN.get(record) === true ? (copyOpenPaths(record) as T) : record;\n}\n\n/** A value freezing cannot seal — a view, or a kind `SEALABLE` says no to (a Date, a Map, an Error …). */\nfunction isUnsealable(value: object): boolean {\n  return ArrayBuffer.isView(value) || !SEALABLE[kindOf(value)];\n}\n\n/**\n * Freeze `root` and every container under it, iteratively; `record` adds the look-through of parts\n * frozen before and the compaction of views over a slice. `true` when something under `root` (or `root`\n * itself) cannot be sealed.\n */\nfunction walkAndFreeze(root: object, indices: boolean, record: boolean): boolean {\n  let open = false;\n  let lookedThrough: Set<object> | undefined;\n  const stack: object[] = [root];\n  while (stack.length > 0) {\n    const node = stack.pop()!;\n    if (ArrayBuffer.isView(node)) {\n      open = true; // its bytes — and a non-empty one cannot be frozen at all\n      continue;\n    }\n    const frozenBefore = Object.isFrozen(node);\n    if (frozenBefore) {\n      if (!record || OPEN.has(node)) {\n        open ||= record;\n        continue;\n      }\n      if ((lookedThrough ??= new Set()).has(node)) continue;\n      lookedThrough.add(node); // a part frozen before: looked through, never frozen past\n    }\n    if (record && !open && !SEALABLE[kindOf(node)]) open = true;\n    // Children first, while `node` is still open to the compaction below; then the freeze.\n    const compacting = record && !frozenBefore;\n    if (indices && Array.isArray(node)) {\n      for (let i = 0; i < node.length; i++) {\n        const child: unknown = node[i];\n        if (child === null || typeof child !== 'object') continue;\n        stack.push(compacting && ArrayBuffer.isView(child) ? compact(node, i, child) : child);\n      }\n    } else {\n      const names = Object.getOwnPropertyNames(node);\n      for (let i = 0; i < names.length; i++) {\n        const child = (node as Record<string, unknown>)[names[i]];\n        if (child === null || typeof child !== 'object') continue;\n        stack.push(compacting && ArrayBuffer.isView(child) ? compact(node, names[i], child) : child);\n      }\n    }\n    if (!frozenBefore) Object.freeze(node);\n  }\n  return open;\n}\n\n/**\n * A view over a SLICE of a bigger buffer, replaced in `container` by a copy of the bytes it views\n * (the type it is — a Node `Buffer` comes out a `Uint8Array`, as a clone of it does). Anything else is\n * returned as it is. A resizable or shared buffer is kept: a copy would change what it is.\n */\nfunction compact(container: object, key: string | number, child: ArrayBufferView): object {\n  const buffer = child.buffer as ArrayBuffer & { resizable?: boolean };\n  if (child.byteOffset === 0 && child.byteLength === buffer.byteLength) return child;\n  if (buffer.resizable === true || !(buffer instanceof ArrayBuffer)) return child;\n  const bytes = buffer.slice(child.byteOffset, child.byteOffset + child.byteLength);\n  const tag = Object.prototype.toString.call(child).slice(8, -1);\n  const Ctor = (globalThis as unknown as Record<string, new (buffer: ArrayBuffer) => ArrayBufferView>)[tag];\n  if (typeof Ctor !== 'function') return child;\n  const copy = new Ctor(bytes);\n  try {\n    (container as Record<string | number, unknown>)[key] = copy;\n  } catch {\n    return child; // a property the record does not let be replaced (a hand-built bundle)\n  }\n  return copy;\n}\n\n/**\n * Map the open paths of `root` — mark every container that reaches a value freezing cannot seal, so a\n * serve copies exactly those (DAGs and cycles included: the marks run UP the reverse edges from each\n * such value). Runs once per open record, at its first serve. A node's first holder is kept in one map;\n * any other holder (a shared part, a cycle) in a second, made only when there is one.\n */\nfunction mapOpenPaths(root: object): void {\n  const holder = new Map<object, object>();\n  let moreHolders: Map<object, object[]> | undefined;\n  const leaves: object[] = [];\n  const stack: object[] = [root];\n  while (stack.length > 0) {\n    const node = stack.pop()!;\n    if (isUnsealable(node)) {\n      leaves.push(node); // a leaf: its contents are copied with it\n      continue;\n    }\n    const names = Object.keys(node);\n    for (let i = 0; i < names.length; i++) {\n      const child = (node as Record<string, unknown>)[names[i]];\n      if (child === null || typeof child !== 'object') continue;\n      if (child !== root && !holder.has(child)) {\n        holder.set(child, node);\n        stack.push(child);\n        continue;\n      }\n      const more = (moreHolders ??= new Map()).get(child);\n      if (more === undefined) moreHolders.set(child, [node]);\n      else more.push(node);\n    }\n  }\n  // Marked in THIS map, not by an earlier one: a part another record already mapped still opens\n  // every container of this record on the way to it.\n  const marked = new Set<object>();\n  const up: object[] = [];\n  const holdersOf = (node: object): void => {\n    const first = holder.get(node);\n    if (first !== undefined) up.push(first);\n    const more = moreHolders?.get(node);\n    // One push per holder: a spread passes every holder as a call argument, and one object held by\n    // 120,000 containers overflowed the stack.\n    if (more !== undefined) for (let i = 0; i < more.length; i++) up.push(more[i]);\n  };\n  for (const leaf of leaves) {\n    if (leaf === root) marked.add(root);\n    holdersOf(leaf);\n  }\n  while (up.length > 0) {\n    const node = up.pop()!;\n    if (marked.has(node)) continue;\n    marked.add(node);\n    holdersOf(node);\n  }\n  // Only now, the walk done, does the record's flag give way to its map: a mapping that throws leaves\n  // the record flagged, so the next serve maps again — it never hands out the record itself.\n  if (!marked.has(root)) OPEN.delete(root);\n  for (const node of marked) OPEN.set(node, true);\n}\n\n/**\n * The served copy of an open record: its open containers copied (fresh, then frozen, and themselves\n * open — a copy is served by copy again), each value freezing cannot seal copied, every sealed part\n * shared. Iterative; one copy per original, so containers shared or cyclic stay shared in the copy. The\n * values freezing cannot seal are copied ONE BY ONE: two of them that share a part (an `ArrayBuffer`\n * and a view of it, an error whose `cause` is another key's Date) come out as separate copies — equal\n * values, the sharing between them not kept.\n */\nfunction copyOpenPaths(root: object): object {\n  const copies = new Map<object, object>();\n  const shells: object[] = [];\n  const copyOf = (value: object, pending: object[]): object => {\n    const done = copies.get(value);\n    if (done !== undefined) return done;\n    let copy: object;\n    if (isUnsealable(value)) {\n      copy = copyLeaf(value);\n    } else {\n      copy = Array.isArray(value) ? new Array(value.length) : {};\n      shells.push(copy);\n      pending.push(value);\n    }\n    copies.set(value, copy);\n    return copy;\n  };\n  const pending: object[] = [];\n  const out = copyOf(root, pending);\n  while (pending.length > 0) {\n    const node = pending.pop()!;\n    const copy = copies.get(node) as Record<string, unknown>;\n    for (const name of Object.keys(node)) {\n      const child = (node as Record<string, unknown>)[name];\n      putOwn(\n        copy,\n        name,\n        child !== null && typeof child === 'object' && (OPEN.has(child) || isUnsealable(child))\n          ? copyOf(child, pending)\n          : child,\n      );\n    }\n  }\n  for (const shell of shells) {\n    Object.freeze(shell);\n    OPEN.set(shell, true);\n  }\n  // A leaf copy is the reader's own; frozen where freezing reaches, as the record's parts are.\n  for (const copy of copies.values()) if (!ArrayBuffer.isView(copy)) Object.freeze(copy);\n  return out;\n}\n\n/**\n * `target[name] = value`, as an OWN data property. A key the shell only inherits — an own `\"__proto__\"`\n * of the record (`JSON.parse` makes one) — would call the inherited setter and re-parent the copy; it is\n * defined as data instead, as `memory/merge.ts · mergeGuarded` keeps it.\n */\nfunction putOwn(target: Record<string, unknown>, name: string, value: unknown): void {\n  if (!Object.prototype.hasOwnProperty.call(target, name) && Reflect.has(target, name)) {\n    Object.defineProperty(target, name, { value, enumerable: true, writable: true, configurable: true });\n  } else {\n    target[name] = value;\n  }\n}\n\n/** A fresh copy of a value freezing cannot seal. One the clone refuses (hand-built) is served as it is. */\nfunction copyLeaf(value: object): object {\n  if (kindOf(value) === 'date') return new Date(Date.prototype.getTime.call(value));\n  try {\n    return structuredClone(value);\n  } catch {\n    return value;\n  }\n}\n"]}

package/dist/lib/capture/valueKinds.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * valueKinds.ts — what KIND of value a record holds: the one classifier.
+ *
+ * WHY. Committed state is what survives `structuredClone` (an engine invariant), so the values a
+ * record holds are the kinds the clone keeps. Two laws need the kind, and both ask here:
+ *
+ *   - what counts as a CHANGE (`memory/equality.ts · deepEqual`): two values are equal when a record
+ *     holds the same thing for both, compared kind by kind. Until 9.44.2 only Date, Map and Set had a
+ *     kind; a RegExp, an Error, a boxed number, a buffer, a DataView or a Blob was compared as an
+ *     object with no own keys — equal to any other of its kind — so replacing one committed no row
+ *     and live state kept the old value;
+ *   - what a served record must COPY (`capture/freeze.ts · freezeRecord` / `serveRecord`):
+ *     `Object.freeze` seals only the kinds whose content is their own properties ({@link SEALABLE}).
+ *
+ * A leaf: imports nothing (`capture/` is L0, below `memory/`).
+ *
+ * @example
+ * ```typescript
+ * kindOf(new Date(0));                    // 'date'
+ * kindOf(new (class Point { x = 1 })());  // 'plain' — its clone is a plain object
+ * kindOf(new Blob(['a']));                // 'opaque' — its clone keeps content this library cannot read
+ * SEALABLE.date;                          // false — setTime writes a slot Object.freeze cannot reach
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kindOf = exports.SEALABLE = void 0;
+/**
+ * Does `Object.freeze` seal every part of a value of this kind? True only where the content is the
+ * value's own properties (or a slot nothing can write). A `Record`, so a new kind does not compile
+ * until it is decided here.
+ */
+exports.SEALABLE = Object.freeze({
+    plain: true,
+    array: true,
+    boxed: true,
+    date: false, // setTime & co. write its time value
+    regexp: false, // compile() rewrites source and flags, even on a frozen one
+    map: false, // set / delete / clear
+    set: false, // add / delete / clear
+    error: false, // V8's own `stack` accessor writes through a frozen error
+    buffer: false, // its bytes, through any view; transfer() detaches it
+    view: false, // index writes, set, fill, sort, copyWithin …
+    opaque: false, // content this library cannot read — never assumed sealed
+});
+/** What a brand check returns, when it does not throw, for a value without the slot. */
+const NOT_BRAND = Symbol('not the brand');
+/**
+ * A built-in kind is known by its BRAND — an internal slot only the real thing has — never by its
+ * prototype: `Object.create(RegExp.prototype)` is not a RegExp (its clone is `{}`), and reading
+ * `source` from it throws. The candidate comes from `Object.prototype.toString` (one call), then ONE
+ * brand-checked read confirms it; a value that fails it is classified by its clone instead.
+ */
+const BRANDS = 
+/* @__PURE__ */ brandTable();
+function brandTable() {
+    const getter = (proto, key) => {
+        const get = proto && Object.getOwnPropertyDescriptor(proto, key)?.get;
+        return get ? (value) => get.call(value) : undefined;
+    };
+    const global = globalThis;
+    const isError = Error.isError;
+    const rows = [
+        ['Date', 'date', (value) => Date.prototype.getTime.call(value)],
+        ['RegExp', 'regexp', getter(RegExp.prototype, 'source')],
+        ['Map', 'map', getter(Map.prototype, 'size')],
+        ['Set', 'set', getter(Set.prototype, 'size')],
+        // An error's tag comes from its own [[ErrorData]] slot: no Error prototype carries a toStringTag. Where
+        // the brand check `Error.isError` is missing (Node 22), a tag a getter supplies is therefore a spoof.
+        ['Error', 'error', (value) => ((isError ? isError(value) : untagged(value)) ? true : NOT_BRAND)],
+        ['Number', 'boxed', (value) => Number.prototype.valueOf.call(value)],
+        ['String', 'boxed', (value) => String.prototype.valueOf.call(value)],
+        ['Boolean', 'boxed', (value) => Boolean.prototype.valueOf.call(value)],
+        ['BigInt', 'boxed', (value) => (global.BigInt?.prototype).valueOf.call(value)],
+        ['ArrayBuffer', 'buffer', getter(ArrayBuffer.prototype, 'byteLength')],
+        ['SharedArrayBuffer', 'buffer', getter(global.SharedArrayBuffer?.prototype, 'byteLength')],
+    ];
+    const table = new Map();
+    for (const [name, kind, check] of rows)
+        if (check)
+            table.set(`[object ${name}]`, { kind, check });
+    return table;
+}
+/** No `Symbol.toStringTag` on the value or its prototypes: its tag came from a slot. */
+function untagged(value) {
+    return value[Symbol.toStringTag] === undefined;
+}
+/** The kind of a built-in value, by its brand — `undefined` for anything else. */
+function builtinKind(value) {
+    if (ArrayBuffer.isView(value))
+        return 'view'; // a brand check of its own: [[ViewedArrayBuffer]]
+    const brand = BRANDS.get(Object.prototype.toString.call(value));
+    if (brand === undefined)
+        return undefined;
+    try {
+        return brand.check(value) === NOT_BRAND ? undefined : brand.kind;
+    }
+    catch {
+        return undefined; // the prototype without the slot
+    }
+}
+/** Prototypes classified by a probe clone of their first instance (see {@link kindOf}). */
+const PROBED = new WeakMap();
+/**
+ * The kind of an object, as a record holds it. A plain object or an array — the bulk of state —
+ * costs one `Array.isArray` and one `getPrototypeOf`; a built-in a tag and one brand-checked read.
+ * The brand is the value's own slot, so a subclass (a `Map` subclass is a `'map'`, Node's `Buffer` a
+ * `'view'`) and a value from another realm land on their kind.
+ *
+ * Any other object is classified by WHAT ITS CLONE IS, once per prototype: a class instance comes
+ * back a plain object (`'plain'`), a fake built-in (`Object.create(Date.prototype)`, or a class whose
+ * `Symbol.toStringTag` says `'Date'`) comes back `{}` (`'plain'`), and a host object comes back as
+ * itself (`'opaque'`). A prototype whose instance the clone refuses is `'opaque'` — remembered too:
+ * it cannot be held, and its commit will refuse it.
+ */
+function kindOf(value) {
+    if (Array.isArray(value))
+        return 'array';
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null)
+        return 'plain';
+    return builtinKind(value) ?? PROBED.get(proto) ?? probe(value, proto);
+}
+exports.kindOf = kindOf;
+function probe(value, proto) {
+    let kind;
+    try {
+        const clone = structuredClone(value);
+        kind = clone === null || typeof clone !== 'object' ? 'opaque' : kindOfClone(clone);
+    }
+    catch {
+        kind = 'opaque';
+    }
+    PROBED.set(proto, kind);
+    return kind;
+}
+/** The kind of a CLONE — a value of this realm, so its prototype or its brand decides it. */
+function kindOfClone(clone) {
+    if (Array.isArray(clone))
+        return 'array';
+    const proto = Object.getPrototypeOf(clone);
+    if (proto === Object.prototype || proto === null)
+        return 'plain';
+    return builtinKind(clone) ?? 'opaque';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"valueKinds.js","sourceRoot":"","sources":["../../../src/lib/capture/valueKinds.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * valueKinds.ts — what KIND of value a record holds: the one classifier.\n *\n * WHY. Committed state is what survives `structuredClone` (an engine invariant), so the values a\n * record holds are the kinds the clone keeps. Two laws need the kind, and both ask here:\n *\n *   - what counts as a CHANGE (`memory/equality.ts · deepEqual`): two values are equal when a record\n *     holds the same thing for both, compared kind by kind. Until 9.44.2 only Date, Map and Set had a\n *     kind; a RegExp, an Error, a boxed number, a buffer, a DataView or a Blob was compared as an\n *     object with no own keys — equal to any other of its kind — so replacing one committed no row\n *     and live state kept the old value;\n *   - what a served record must COPY (`capture/freeze.ts · freezeRecord` / `serveRecord`):\n *     `Object.freeze` seals only the kinds whose content is their own properties ({@link SEALABLE}).\n *\n * A leaf: imports nothing (`capture/` is L0, below `memory/`).\n *\n * @example\n * ```typescript\n * kindOf(new Date(0));                    // 'date'\n * kindOf(new (class Point { x = 1 })());  // 'plain' — its clone is a plain object\n * kindOf(new Blob(['a']));                // 'opaque' — its clone keeps content this library cannot read\n * SEALABLE.date;                          // false — setTime writes a slot Object.freeze cannot reach\n * ```\n */\n\n/** Every kind a record can hold. */\nexport type ValueKind =\n  /** An object the clone keeps as its own enumerable keys — a class instance included. */\n  | 'plain'\n  | 'array'\n  | 'date'\n  | 'regexp'\n  | 'map'\n  | 'set'\n  | 'error'\n  /** A boxed primitive: `new Number(1)`, `new String('a')`, `new Boolean(true)`, `Object(1n)`. */\n  | 'boxed'\n  /** An `ArrayBuffer` (a `SharedArrayBuffer` too: shared memory is out of contract for state). */\n  | 'buffer'\n  /** A typed array or a `DataView`. */\n  | 'view'\n  /** Any other object the clone keeps as itself (a Blob, a File, a `DOMException`): content unread here. */\n  | 'opaque';\n\n/**\n * Does `Object.freeze` seal every part of a value of this kind? True only where the content is the\n * value's own properties (or a slot nothing can write). A `Record`, so a new kind does not compile\n * until it is decided here.\n */\nexport const SEALABLE: { readonly [K in ValueKind]: boolean } = /* @__PURE__ */ Object.freeze({\n  plain: true,\n  array: true,\n  boxed: true,\n  date: false, // setTime & co. write its time value\n  regexp: false, // compile() rewrites source and flags, even on a frozen one\n  map: false, // set / delete / clear\n  set: false, // add / delete / clear\n  error: false, // V8's own `stack` accessor writes through a frozen error\n  buffer: false, // its bytes, through any view; transfer() detaches it\n  view: false, // index writes, set, fill, sort, copyWithin …\n  opaque: false, // content this library cannot read — never assumed sealed\n});\n\n/** What a brand check returns, when it does not throw, for a value without the slot. */\nconst NOT_BRAND = Symbol('not the brand');\n\n/**\n * A built-in kind is known by its BRAND — an internal slot only the real thing has — never by its\n * prototype: `Object.create(RegExp.prototype)` is not a RegExp (its clone is `{}`), and reading\n * `source` from it throws. The candidate comes from `Object.prototype.toString` (one call), then ONE\n * brand-checked read confirms it; a value that fails it is classified by its clone instead.\n */\nconst BRANDS: ReadonlyMap<string, { readonly kind: ValueKind; readonly check: (value: object) => unknown }> =\n  /* @__PURE__ */ brandTable();\n\nfunction brandTable(): Map<string, { kind: ValueKind; check: (value: object) => unknown }> {\n  const getter = (proto: object | undefined, key: string): ((value: object) => unknown) | undefined => {\n    const get = proto && Object.getOwnPropertyDescriptor(proto, key)?.get;\n    return get ? (value) => get.call(value) : undefined;\n  };\n  const global = globalThis as unknown as Record<string, { prototype?: object } | undefined>;\n  const isError = (Error as unknown as { isError?: (value: unknown) => boolean }).isError;\n  const rows: Array<[string, ValueKind, ((value: object) => unknown) | undefined]> = [\n    ['Date', 'date', (value) => Date.prototype.getTime.call(value)],\n    ['RegExp', 'regexp', getter(RegExp.prototype, 'source')],\n    ['Map', 'map', getter(Map.prototype, 'size')],\n    ['Set', 'set', getter(Set.prototype, 'size')],\n    // An error's tag comes from its own [[ErrorData]] slot: no Error prototype carries a toStringTag. Where\n    // the brand check `Error.isError` is missing (Node 22), a tag a getter supplies is therefore a spoof.\n    ['Error', 'error', (value) => ((isError ? isError(value) : untagged(value)) ? true : NOT_BRAND)],\n    ['Number', 'boxed', (value) => Number.prototype.valueOf.call(value)],\n    ['String', 'boxed', (value) => String.prototype.valueOf.call(value)],\n    ['Boolean', 'boxed', (value) => Boolean.prototype.valueOf.call(value)],\n    ['BigInt', 'boxed', (value) => (global.BigInt?.prototype as { valueOf(): unknown }).valueOf.call(value)],\n    ['ArrayBuffer', 'buffer', getter(ArrayBuffer.prototype, 'byteLength')],\n    ['SharedArrayBuffer', 'buffer', getter(global.SharedArrayBuffer?.prototype, 'byteLength')],\n  ];\n  const table = new Map<string, { kind: ValueKind; check: (value: object) => unknown }>();\n  for (const [name, kind, check] of rows) if (check) table.set(`[object ${name}]`, { kind, check });\n  return table;\n}\n\n/** No `Symbol.toStringTag` on the value or its prototypes: its tag came from a slot. */\nfunction untagged(value: object): boolean {\n  return (value as Record<symbol, unknown>)[Symbol.toStringTag] === undefined;\n}\n\n/** The kind of a built-in value, by its brand — `undefined` for anything else. */\nfunction builtinKind(value: object): ValueKind | undefined {\n  if (ArrayBuffer.isView(value)) return 'view'; // a brand check of its own: [[ViewedArrayBuffer]]\n  const brand = BRANDS.get(Object.prototype.toString.call(value));\n  if (brand === undefined) return undefined;\n  try {\n    return brand.check(value) === NOT_BRAND ? undefined : brand.kind;\n  } catch {\n    return undefined; // the prototype without the slot\n  }\n}\n\n/** Prototypes classified by a probe clone of their first instance (see {@link kindOf}). */\nconst PROBED = new WeakMap<object, ValueKind>();\n\n/**\n * The kind of an object, as a record holds it. A plain object or an array — the bulk of state —\n * costs one `Array.isArray` and one `getPrototypeOf`; a built-in a tag and one brand-checked read.\n * The brand is the value's own slot, so a subclass (a `Map` subclass is a `'map'`, Node's `Buffer` a\n * `'view'`) and a value from another realm land on their kind.\n *\n * Any other object is classified by WHAT ITS CLONE IS, once per prototype: a class instance comes\n * back a plain object (`'plain'`), a fake built-in (`Object.create(Date.prototype)`, or a class whose\n * `Symbol.toStringTag` says `'Date'`) comes back `{}` (`'plain'`), and a host object comes back as\n * itself (`'opaque'`). A prototype whose instance the clone refuses is `'opaque'` — remembered too:\n * it cannot be held, and its commit will refuse it.\n */\nexport function kindOf(value: object): ValueKind {\n  if (Array.isArray(value)) return 'array';\n  const proto = Object.getPrototypeOf(value);\n  if (proto === Object.prototype || proto === null) return 'plain';\n  return builtinKind(value) ?? PROBED.get(proto) ?? probe(value, proto);\n}\n\nfunction probe(value: object, proto: object): ValueKind {\n  let kind: ValueKind;\n  try {\n    const clone: unknown = structuredClone(value);\n    kind = clone === null || typeof clone !== 'object' ? 'opaque' : kindOfClone(clone);\n  } catch {\n    kind = 'opaque';\n  }\n  PROBED.set(proto, kind);\n  return kind;\n}\n\n/** The kind of a CLONE — a value of this realm, so its prototype or its brand decides it. */\nfunction kindOfClone(clone: object): ValueKind {\n  if (Array.isArray(clone)) return 'array';\n  const proto = Object.getPrototypeOf(clone);\n  if (proto === Object.prototype || proto === null) return 'plain';\n  return builtinKind(clone) ?? 'opaque';\n}\n"]}