footprintjs 9.44.0 → 9.44.2

package/dist/esm/lib/capture/valueKinds.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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
+ * ```
+ */
+/** Every kind a record can hold. */
+export type ValueKind = 
+/** An object the clone keeps as its own enumerable keys — a class instance included. */
+'plain' | 'array' | 'date' | 'regexp' | 'map' | 'set' | 'error'
+/** A boxed primitive: `new Number(1)`, `new String('a')`, `new Boolean(true)`, `Object(1n)`. */
+ | 'boxed'
+/** An `ArrayBuffer` (a `SharedArrayBuffer` too: shared memory is out of contract for state). */
+ | 'buffer'
+/** A typed array or a `DataView`. */
+ | 'view'
+/** Any other object the clone keeps as itself (a Blob, a File, a `DOMException`): content unread here. */
+ | 'opaque';
+/**
+ * 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.
+ */
+export declare const SEALABLE: {
+    readonly [K in ValueKind]: boolean;
+};
+/**
+ * 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.
+ */
+export declare function kindOf(value: object): ValueKind;

package/dist/esm/lib/capture/valueKinds.js

@@ -0,0 +1,142 @@
+/**
+ * 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
+ * ```
+ */
+/**
+ * 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.
+ */
+export const SEALABLE = /* @__PURE__ */ 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.
+ */
+export 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);
+}
+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"]}

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

@@ -13,11 +13,17 @@
  * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by
  * test/lib/memory/property/record-reachability.property.test.ts.
  *
- * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's
- * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung
- * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps
- * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`
- * regex read from a bundle throws when `exec` or `replace` advance it.
+ * What `Object.freeze` cannot seal — a Date's time, a Map's or Set's entries, a buffer's bytes, a
+ * RegExp, an Error's stack — is never handed out to a reader (9.44.2): `record` remembers that a
+ * bundle holds such a value (`capture/freeze.ts · freezeRecord`), and `list()` — like the public
+ * snapshot, `runner/snapshot.ts · servedSnapshot` — serves that bundle as a copy of its open paths
+ * (`serveRecord`, mapped at its first serve): fresh frozen containers down to each such value, a
+ * fresh copy of it, every other part the log's own. A reader edits only its own copy; every later
+ * serve reads the record as recorded. `recorded()` is the engine's own, unserved read. Named holes: an object hung on an array EXPANDO (arrays are walked
+ * by index — the `'indices'` walk, which keeps the freeze inside its budget; an expando is out of
+ * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's
+ * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or
+ * `replace` advance it.
  */
 import type { EmitSourcePosition, LogAddress } from './eventPosition.js';
 import type { CommitBundle } from './types.js';
@@ -72,8 +78,20 @@ export declare class EventLog {
      * will no longer edit — its own object is the one frozen.
      */
     record(bundle: CommitBundle): void;
-    /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */
+    /**
+     * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed
+     * whole is the log's own (frozen) object, one holding a Date, Map, buffer … is a copy of its open
+     * paths (`capture/freeze.ts · serveRecord`) — the reader's own, so no edit reaches the log.
+     */
     list(): CommitBundle[];
+    /**
+     * @internal The bundles as the log holds them — each frozen, NOT served — in a new array, so a holder's
+     * `splice` reaches only its own. For the engine's own snapshot (`ExecutionRuntime · getSnapshot`, which
+     * a subflow mount takes once per mount), so the run serves nothing; a reader is served by `list()` and
+     * `getSnapshot().commitLog`. A known open door (CHANGELOG 9.44.2): a holder of these bundles can still
+     * edit a Date, Map or buffer inside them.
+     */
+    recorded(): CommitBundle[];
     /** Number of recorded commits. */
     get length(): number;
     /** Immutable identity of this log, absent until the engine binds it. */

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

@@ -13,13 +13,19 @@
  * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by
  * test/lib/memory/property/record-reachability.property.test.ts.
  *
- * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's
- * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung
- * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps
- * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`
- * regex read from a bundle throws when `exec` or `replace` advance it.
+ * What `Object.freeze` cannot seal — a Date's time, a Map's or Set's entries, a buffer's bytes, a
+ * RegExp, an Error's stack — is never handed out to a reader (9.44.2): `record` remembers that a
+ * bundle holds such a value (`capture/freeze.ts · freezeRecord`), and `list()` — like the public
+ * snapshot, `runner/snapshot.ts · servedSnapshot` — serves that bundle as a copy of its open paths
+ * (`serveRecord`, mapped at its first serve): fresh frozen containers down to each such value, a
+ * fresh copy of it, every other part the log's own. A reader edits only its own copy; every later
+ * serve reads the record as recorded. `recorded()` is the engine's own, unserved read. Named holes: an object hung on an array EXPANDO (arrays are walked
+ * by index — the `'indices'` walk, which keeps the freeze inside its budget; an expando is out of
+ * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's
+ * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or
+ * `replace` advance it.
  */
-import { deepFreeze } from '../capture/freeze.js';
+import { freezeRecord, serveRecord } from '../capture/freeze.js';
 import { applySmartMergeInto } from './utils.js';
 export class EventLog {
     /** Base snapshot BEFORE the first stage mutates anything. */
@@ -88,12 +94,26 @@ export class EventLog {
      */
     record(bundle) {
         bundle.idx = this.steps.length;
-        deepFreeze(bundle, 'indices');
+        freezeRecord(bundle, 'indices');
         this.steps.push(bundle);
     }
-    /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */
+    /**
+     * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed
+     * whole is the log's own (frozen) object, one holding a Date, Map, buffer … is a copy of its open
+     * paths (`capture/freeze.ts · serveRecord`) — the reader's own, so no edit reaches the log.
+     */
     list() {
-        return this.steps;
+        return this.steps.map(serveRecord);
+    }
+    /**
+     * @internal The bundles as the log holds them — each frozen, NOT served — in a new array, so a holder's
+     * `splice` reaches only its own. For the engine's own snapshot (`ExecutionRuntime · getSnapshot`, which
+     * a subflow mount takes once per mount), so the run serves nothing; a reader is served by `list()` and
+     * `getSnapshot().commitLog`. A known open door (CHANGELOG 9.44.2): a holder of these bundles can still
+     * edit a Date, Map or buffer inside them.
+     */
+    recorded() {
+        return this.steps.slice();
     }
     /** Number of recorded commits. */
     get length() {
@@ -125,4 +145,4 @@ export class EventLog {
         this.sourceAddressRetired = true;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../../../src/lib/memory/EventLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,OAAO,QAAQ;IACnB,6DAA6D;IACrD,IAAI,CAAM;IAClB,sCAAsC;IAC9B,KAAK,GAAmB,EAAE,CAAC;IAC3B,aAAa,CAAc;IAC3B,oBAAoB,GAAG,KAAK,CAAC;IAErC,YAAY,aAAkB;QAC5B,uEAAuE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,IAAI,GAAG,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,eAAe;QACb,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;QACrC,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,mBAAmB,CAAC,GAAG,EAAE,OAAsB,EAAE,SAAwB,EAAE,KAAK,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAoB;QACzB,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,uFAAuF;IACvF,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,kCAAkC;IAClC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,wEAAwE;IACxE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,wFAAwF;IACxF,WAAW,CAAC,QAAgB,EAAE,SAA4B;QACxD,IAAI,IAAI,CAAC,oBAAoB;YAAE,OAAO;QACtC,IAAI,CAAC,aAAa,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,+FAA+F;IAC/F,eAAe,CAAC,KAAa;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,SAAS,CAAC;QAC1C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,mBAAmB,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC;IACrG,CAAC;IAED,8CAA8C;IAC9C,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,wEAAwE;QACxE,sEAAsE;QACtE,uEAAuE;QACvE,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IACnC,CAAC;CACF","sourcesContent":["/**\n * EventLog — Time-travel snapshot storage for flowchart execution\n *\n * Like git history: stores commit bundles (diffs), not full snapshots.\n *\n * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is\n * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the\n * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no\n * longer rewrite the history every later answer is folded from: an assignment into a bundle throws\n * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:\n * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of\n * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy\n * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by\n * test/lib/memory/property/record-reachability.property.test.ts.\n *\n * Named holes — what `Object.freeze` cannot reach stays mutable: Map and Set contents, a Date's\n * time, the bytes of a typed array (skipped: a non-empty one cannot be frozen), and an object hung\n * on an array EXPANDO (arrays are walked by index — `deepFreeze`'s `'indices'` walk, which keeps\n * the freeze inside its budget). A frozen RegExp's `lastIndex` is read-only, so a `/g` or `/y`\n * regex read from a bundle throws when `exec` or `replace` advance it.\n */\n\nimport { deepFreeze } from '../capture/freeze.js';\nimport type { EmitSourcePosition, LogAddress } from './eventPosition.js';\nimport type { CommitBundle, MemoryPatch } from './types.js';\nimport { applySmartMergeInto } from './utils.js';\n\nexport class EventLog {\n  /** Base snapshot BEFORE the first stage mutates anything. */\n  private base: any;\n  /** Ordered list of commit bundles. */\n  private steps: CommitBundle[] = [];\n  private sourceAddress?: LogAddress;\n  private sourceAddressRetired = false;\n\n  constructor(initialMemory: any) {\n    // Normalised to an object: the base is a STATE, and every fold over it\n    // (`materialise`, `stateAt`) applies path writes to it. `undefined` —\n    // what a run with no `initialContext` used to store here — made every\n    // one of those folds throw on the first `set`.\n    this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);\n  }\n\n  /**\n   * The fold BASE — the state as it stood before the first commit.\n   *\n   * This is the other half of the commit log: bundles are DIFFS, so a log\n   * alone cannot reconstruct state that was seeded before the run (an\n   * executor `initialContext`, `defaultValuesForContext`, a resume's\n   * `checkpoint.sharedState`, a subflow's `inputMapper` seed). Travelling\n   * with the log — `RuntimeSnapshot.initialState` — is what lets an OFFLINE\n   * consumer fold; without it the honest answer is a partial one\n   * (`stateAt`'s `basis: 'log-only'`).\n   *\n   * Returns a fresh detached clone on every call — the caller owns it.\n   */\n  getInitialState(): any {\n    return structuredClone(this.base);\n  }\n\n  /**\n   * Reconstructs the full state at any given step.\n   * Replays commits from the beginning — O(n) but low memory footprint.\n   *\n   * INDEX CONVENTION — `stepIdx` is EXCLUSIVE: `materialise(3)` folds commits\n   * 0, 1 and 2. `stateAt(source, commitIdx)` (footprintjs/trace) folds the\n   * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks\n   * \"the state AT this stop\", which must include that stop's own commit. Two\n   * folds over one log with opposite conventions: check which one you hold.\n   *\n   * One clone of the base per call, then every bundle replayed INTO that\n   * private copy (`applySmartMergeInto` — the live commit's copy-on-write law\n   * below the root, 9.29.0, so the fold and the live state agree at every\n   * path). The result is the caller's: it shares nothing with the base or\n   * the log.\n   *\n   * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log\n   * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).\n   * Nothing in the library calls this; it stays for one minor and is then removed. Mind the\n   * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.\n   */\n  materialise(stepIdx = this.steps.length): any {\n    const out = structuredClone(this.base);\n    for (let i = 0; i < stepIdx; i++) {\n      const { overwrite, updates, trace } = this.steps[i];\n      applySmartMergeInto(out, updates as MemoryPatch, overwrite as MemoryPatch, trace);\n    }\n    return out;\n  }\n\n  /**\n   * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle\n   * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle\n   * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it\n   * will no longer edit — its own object is the one frozen.\n   */\n  record(bundle: CommitBundle): void {\n    bundle.idx = this.steps.length;\n    deepFreeze(bundle, 'indices');\n    this.steps.push(bundle);\n  }\n\n  /** Gets all recorded commit bundles — the live array; every bundle in it is frozen. */\n  list(): CommitBundle[] {\n    return this.steps;\n  }\n\n  /** Number of recorded commits. */\n  get length(): number {\n    return this.steps.length;\n  }\n\n  /** Immutable identity of this log, absent until the engine binds it. */\n  get address(): LogAddress | undefined {\n    return this.sourceAddress;\n  }\n\n  /** @internal Bind once; resuming the same log must not rename its earlier positions. */\n  bindAddress(logRunId: string, drillPath: readonly string[]): void {\n    if (this.sourceAddressRetired) return;\n    this.sourceAddress ??= Object.freeze({ logRunId, drillPath: Object.freeze([...drillPath]) });\n  }\n\n  /** O(1) source-time capture. No counter, observer bookkeeping, or future commit prediction. */\n  capturePosition(runId: string): EmitSourcePosition | undefined {\n    if (!this.sourceAddress) return undefined;\n    return Object.freeze({ runId, ...this.sourceAddress, committedThroughIdx: this.steps.length - 1 });\n  }\n\n  /** Wipes history (useful for test resets). */\n  clear(): void {\n    this.steps = [];\n    // A reset prefix cannot reuse old coordinates, even if another stage of\n    // the SAME leg binds it again. Keep clear's data behavior, but retire\n    // addressing for this log; known coordinates require a fresh EventLog.\n    this.sourceAddress = undefined;\n    this.sourceAddressRetired = true;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../../../src/lib/memory/EventLog.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EventLog — Time-travel snapshot storage for flowchart execution\n *\n * Like git history: stores commit bundles (diffs), not full snapshots.\n *\n * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is\n * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the\n * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no\n * longer rewrite the history every later answer is folded from: an assignment into a bundle throws\n * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:\n * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of\n * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy\n * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by\n * test/lib/memory/property/record-reachability.property.test.ts.\n *\n * What `Object.freeze` cannot seal — a Date's time, a Map's or Set's entries, a buffer's bytes, a\n * RegExp, an Error's stack — is never handed out to a reader (9.44.2): `record` remembers that a\n * bundle holds such a value (`capture/freeze.ts · freezeRecord`), and `list()` — like the public\n * snapshot, `runner/snapshot.ts · servedSnapshot` — serves that bundle as a copy of its open paths\n * (`serveRecord`, mapped at its first serve): fresh frozen containers down to each such value, a\n * fresh copy of it, every other part the log's own. A reader edits only its own copy; every later\n * serve reads the record as recorded. `recorded()` is the engine's own, unserved read. Named holes: an object hung on an array EXPANDO (arrays are walked\n * by index — the `'indices'` walk, which keeps the freeze inside its budget; an expando is out of\n * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's\n * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or\n * `replace` advance it.\n */\n\nimport { freezeRecord, serveRecord } from '../capture/freeze.js';\nimport type { EmitSourcePosition, LogAddress } from './eventPosition.js';\nimport type { CommitBundle, MemoryPatch } from './types.js';\nimport { applySmartMergeInto } from './utils.js';\n\nexport class EventLog {\n  /** Base snapshot BEFORE the first stage mutates anything. */\n  private base: any;\n  /** Ordered list of commit bundles. */\n  private steps: CommitBundle[] = [];\n  private sourceAddress?: LogAddress;\n  private sourceAddressRetired = false;\n\n  constructor(initialMemory: any) {\n    // Normalised to an object: the base is a STATE, and every fold over it\n    // (`materialise`, `stateAt`) applies path writes to it. `undefined` —\n    // what a run with no `initialContext` used to store here — made every\n    // one of those folds throw on the first `set`.\n    this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);\n  }\n\n  /**\n   * The fold BASE — the state as it stood before the first commit.\n   *\n   * This is the other half of the commit log: bundles are DIFFS, so a log\n   * alone cannot reconstruct state that was seeded before the run (an\n   * executor `initialContext`, `defaultValuesForContext`, a resume's\n   * `checkpoint.sharedState`, a subflow's `inputMapper` seed). Travelling\n   * with the log — `RuntimeSnapshot.initialState` — is what lets an OFFLINE\n   * consumer fold; without it the honest answer is a partial one\n   * (`stateAt`'s `basis: 'log-only'`).\n   *\n   * Returns a fresh detached clone on every call — the caller owns it.\n   */\n  getInitialState(): any {\n    return structuredClone(this.base);\n  }\n\n  /**\n   * Reconstructs the full state at any given step.\n   * Replays commits from the beginning — O(n) but low memory footprint.\n   *\n   * INDEX CONVENTION — `stepIdx` is EXCLUSIVE: `materialise(3)` folds commits\n   * 0, 1 and 2. `stateAt(source, commitIdx)` (footprintjs/trace) folds the\n   * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks\n   * \"the state AT this stop\", which must include that stop's own commit. Two\n   * folds over one log with opposite conventions: check which one you hold.\n   *\n   * One clone of the base per call, then every bundle replayed INTO that\n   * private copy (`applySmartMergeInto` — the live commit's copy-on-write law\n   * below the root, 9.29.0, so the fold and the live state agree at every\n   * path). The result is the caller's: it shares nothing with the base or\n   * the log.\n   *\n   * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log\n   * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).\n   * Nothing in the library calls this; it stays for one minor and is then removed. Mind the\n   * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.\n   */\n  materialise(stepIdx = this.steps.length): any {\n    const out = structuredClone(this.base);\n    for (let i = 0; i < stepIdx; i++) {\n      const { overwrite, updates, trace } = this.steps[i];\n      applySmartMergeInto(out, updates as MemoryPatch, overwrite as MemoryPatch, trace);\n    }\n    return out;\n  }\n\n  /**\n   * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle\n   * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle\n   * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it\n   * will no longer edit — its own object is the one frozen.\n   */\n  record(bundle: CommitBundle): void {\n    bundle.idx = this.steps.length;\n    freezeRecord(bundle, 'indices');\n    this.steps.push(bundle);\n  }\n\n  /**\n   * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed\n   * whole is the log's own (frozen) object, one holding a Date, Map, buffer … is a copy of its open\n   * paths (`capture/freeze.ts · serveRecord`) — the reader's own, so no edit reaches the log.\n   */\n  list(): CommitBundle[] {\n    return this.steps.map(serveRecord);\n  }\n\n  /**\n   * @internal The bundles as the log holds them — each frozen, NOT served — in a new array, so a holder's\n   * `splice` reaches only its own. For the engine's own snapshot (`ExecutionRuntime · getSnapshot`, which\n   * a subflow mount takes once per mount), so the run serves nothing; a reader is served by `list()` and\n   * `getSnapshot().commitLog`. A known open door (CHANGELOG 9.44.2): a holder of these bundles can still\n   * edit a Date, Map or buffer inside them.\n   */\n  recorded(): CommitBundle[] {\n    return this.steps.slice();\n  }\n\n  /** Number of recorded commits. */\n  get length(): number {\n    return this.steps.length;\n  }\n\n  /** Immutable identity of this log, absent until the engine binds it. */\n  get address(): LogAddress | undefined {\n    return this.sourceAddress;\n  }\n\n  /** @internal Bind once; resuming the same log must not rename its earlier positions. */\n  bindAddress(logRunId: string, drillPath: readonly string[]): void {\n    if (this.sourceAddressRetired) return;\n    this.sourceAddress ??= Object.freeze({ logRunId, drillPath: Object.freeze([...drillPath]) });\n  }\n\n  /** O(1) source-time capture. No counter, observer bookkeeping, or future commit prediction. */\n  capturePosition(runId: string): EmitSourcePosition | undefined {\n    if (!this.sourceAddress) return undefined;\n    return Object.freeze({ runId, ...this.sourceAddress, committedThroughIdx: this.steps.length - 1 });\n  }\n\n  /** Wipes history (useful for test resets). */\n  clear(): void {\n    this.steps = [];\n    // A reset prefix cannot reuse old coordinates, even if another stage of\n    // the SAME leg binds it again. Keep clear's data behavior, but retire\n    // addressing for this log; known coordinates require a fresh EventLog.\n    this.sourceAddress = undefined;\n    this.sourceAddressRetired = true;\n  }\n}\n"]}

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

@@ -48,10 +48,11 @@ function foldsBack(fold, workingCopy, family, address) {
         return false;
     const folded = _get(fold, segments);
     const read = _get(workingCopy, segments);
-    if (deepEqual(folded, read))
+    // Both sides are the same values as a record holds them: an opaque one (a Blob) is never the same object.
+    if (deepEqual(folded, read, 'copies'))
         return true;
     family.held = { value: structuredClone(read) };
-    return deepEqual(folded, family.held.value);
+    return deepEqual(folded, family.held.value, 'copies');
 }
 /**
  * Every staged path grouped under its SHALLOWEST staged ancestor-or-self —
@@ -149,4 +150,4 @@ function shallowestIn(path, touched) {
     }
     return path;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"admission.js","sourceRoot":"","sources":["../../../../src/lib/memory/admission.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * admission.ts — the admitted record's check (9.30.0): does a commit's bundle\n * fold back to what its stage read? (docs/design/2026-10-admitted-record.md)\n *\n * THE LAW: a commit is admitted only if its bundle, replayed onto the state\n * the stage began from, gives back the stage's read-your-writes view at every\n * path the stage touched — and at every container and array slot its writes\n * made on the way there, below the stage's address.\n *\n * Pure: handed the candidate rows, the stage's diff base, its working copy,\n * its op trace and its address, {@link lossyFamilies} answers which families\n * of touched paths do not fold back. `TransactionBuffer · admit` asks once per\n * commit that staged a `merge` or a nested op, and lays the rows out again\n * with those families written as what the stage read. The fold is the one\n * verb law ({@link dryFold}, no clone); the compare is {@link deepEqual}.\n */\n\nimport { isContainer, nativeGet as _get, ownChild } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\nimport { deepEqual, DELIM, dryFold } from './utils.js';\n\n/** The rows a payload is built from, before the commit names its redacted paths. */\nexport type Rows = { overwrite: MemoryPatch; updates: MemoryPatch; trace: TraceEntry[] };\n\n/** One staged op, as `TransactionBuffer` records it. */\nexport type StagedOp = { path: string; verb: string; readKeys?: string[] };\n\n/** A staged path in a {@link Family}, with its last op's read prefix. */\nexport type Member = { path: string; readKeys?: string[] };\n\n/**\n * A family of TOUCHED paths: every staged path under its shallowest staged\n * ancestor-or-self — the unit the check verifies and, when it does not fold\n * back, the unit re-encoded. Two families never overlap.\n */\nexport type Family = {\n  root: string;\n  rootSegments: string[];\n  /** Its staged paths, by last touch. */\n  members: Member[];\n  /** Index in the op trace of the family's last op: where its re-encoded rows go. */\n  slot: number;\n  /**\n   * The root's read-back as a record can hold it — its `structuredClone`,\n   * boxed — when the check took one ({@link foldsBack}); the re-encoding\n   * reuses it.\n   */\n  held?: { value: unknown };\n};\n\n/** The families whose rows did not fold back, and which family every staged path is in. */\nexport type Lossy = { rootOf: Map<string, string>; families: Map<string, Family> };\n\n/**\n * The families of `ops` whose candidate rows do not fold back to what the\n * stage read — `undefined` when every family does. Each family ROOT is\n * compared ({@link foldsBack}): its value and the way down to it.\n */\nexport function lossyFamilies(\n  candidate: Rows,\n  base: unknown,\n  workingCopy: unknown,\n  ops: readonly StagedOp[],\n  address: readonly string[],\n): Lossy | undefined {\n  const fold = dryFold(base, candidate.updates, candidate.overwrite, candidate.trace);\n  const { rootOf, families } = touchedFamilies(ops);\n  let lossy: Map<string, Family> | undefined;\n  for (const family of families.values()) {\n    if (!foldsBack(fold, workingCopy, family, address)) (lossy ??= new Map()).set(family.root, family);\n  }\n  return lossy === undefined ? undefined : { rootOf, families: lossy };\n}\n\n/**\n * Does the fold give back what the stage read at a family root? The way down\n * ({@link spineHeld}), then the value by {@link deepEqual} (a root covers every\n * descendant; an own `undefined` is a deleted key) — against the read-back as\n * a record can hold it. A record holds `structuredClone`s of what a stage\n * wrote (state values must survive one), and a few values do not survive one\n * whole: an `Error`'s own fields are dropped. When the fold equals the\n * read-back's clone, no row could hold more, and the family is admitted as it\n * is; the clone, taken only for a root the cheap compare refused, is kept for\n * the re-encoding.\n */\nfunction foldsBack(fold: unknown, workingCopy: unknown, family: Family, address: readonly string[]): boolean {\n  const segments = family.rootSegments;\n  if (!spineHeld(fold, workingCopy, segments, address)) return false;\n  const folded = _get(fold, segments);\n  const read = _get(workingCopy, segments);\n  if (deepEqual(folded, read)) return true;\n  family.held = { value: structuredClone(read) };\n  return deepEqual(folded, family.held.value);\n}\n\n/**\n * Every staged path grouped under its SHALLOWEST staged ancestor-or-self —\n * over TOUCHED paths, not surviving ones: an op the net-change filter drops\n * can still have changed what the stage reads (L-1). Members are listed by\n * last touch; a family's slot is its last op.\n */\nexport function touchedFamilies(ops: readonly StagedOp[]): {\n  rootOf: Map<string, string>;\n  families: Map<string, Family>;\n} {\n  const touches = new Map<string, { last: number; readKeys?: string[] }>();\n  for (let i = 0; i < ops.length; i++) {\n    touches.delete(ops[i].path); // re-insert: the Map's order is last-touch order\n    touches.set(ops[i].path, { last: i, readKeys: ops[i].readKeys });\n  }\n  const rootOf = new Map<string, string>();\n  const families = new Map<string, Family>();\n  for (const [path, touch] of touches) {\n    const root = shallowestIn(path, touches);\n    rootOf.set(path, root);\n    let family = families.get(root);\n    if (family === undefined) {\n      family = { root, rootSegments: root.split(DELIM), members: [], slot: touch.last };\n      families.set(root, family);\n    }\n    family.members.push({ path, readKeys: touch.readKeys });\n    if (touch.last > family.slot) family.slot = touch.last;\n  }\n  return { rootOf, families };\n}\n\n/**\n * How many leading segments of `path` are the stage's `address` — its length\n * when `path` lies strictly below it, else 0.\n */\nexport function addressDepthOf(path: readonly (string | number)[], address: readonly string[]): number {\n  const depth = address.length;\n  if (depth === 0 || path.length <= depth) return 0;\n  for (let i = 0; i < depth; i++) if (String(path[i]) !== address[i]) return 0;\n  return depth;\n}\n\n/**\n * L-1: a nested op through an absent or primitive parent makes that parent a\n * container in the working copy — and when the op itself changes nothing (a\n * delete of a key that was never there) no row is left to make it in the\n * fold, so the stage reads back a container the record never mentions. The\n * same op on an ARRAY parent past its end grows it (`delete a.0` on `[]`\n * reads back `[undefined]`). Every container the working copy holds on the\n * way to `segments`, and every array slot each step lands in, must be one the\n * fold holds too — below the stage's address, whose containers are where it\n * writes, not a value it reads.\n */\nfunction spineHeld(fold: unknown, workingCopy: unknown, segments: string[], address: readonly string[]): boolean {\n  const from = addressDepthOf(segments, address);\n  let f: unknown = fold;\n  let w: unknown = workingCopy;\n  for (let i = 0; i < segments.length; i++) {\n    if (i >= from && !slotHeld(f, w, segments[i])) return false;\n    if (i === segments.length - 1) return true;\n    f = ownChild(f, segments[i]);\n    w = ownChild(w, segments[i]);\n    if (!isContainer(w)) return true;\n    if (i >= from && (!isContainer(f) || Array.isArray(f) !== Array.isArray(w))) return false;\n  }\n  return true;\n}\n\n/**\n * Does the fold hold every array slot the working copy's container `w` holds\n * at `key`? Only an array can be grown by a write that changes nothing else\n * (an index past its end, set to `undefined`); an object's own `undefined`\n * key is a deleted key to every reader, so objects always pass.\n */\nfunction slotHeld(f: unknown, w: unknown, key: string): boolean {\n  if (!Array.isArray(w)) return true;\n  const index = Number(key);\n  if (!Number.isInteger(index) || index < 0 || String(index) !== key || index >= w.length) return true;\n  return Array.isArray(f) && index < f.length;\n}\n\n/** The shallowest of `path` and its ancestors that `touched` holds — its family's root. */\nfunction shallowestIn(path: string, touched: ReadonlyMap<string, unknown>): string {\n  if (path.indexOf(DELIM) === -1) return path;\n  const segments = path.split(DELIM);\n  for (let i = 1; i < segments.length; i++) {\n    const ancestor = segments.slice(0, i).join(DELIM);\n    if (touched.has(ancestor)) return ancestor;\n  }\n  return path;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"admission.js","sourceRoot":"","sources":["../../../../src/lib/memory/admission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,WAAW,EAAE,SAAS,IAAI,IAAI,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAkCvD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAC3B,SAAe,EACf,IAAa,EACb,WAAoB,EACpB,GAAwB,EACxB,OAA0B;IAE1B,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACpF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;IAClD,IAAI,KAAsC,CAAC;IAC3C,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;QACvC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC;YAAE,CAAC,KAAK,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACrG,CAAC;IACD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AACvE,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,SAAS,CAAC,IAAa,EAAE,WAAoB,EAAE,MAAc,EAAE,OAA0B;IAChG,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC;IACrC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IACnE,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACpC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;IACzC,0GAA0G;IAC1G,IAAI,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,CAAC,IAAI,GAAG,EAAE,KAAK,EAAE,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;IAC/C,OAAO,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACxD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,GAAwB;IAItD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAiD,CAAC;IACzE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,iDAAiD;QAC9E,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC3C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;QACpC,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACzC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACvB,IAAI,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,MAAM,GAAG,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;YAClF,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC7B,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxD,IAAI,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI;YAAE,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzD,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAkC,EAAE,OAA0B;IAC3F,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC;IAC7B,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,KAAK;QAAE,OAAO,CAAC,CAAC;IAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE;QAAE,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;YAAE,OAAO,CAAC,CAAC;IAC7E,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,SAAS,CAAC,IAAa,EAAE,WAAoB,EAAE,QAAkB,EAAE,OAA0B;IACpG,MAAM,IAAI,GAAG,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,IAAI,CAAC,GAAY,IAAI,CAAC;IACtB,IAAI,CAAC,GAAY,WAAW,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QAC5D,IAAI,CAAC,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC;QAC3C,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QACjC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;IAC5F,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,SAAS,QAAQ,CAAC,CAAU,EAAE,CAAU,EAAE,GAAW;IACnD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACrG,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC;AAC9C,CAAC;AAED,2FAA2F;AAC3F,SAAS,YAAY,CAAC,IAAY,EAAE,OAAqC;IACvE,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;YAAE,OAAO,QAAQ,CAAC;IAC7C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/**\n * admission.ts — the admitted record's check (9.30.0): does a commit's bundle\n * fold back to what its stage read? (docs/design/2026-10-admitted-record.md)\n *\n * THE LAW: a commit is admitted only if its bundle, replayed onto the state\n * the stage began from, gives back the stage's read-your-writes view at every\n * path the stage touched — and at every container and array slot its writes\n * made on the way there, below the stage's address.\n *\n * Pure: handed the candidate rows, the stage's diff base, its working copy,\n * its op trace and its address, {@link lossyFamilies} answers which families\n * of touched paths do not fold back. `TransactionBuffer · admit` asks once per\n * commit that staged a `merge` or a nested op, and lays the rows out again\n * with those families written as what the stage read. The fold is the one\n * verb law ({@link dryFold}, no clone); the compare is {@link deepEqual}.\n */\n\nimport { isContainer, nativeGet as _get, ownChild } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\nimport { deepEqual, DELIM, dryFold } from './utils.js';\n\n/** The rows a payload is built from, before the commit names its redacted paths. */\nexport type Rows = { overwrite: MemoryPatch; updates: MemoryPatch; trace: TraceEntry[] };\n\n/** One staged op, as `TransactionBuffer` records it. */\nexport type StagedOp = { path: string; verb: string; readKeys?: string[] };\n\n/** A staged path in a {@link Family}, with its last op's read prefix. */\nexport type Member = { path: string; readKeys?: string[] };\n\n/**\n * A family of TOUCHED paths: every staged path under its shallowest staged\n * ancestor-or-self — the unit the check verifies and, when it does not fold\n * back, the unit re-encoded. Two families never overlap.\n */\nexport type Family = {\n  root: string;\n  rootSegments: string[];\n  /** Its staged paths, by last touch. */\n  members: Member[];\n  /** Index in the op trace of the family's last op: where its re-encoded rows go. */\n  slot: number;\n  /**\n   * The root's read-back as a record can hold it — its `structuredClone`,\n   * boxed — when the check took one ({@link foldsBack}); the re-encoding\n   * reuses it.\n   */\n  held?: { value: unknown };\n};\n\n/** The families whose rows did not fold back, and which family every staged path is in. */\nexport type Lossy = { rootOf: Map<string, string>; families: Map<string, Family> };\n\n/**\n * The families of `ops` whose candidate rows do not fold back to what the\n * stage read — `undefined` when every family does. Each family ROOT is\n * compared ({@link foldsBack}): its value and the way down to it.\n */\nexport function lossyFamilies(\n  candidate: Rows,\n  base: unknown,\n  workingCopy: unknown,\n  ops: readonly StagedOp[],\n  address: readonly string[],\n): Lossy | undefined {\n  const fold = dryFold(base, candidate.updates, candidate.overwrite, candidate.trace);\n  const { rootOf, families } = touchedFamilies(ops);\n  let lossy: Map<string, Family> | undefined;\n  for (const family of families.values()) {\n    if (!foldsBack(fold, workingCopy, family, address)) (lossy ??= new Map()).set(family.root, family);\n  }\n  return lossy === undefined ? undefined : { rootOf, families: lossy };\n}\n\n/**\n * Does the fold give back what the stage read at a family root? The way down\n * ({@link spineHeld}), then the value by {@link deepEqual} (a root covers every\n * descendant; an own `undefined` is a deleted key) — against the read-back as\n * a record can hold it. A record holds `structuredClone`s of what a stage\n * wrote (state values must survive one), and a few values do not survive one\n * whole: an `Error`'s own fields are dropped. When the fold equals the\n * read-back's clone, no row could hold more, and the family is admitted as it\n * is; the clone, taken only for a root the cheap compare refused, is kept for\n * the re-encoding.\n */\nfunction foldsBack(fold: unknown, workingCopy: unknown, family: Family, address: readonly string[]): boolean {\n  const segments = family.rootSegments;\n  if (!spineHeld(fold, workingCopy, segments, address)) return false;\n  const folded = _get(fold, segments);\n  const read = _get(workingCopy, segments);\n  // Both sides are the same values as a record holds them: an opaque one (a Blob) is never the same object.\n  if (deepEqual(folded, read, 'copies')) return true;\n  family.held = { value: structuredClone(read) };\n  return deepEqual(folded, family.held.value, 'copies');\n}\n\n/**\n * Every staged path grouped under its SHALLOWEST staged ancestor-or-self —\n * over TOUCHED paths, not surviving ones: an op the net-change filter drops\n * can still have changed what the stage reads (L-1). Members are listed by\n * last touch; a family's slot is its last op.\n */\nexport function touchedFamilies(ops: readonly StagedOp[]): {\n  rootOf: Map<string, string>;\n  families: Map<string, Family>;\n} {\n  const touches = new Map<string, { last: number; readKeys?: string[] }>();\n  for (let i = 0; i < ops.length; i++) {\n    touches.delete(ops[i].path); // re-insert: the Map's order is last-touch order\n    touches.set(ops[i].path, { last: i, readKeys: ops[i].readKeys });\n  }\n  const rootOf = new Map<string, string>();\n  const families = new Map<string, Family>();\n  for (const [path, touch] of touches) {\n    const root = shallowestIn(path, touches);\n    rootOf.set(path, root);\n    let family = families.get(root);\n    if (family === undefined) {\n      family = { root, rootSegments: root.split(DELIM), members: [], slot: touch.last };\n      families.set(root, family);\n    }\n    family.members.push({ path, readKeys: touch.readKeys });\n    if (touch.last > family.slot) family.slot = touch.last;\n  }\n  return { rootOf, families };\n}\n\n/**\n * How many leading segments of `path` are the stage's `address` — its length\n * when `path` lies strictly below it, else 0.\n */\nexport function addressDepthOf(path: readonly (string | number)[], address: readonly string[]): number {\n  const depth = address.length;\n  if (depth === 0 || path.length <= depth) return 0;\n  for (let i = 0; i < depth; i++) if (String(path[i]) !== address[i]) return 0;\n  return depth;\n}\n\n/**\n * L-1: a nested op through an absent or primitive parent makes that parent a\n * container in the working copy — and when the op itself changes nothing (a\n * delete of a key that was never there) no row is left to make it in the\n * fold, so the stage reads back a container the record never mentions. The\n * same op on an ARRAY parent past its end grows it (`delete a.0` on `[]`\n * reads back `[undefined]`). Every container the working copy holds on the\n * way to `segments`, and every array slot each step lands in, must be one the\n * fold holds too — below the stage's address, whose containers are where it\n * writes, not a value it reads.\n */\nfunction spineHeld(fold: unknown, workingCopy: unknown, segments: string[], address: readonly string[]): boolean {\n  const from = addressDepthOf(segments, address);\n  let f: unknown = fold;\n  let w: unknown = workingCopy;\n  for (let i = 0; i < segments.length; i++) {\n    if (i >= from && !slotHeld(f, w, segments[i])) return false;\n    if (i === segments.length - 1) return true;\n    f = ownChild(f, segments[i]);\n    w = ownChild(w, segments[i]);\n    if (!isContainer(w)) return true;\n    if (i >= from && (!isContainer(f) || Array.isArray(f) !== Array.isArray(w))) return false;\n  }\n  return true;\n}\n\n/**\n * Does the fold hold every array slot the working copy's container `w` holds\n * at `key`? Only an array can be grown by a write that changes nothing else\n * (an index past its end, set to `undefined`); an object's own `undefined`\n * key is a deleted key to every reader, so objects always pass.\n */\nfunction slotHeld(f: unknown, w: unknown, key: string): boolean {\n  if (!Array.isArray(w)) return true;\n  const index = Number(key);\n  if (!Number.isInteger(index) || index < 0 || String(index) !== key || index >= w.length) return true;\n  return Array.isArray(f) && index < f.length;\n}\n\n/** The shallowest of `path` and its ancestors that `touched` holds — its family's root. */\nfunction shallowestIn(path: string, touched: ReadonlyMap<string, unknown>): string {\n  if (path.indexOf(DELIM) === -1) return path;\n  const segments = path.split(DELIM);\n  for (let i = 1; i < segments.length; i++) {\n    const ancestor = segments.slice(0, i).join(DELIM);\n    if (touched.has(ancestor)) return ancestor;\n  }\n  return path;\n}\n"]}

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

@@ -45,7 +45,7 @@ function joinSegment(prefix, segment, intoArray) {
  * `deepEqual`, and stops at the first disagreement.
  */
 export function firstDifferingPath(before, after, prefix = '', depth = 0) {
-    if (deepEqual(before, after))
+    if (deepEqual(before, after, 'copies'))
         return undefined;
     if (depth >= 24)
         return prefix; // pathological nesting — name what we have
@@ -127,4 +127,4 @@ export function borrowedMutationMessage(stageName, key, path) {
         'This usually comes from mutating an element reached by `find`/`filter`/`for…of`/`forEach`, ' +
         'which the scope proxy cannot intercept.');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"borrowedMutation.js","sourceRoot":"","sources":["../../../../src/lib/memory/borrowedMutation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * memory/borrowedMutation — the honest boundary's two texts: the dev-mode\n * REPORT for a write the engine cannot see ({@link borrowedMutationMessage})\n * and the REFUSAL for a write from a handle held past its stage\n * ({@link deadFrameMessage}, thrown by `StageContext.stageWrite`).\n *\n * ── The honest boundary ──────────────────────────────────────────────────\n * The typed scope intercepts every write it can reach: a property at any\n * depth, an indexed element, an array method. What it cannot reach is an\n * element handed out by a READ METHOD — `find`, `filter`, `for…of`, `forEach`,\n * destructuring — because wrapping those would mean returning proxies out of\n * every read (`map` would build an array of proxies, `filter` would compare\n * proxies, a returned value would escape the stage still bound to it). That is\n * a cost the library should not pay, and a semantic change it should not make.\n *\n * So the answer for that family is not interception — it is a REPORT. A read\n * is BORROWED; mutating it in place is out of contract. This module detects the\n * violation after the fact and names it (a dev-mode warning at commit — the\n * write already happened, so it cannot be refused), instead of letting the run\n * end with a commit log that disagrees with final state and nothing saying so.\n *\n * ── How ──────────────────────────────────────────────────────────────────\n * `readTracking: 'full'` (the default) already retains a CLONE of every value\n * a stage read. At commit, a key the stage read but never WROTE must still\n * hold what it held at read time — committed state is immutable-after-swap and\n * the buffer's working copy is private. If it differs, the only thing that can\n * have changed it is the stage itself, in place.\n *\n * Dev-mode only (`enableDevMode()`), so the default run pays nothing and its\n * bytes are unchanged.\n */\n\nimport { deepEqual } from './utils.js';\n\n/** Render one path segment for a human: `lines[0].qty`, not `lines.0.qty`. */\nfunction joinSegment(prefix: string, segment: string, intoArray: boolean): string {\n  if (intoArray) return `${prefix}[${segment}]`;\n  return prefix === '' ? segment : `${prefix}.${segment}`;\n}\n\n/**\n * The first path at which `after` stops agreeing with `before`, or `undefined`\n * when they are structurally equal. Depth-first, own keys only — the same\n * shapes `deepEqual` handles, since committed state is JSON-shaped.\n *\n * Cycle-safe by construction: it only recurses into pairs that are not already\n * `deepEqual`, and stops at the first disagreement.\n */\nexport function firstDifferingPath(before: unknown, after: unknown, prefix = '', depth = 0): string | undefined {\n  if (deepEqual(before, after)) return undefined;\n  if (depth >= 24) return prefix; // pathological nesting — name what we have\n  if (before === null || after === null || typeof before !== 'object' || typeof after !== 'object') return prefix;\n\n  const beforeIsArray = Array.isArray(before);\n  if (beforeIsArray !== Array.isArray(after)) return prefix;\n\n  if (beforeIsArray) {\n    const a = before as unknown[];\n    const b = after as unknown[];\n    if (a.length !== b.length) return prefix;\n    for (let i = 0; i < a.length; i++) {\n      const deeper = firstDifferingPath(a[i], b[i], joinSegment(prefix, String(i), true), depth + 1);\n      if (deeper !== undefined) return deeper;\n    }\n    return prefix;\n  }\n\n  const a = before as Record<string, unknown>;\n  const b = after as Record<string, unknown>;\n  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);\n  for (const key of keys) {\n    const deeper = firstDifferingPath(a[key], b[key], joinSegment(prefix, key, false), depth + 1);\n    if (deeper !== undefined) return deeper;\n  }\n  return prefix;\n}\n\n/**\n * The refusal text for a write that reached a frame AFTER its stage committed.\n * A scope, and every proxy read out of it, is bound to the stage it was handed\n * to; kept past that stage's commit it has no frame to land in, so the write\n * would sit in a buffer nothing ever commits — no trace row, state unchanged.\n * The throw surfaces in the stage that made the write (the engine's error\n * path names it); this text names the stage the handle came from.\n */\nexport function deadFrameMessage(stageName: string, runtimeStageId: string | undefined, key: string): string {\n  const from = runtimeStageId ? `\"${stageName}\" (${runtimeStageId})` : `\"${stageName}\"`;\n  return (\n    `[footprint] Stage ${from} has already committed — its scope is dead, and a write to \\`${key}\\` ` +\n    'just reached it from a later stage (this error is raised in that stage). A scope, and anything read ' +\n    'out of it (`scope.k`, `scope.k.arr[0]`), belongs to the stage it was handed to; held past that ' +\n    \"stage's commit it has no frame to land in, so the write would vanish with no trace row. \" +\n    \"Read the key again through the CURRENT stage's scope and write there.\"\n  );\n}\n\n/**\n * The warning text for a key the stage WROTE after changing, in place, the\n * committed value it had read before its first write (copy-on-write, 9.29.0).\n * The commit compares what the stage wrote against committed state — the\n * object the in-place change also moved — so it records no change: live state\n * keeps the edit, the log and every fold do not. (9.28.0 recorded it when the\n * edit came after the first write, by accident of a whole-state clone.)\n */\nexport function committedMutationMessage(stageName: string, key: string, path: string): string {\n  const where = path === '' ? key : `${key}.${path}`.replace(/\\.\\[/g, '[');\n  return (\n    `[footprint] Stage \"${stageName}\" changed \\`${where}\\` IN PLACE on the committed value it read before ` +\n    'its first write, then wrote the key. The commit compares the written value with committed state — ' +\n    'which the in-place change also moved — so it records NO change: live state keeps the edit, the commit ' +\n    'log and every reader that folds it do not. Reads are BORROWED. Build the next value instead ' +\n    `(\\`scope.$setValue('${key}', { ...value, … })\\`), or read the key again after the stage's first ` +\n    \"write — that read is the stage's own copy.\"\n  );\n}\n\n/**\n * The warning text. Names the stage, the exact path that moved, and the two\n * ways to write it back — because \"you mutated something\" is not actionable\n * and this is the one failure mode the whole design exists to prevent.\n */\nexport function borrowedMutationMessage(stageName: string, key: string, path: string): string {\n  const where = path === '' ? key : `${key}.${path}`.replace(/\\.\\[/g, '[');\n  return (\n    `[footprint] Stage \"${stageName}\" changed \\`${where}\\` IN PLACE, on a value it only read. ` +\n    'footprint never saw that write: there is no trace row for it, so the commit log, the causal chain ' +\n    'and every reader that folds the log will disagree with final state — and under a different write ' +\n    'order the change is dropped entirely. Reads are BORROWED. ' +\n    'Write through the scope instead (`scope.' +\n    where +\n    ' = …` — property and indexed access are both tracked), ' +\n    `or hand back the whole value with \\`scope.$setValue('${key}', next)\\`. ` +\n    'This usually comes from mutating an element reached by `find`/`filter`/`for…of`/`forEach`, ' +\n    'which the scope proxy cannot intercept.'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"borrowedMutation.js","sourceRoot":"","sources":["../../../../src/lib/memory/borrowedMutation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * memory/borrowedMutation — the honest boundary's two texts: the dev-mode\n * REPORT for a write the engine cannot see ({@link borrowedMutationMessage})\n * and the REFUSAL for a write from a handle held past its stage\n * ({@link deadFrameMessage}, thrown by `StageContext.stageWrite`).\n *\n * ── The honest boundary ──────────────────────────────────────────────────\n * The typed scope intercepts every write it can reach: a property at any\n * depth, an indexed element, an array method. What it cannot reach is an\n * element handed out by a READ METHOD — `find`, `filter`, `for…of`, `forEach`,\n * destructuring — because wrapping those would mean returning proxies out of\n * every read (`map` would build an array of proxies, `filter` would compare\n * proxies, a returned value would escape the stage still bound to it). That is\n * a cost the library should not pay, and a semantic change it should not make.\n *\n * So the answer for that family is not interception — it is a REPORT. A read\n * is BORROWED; mutating it in place is out of contract. This module detects the\n * violation after the fact and names it (a dev-mode warning at commit — the\n * write already happened, so it cannot be refused), instead of letting the run\n * end with a commit log that disagrees with final state and nothing saying so.\n *\n * ── How ──────────────────────────────────────────────────────────────────\n * `readTracking: 'full'` (the default) already retains a CLONE of every value\n * a stage read. At commit, a key the stage read but never WROTE must still\n * hold what it held at read time — committed state is immutable-after-swap and\n * the buffer's working copy is private. If it differs, the only thing that can\n * have changed it is the stage itself, in place.\n *\n * Dev-mode only (`enableDevMode()`), so the default run pays nothing and its\n * bytes are unchanged.\n */\n\nimport { deepEqual } from './utils.js';\n\n/** Render one path segment for a human: `lines[0].qty`, not `lines.0.qty`. */\nfunction joinSegment(prefix: string, segment: string, intoArray: boolean): string {\n  if (intoArray) return `${prefix}[${segment}]`;\n  return prefix === '' ? segment : `${prefix}.${segment}`;\n}\n\n/**\n * The first path at which `after` stops agreeing with `before`, or `undefined`\n * when they are structurally equal. Depth-first, own keys only — the same\n * shapes `deepEqual` handles, since committed state is JSON-shaped.\n *\n * Cycle-safe by construction: it only recurses into pairs that are not already\n * `deepEqual`, and stops at the first disagreement.\n */\nexport function firstDifferingPath(before: unknown, after: unknown, prefix = '', depth = 0): string | undefined {\n  if (deepEqual(before, after, 'copies')) return undefined;\n  if (depth >= 24) return prefix; // pathological nesting — name what we have\n  if (before === null || after === null || typeof before !== 'object' || typeof after !== 'object') return prefix;\n\n  const beforeIsArray = Array.isArray(before);\n  if (beforeIsArray !== Array.isArray(after)) return prefix;\n\n  if (beforeIsArray) {\n    const a = before as unknown[];\n    const b = after as unknown[];\n    if (a.length !== b.length) return prefix;\n    for (let i = 0; i < a.length; i++) {\n      const deeper = firstDifferingPath(a[i], b[i], joinSegment(prefix, String(i), true), depth + 1);\n      if (deeper !== undefined) return deeper;\n    }\n    return prefix;\n  }\n\n  const a = before as Record<string, unknown>;\n  const b = after as Record<string, unknown>;\n  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);\n  for (const key of keys) {\n    const deeper = firstDifferingPath(a[key], b[key], joinSegment(prefix, key, false), depth + 1);\n    if (deeper !== undefined) return deeper;\n  }\n  return prefix;\n}\n\n/**\n * The refusal text for a write that reached a frame AFTER its stage committed.\n * A scope, and every proxy read out of it, is bound to the stage it was handed\n * to; kept past that stage's commit it has no frame to land in, so the write\n * would sit in a buffer nothing ever commits — no trace row, state unchanged.\n * The throw surfaces in the stage that made the write (the engine's error\n * path names it); this text names the stage the handle came from.\n */\nexport function deadFrameMessage(stageName: string, runtimeStageId: string | undefined, key: string): string {\n  const from = runtimeStageId ? `\"${stageName}\" (${runtimeStageId})` : `\"${stageName}\"`;\n  return (\n    `[footprint] Stage ${from} has already committed — its scope is dead, and a write to \\`${key}\\` ` +\n    'just reached it from a later stage (this error is raised in that stage). A scope, and anything read ' +\n    'out of it (`scope.k`, `scope.k.arr[0]`), belongs to the stage it was handed to; held past that ' +\n    \"stage's commit it has no frame to land in, so the write would vanish with no trace row. \" +\n    \"Read the key again through the CURRENT stage's scope and write there.\"\n  );\n}\n\n/**\n * The warning text for a key the stage WROTE after changing, in place, the\n * committed value it had read before its first write (copy-on-write, 9.29.0).\n * The commit compares what the stage wrote against committed state — the\n * object the in-place change also moved — so it records no change: live state\n * keeps the edit, the log and every fold do not. (9.28.0 recorded it when the\n * edit came after the first write, by accident of a whole-state clone.)\n */\nexport function committedMutationMessage(stageName: string, key: string, path: string): string {\n  const where = path === '' ? key : `${key}.${path}`.replace(/\\.\\[/g, '[');\n  return (\n    `[footprint] Stage \"${stageName}\" changed \\`${where}\\` IN PLACE on the committed value it read before ` +\n    'its first write, then wrote the key. The commit compares the written value with committed state — ' +\n    'which the in-place change also moved — so it records NO change: live state keeps the edit, the commit ' +\n    'log and every reader that folds it do not. Reads are BORROWED. Build the next value instead ' +\n    `(\\`scope.$setValue('${key}', { ...value, … })\\`), or read the key again after the stage's first ` +\n    \"write — that read is the stage's own copy.\"\n  );\n}\n\n/**\n * The warning text. Names the stage, the exact path that moved, and the two\n * ways to write it back — because \"you mutated something\" is not actionable\n * and this is the one failure mode the whole design exists to prevent.\n */\nexport function borrowedMutationMessage(stageName: string, key: string, path: string): string {\n  const where = path === '' ? key : `${key}.${path}`.replace(/\\.\\[/g, '[');\n  return (\n    `[footprint] Stage \"${stageName}\" changed \\`${where}\\` IN PLACE, on a value it only read. ` +\n    'footprint never saw that write: there is no trace row for it, so the commit log, the causal chain ' +\n    'and every reader that folds the log will disagree with final state — and under a different write ' +\n    'order the change is dropped entirely. Reads are BORROWED. ' +\n    'Write through the scope instead (`scope.' +\n    where +\n    ' = …` — property and indexed access are both tracked), ' +\n    `or hand back the whole value with \\`scope.$setValue('${key}', next)\\`. ` +\n    'This usually comes from mutating an element reached by `find`/`filter`/`for…of`/`forEach`, ' +\n    'which the scope proxy cannot intercept.'\n  );\n}\n"]}