footprintjs 9.44.1 → 9.44.2

package/dist/lib/time-travel/chain.js

@@ -44,6 +44,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refuseChain = exports.spanOf = void 0;
+const valueKinds_js_1 = require("../capture/valueKinds.js");
 const runtimeStageId_js_1 = require("../ids/runtimeStageId.js");
 const utils_js_1 = require("../memory/utils.js");
 const stateAt_js_1 = require("./stateAt.js");
@@ -74,44 +75,45 @@ exports.spanOf = spanOf;
  *
  * The fold reproduces `'REDACTED'` wherever the engine scrubbed a write, while
  * the checkpoint that seeded the resumed leg holds the real value — so those
- * paths CANNOT agree, and are not asked to. Everything else must: same keys
- * (a key holding `undefined` counts as absent, as it does through JSON), same
- * array lengths, same leaves by `Object.is`, Dates by their instant. Values
- * are whatever survived `structuredClone`, which is the library's own law on
- * state values.
+ * paths CANNOT agree, and are not asked to. Everything else is decided by the
+ * ONE equality law (`memory/equality.ts · deepEqual`, every value kind compared
+ * as the record holds it; 9.44.2 — this walk had a law of its own, which held
+ * any two RegExps, Errors or buffers equal). Both sides are copies of one
+ * record, so an opaque value compares as `'copies'`. Only the containers above
+ * a redacted path are walked here.
  */
 function sameState(a, b, redacted, path) {
-    if (Object.is(a, b))
-        return true;
-    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
-        return false;
-    if (a instanceof Date || b instanceof Date) {
-        return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
-    }
-    if (a instanceof Map || b instanceof Map || a instanceof Set || b instanceof Set) {
-        if (!(a instanceof Map && b instanceof Map) && !(a instanceof Set && b instanceof Set))
-            return false;
-        return sameState([...a.entries()], [...b.entries()], redacted, path);
-    }
-    if (Array.isArray(a) !== Array.isArray(b))
-        return false;
+    if (!redactedBelow(path, redacted))
+        return (0, utils_js_1.deepEqual)(a, b, 'copies');
     if (Array.isArray(a) && Array.isArray(b)) {
         if (a.length !== b.length)
             return false;
         return a.every((item, i) => sameState(item, b[i], redacted, path === '' ? String(i) : `${path}${utils_js_1.DELIM}${i}`));
     }
-    const left = a;
-    const right = b;
+    const plain = (v) => v !== null && typeof v === 'object' && !Array.isArray(v) && (0, valueKinds_js_1.kindOf)(v) === 'plain';
+    if (!plain(a) || !plain(b))
+        return (0, utils_js_1.deepEqual)(a, b, 'copies');
     const present = (o) => Object.keys(o).filter((k) => o[k] !== undefined);
-    const leftKeys = present(left);
-    const rightKeys = new Set(present(right));
+    const leftKeys = present(a);
+    const rightKeys = new Set(present(b));
     if (leftKeys.length !== rightKeys.size || !leftKeys.every((k) => rightKeys.has(k)))
         return false;
     return leftKeys.every((k) => {
         const childPath = path === '' ? k : `${path}${utils_js_1.DELIM}${k}`;
-        return redacted.has(childPath) || sameState(left[k], right[k], redacted, childPath);
+        return redacted.has(childPath) || sameState(a[k], b[k], redacted, childPath);
     });
 }
+/** Is `path`, or a path below it, one the log was redacted at? */
+function redactedBelow(path, redacted) {
+    if (redacted.size === 0)
+        return false;
+    if (path === '')
+        return true;
+    for (const r of redacted)
+        if (r === path || r.startsWith(`${path}${utils_js_1.DELIM}`))
+            return true;
+    return false;
+}
 /**
  * Check that `legs` really are one run read in order, and say why not.
  *
@@ -188,4 +190,4 @@ function refuseChain(legs) {
     return undefined;
 }
 exports.refuseChain = refuseChain;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../../src/lib/time-travel/chain.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * chain.ts — reading a pause/resume as ONE axis.\n *\n * WHY THIS FILE EXISTS. A pause and its resume produce TWO snapshots. On a\n * cross-executor resume (the checkpoint was persisted and a fresh executor\n * picked it up) the second run gets a fresh runtime: its `commitLog` starts at\n * index 0 and holds only the post-resume commits, and its `initialState` is\n * the state at the pause. Two logs, two disjoint axes — so a reader scrubbing\n * a resumed run saw only the second half unless the application had kept the\n * paused snapshot and stitched the halves itself. Every application that\n * pauses would write that stitching, and none of them own the arithmetic.\n *\n * THE HONEST BIT, up front: COMMIT INDICES ARE RUN-LOCAL. There is no global\n * index across a chain and this file does not invent one — `commitIdx` and\n * `lastCommitIdx` keep indexing their own source, and every stop carries the\n * {@link Stop.sourceIdx} they belong to. The cursor's STEPS are what run\n * across the whole chain.\n *\n * AND THE REFUSAL: a chain that is not ordered, or whose legs are not from one\n * lineage, is REFUSED rather than guessed at. The record carries TWO signals\n * and this file reads both:\n *\n * - The execution index the engine stamps into every `runtimeStageId` —\n *   globally monotonic per run and, deliberately, NOT reset on resume. So a\n *   later leg's first execution index must be past the earlier leg's last, and\n *   no stage may appear in two legs. This catches a backwards chain, a fresh\n *   run (which restarts at 0) and a same-executor resume (whose one snapshot\n *   already holds both halves).\n * - The later leg's `initialState`. On a resume the fresh runtime is seeded\n *   from the checkpoint, so that base IS the state at the pause — and the\n *   state the earlier legs FOLD TO must deep-equal it. This is what catches a\n *   leg from some OTHER lineage whose indices merely happen to be higher: the\n *   counters line up by accident, the state never does.\n *\n * A chart identity or a lineage id is NOT on the record, so nothing here\n * pretends to check one. And where the state signal is not on the record\n * either — a leg recorded before 9.17 carries no `initialState`; an earlier\n * leg with no base folds `'log-only'`; a leg with unreadable rows folds an\n * incomplete state — that check is SKIPPED, not faked: the chain then rests on\n * the index checks alone, and every fold's `basis` still says what it stood\n * on. That degradation is documented on `refuseChain`, on `timeTravel`'s\n * `@throws`, and in the README.\n */\n\nimport { parseRuntimeStageId } from '../ids/runtimeStageId.js';\nimport type { CommitBundle } from '../memory/types.js';\nimport { DELIM } from '../memory/utils.js';\nimport { type ReadSource, foldLegs } from './stateAt.js';\nimport type { TimeTravelSource } from './types.js';\n\n/** One leg of a chain: a source, its read log, and where it sits in the run. */\nexport interface ChainLeg {\n  readonly source: TimeTravelSource;\n  readonly log: readonly CommitBundle[];\n  /** Lowest execution index stamped in this leg; `undefined` for an id-less log. */\n  readonly firstExecutionIndex: number | undefined;\n  /** Highest execution index stamped in this leg. */\n  readonly lastExecutionIndex: number | undefined;\n}\n\n/** The execution-index span of one leg, read off its `runtimeStageId`s. */\nexport function spanOf(log: readonly CommitBundle[]): {\n  first: number | undefined;\n  last: number | undefined;\n  ids: Set<string>;\n} {\n  let first: number | undefined;\n  let last: number | undefined;\n  const ids = new Set<string>();\n  for (const bundle of log) {\n    const id = bundle.runtimeStageId;\n    if (!id) continue;\n    ids.add(id);\n    const { executionIndex } = parseRuntimeStageId(id);\n    if (Number.isNaN(executionIndex)) continue;\n    if (first === undefined || executionIndex < first) first = executionIndex;\n    if (last === undefined || executionIndex > last) last = executionIndex;\n  }\n  return { first, last, ids };\n}\n\n/**\n * Structural equality of two folded states, ignoring the paths the log was\n * redacted at.\n *\n * The fold reproduces `'REDACTED'` wherever the engine scrubbed a write, while\n * the checkpoint that seeded the resumed leg holds the real value — so those\n * paths CANNOT agree, and are not asked to. Everything else must: same keys\n * (a key holding `undefined` counts as absent, as it does through JSON), same\n * array lengths, same leaves by `Object.is`, Dates by their instant. Values\n * are whatever survived `structuredClone`, which is the library's own law on\n * state values.\n */\nfunction sameState(a: unknown, b: unknown, redacted: ReadonlySet<string>, path: string): boolean {\n  if (Object.is(a, b)) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  if (a instanceof Date || b instanceof Date) {\n    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();\n  }\n  if (a instanceof Map || b instanceof Map || a instanceof Set || b instanceof Set) {\n    if (!(a instanceof Map && b instanceof Map) && !(a instanceof Set && b instanceof Set)) return false;\n    return sameState([...a.entries()], [...b.entries()], redacted, path);\n  }\n  if (Array.isArray(a) !== Array.isArray(b)) return false;\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    return a.every((item, i) => sameState(item, b[i], redacted, path === '' ? String(i) : `${path}${DELIM}${i}`));\n  }\n  const left = a as Record<string, unknown>;\n  const right = b as Record<string, unknown>;\n  const present = (o: Record<string, unknown>) => Object.keys(o).filter((k) => o[k] !== undefined);\n  const leftKeys = present(left);\n  const rightKeys = new Set(present(right));\n  if (leftKeys.length !== rightKeys.size || !leftKeys.every((k) => rightKeys.has(k))) return false;\n  return leftKeys.every((k) => {\n    const childPath = path === '' ? k : `${path}${DELIM}${k}`;\n    return redacted.has(childPath) || sameState(left[k], right[k], redacted, childPath);\n  });\n}\n\n/**\n * Check that `legs` really are one run read in order, and say why not.\n *\n * Returns the refusal message, or `undefined` when the chain is sound. Three\n * distinct failures, because they are three different mistakes, checked in\n * this order:\n *\n * - REPEATED STAGE — one `runtimeStageId` appears in two legs. Ids are unique\n *   within a run, so a repeat means the same execution was recorded twice: a\n *   same-executor resume, whose snapshot ALREADY holds the whole log and needs\n *   no chaining, is the usual cause.\n * - OUT OF ORDER — a later leg's first execution index is not past the earlier\n *   leg's last. Either the sources were handed over backwards, or the second\n *   is not a continuation at all (a fresh run restarts the counter at 0, so an\n *   unrelated snapshot fails here rather than silently interleaving).\n * - WRONG LINEAGE — leg k's `initialState` is not the state legs 0..k-1 fold\n *   to. On a resume the later leg is seeded from the checkpoint, so its base\n *   IS the state at the pause; a leg that begins anywhere else is from some\n *   other run, however its indices happen to line up.\n *\n * THE LINEAGE CHECK RUNS ONLY WHERE THE RECORD ALLOWS IT, and is skipped —\n * never faked — otherwise: leg k must carry an `initialState` (a recording\n * made before 9.17 has none), and the fold of the legs before it must stand on\n * a real base (`basis: 'initial+log'`) with no unreadable rows (`skipped`\n * absent) — a log-only or gapped fold is not a state a real base may be held\n * against. On such a chain the two index checks are the whole defence, and\n * `foldLegs`' leg rule then CONTINUES the fold across the seam, which is the\n * right state for a real resume and is what `basis` reports. Paths the log\n * was redacted at are excluded from the comparison: the fold holds\n * `'REDACTED'` there and the checkpoint holds the value.\n */\nexport function refuseChain(legs: readonly ReadSource[]): string | undefined {\n  if (legs.length === 0) return 'timeTravel: a chain needs at least one source, got an empty array.';\n\n  const spans = legs.map((leg) => spanOf(leg.log));\n  const seen = new Map<string, number>();\n  for (const [i, span] of spans.entries()) {\n    for (const id of span.ids) {\n      const earlier = seen.get(id);\n      if (earlier !== undefined) {\n        return (\n          `timeTravel: sources ${earlier} and ${i} both record '${id}'. A runtimeStageId is unique ` +\n          'within a run, so these are not two legs of one run — a same-executor resume already ' +\n          'carries the whole log in ONE snapshot and must not be chained with the paused one.'\n        );\n      }\n      seen.set(id, i);\n    }\n  }\n\n  let previous: { idx: number; last: number } | undefined;\n  for (const [i, span] of spans.entries()) {\n    if (span.first === undefined || span.last === undefined) continue;\n    if (previous && span.first <= previous.last) {\n      return (\n        `timeTravel: source ${i} starts at execution index ${span.first}, which is not past ` +\n        `source ${previous.idx}'s last (${previous.last}). Chain the sources in run order, and ` +\n        'only sources from ONE lineage — the engine never resets the execution counter across a ' +\n        'resume, so a fresh run restarting at 0 is a different run, not a continuation.'\n      );\n    }\n    previous = { idx: i, last: span.last };\n  }\n\n  for (let k = 1; k < legs.length; k++) {\n    const base = legs[k].base;\n    if (!base || typeof base !== 'object') continue; // no signal on the record — documented degradation\n    const before = foldLegs(legs, k - 1, Number.POSITIVE_INFINITY);\n    if (before.basis !== 'initial+log' || before.skipped) continue; // not a state a real base can be held to\n    if (!sameState(before.state, base, new Set(before.redactedPaths), '')) {\n      return (\n        `timeTravel: source ${k}'s initialState is not the state source ${k - 1} folds to. On a resume ` +\n        \"the later leg's initialState IS the state at the pause, so a leg that begins anywhere else is \" +\n        'not from one lineage — a different chart, or another run of this one — even when its execution ' +\n        'indices happen to be higher.'\n      );\n    }\n  }\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../../src/lib/time-travel/chain.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;;;AAEH,4DAAkD;AAClD,gEAA+D;AAE/D,iDAAsD;AACtD,6CAAyD;AAazD,2EAA2E;AAC3E,SAAgB,MAAM,CAAC,GAA4B;IAKjD,IAAI,KAAyB,CAAC;IAC9B,IAAI,IAAwB,CAAC;IAC7B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,MAAM,IAAI,GAAG,EAAE,CAAC;QACzB,MAAM,EAAE,GAAG,MAAM,CAAC,cAAc,CAAC;QACjC,IAAI,CAAC,EAAE;YAAE,SAAS;QAClB,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACZ,MAAM,EAAE,cAAc,EAAE,GAAG,IAAA,uCAAmB,EAAC,EAAE,CAAC,CAAC;QACnD,IAAI,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC;YAAE,SAAS;QAC3C,IAAI,KAAK,KAAK,SAAS,IAAI,cAAc,GAAG,KAAK;YAAE,KAAK,GAAG,cAAc,CAAC;QAC1E,IAAI,IAAI,KAAK,SAAS,IAAI,cAAc,GAAG,IAAI;YAAE,IAAI,GAAG,cAAc,CAAC;IACzE,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC9B,CAAC;AAlBD,wBAkBC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,SAAS,CAAC,CAAU,EAAE,CAAU,EAAE,QAA6B,EAAE,IAAY;IACpF,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC;QAAE,OAAO,IAAA,oBAAS,EAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IACrE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QACxC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,gBAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAChH,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,CAAU,EAAgC,EAAE,CACzD,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAA,sBAAM,EAAC,CAAC,CAAC,KAAK,OAAO,CAAC;IACpF,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAAE,OAAO,IAAA,oBAAS,EAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC7D,MAAM,OAAO,GAAG,CAAC,CAA0B,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;IACjG,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACjG,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;QAC1B,MAAM,SAAS,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,gBAAK,GAAG,CAAC,EAAE,CAAC;QAC1D,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;AACL,CAAC;AAED,kEAAkE;AAClE,SAAS,aAAa,CAAC,IAAY,EAAE,QAA6B;IAChE,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtC,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAC7B,KAAK,MAAM,CAAC,IAAI,QAAQ;QAAE,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,gBAAK,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IACzF,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,WAAW,CAAC,IAA2B;IACrD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,oEAAoE,CAAC;IAEnG,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QACxC,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC7B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,CACL,uBAAuB,OAAO,QAAQ,CAAC,iBAAiB,EAAE,gCAAgC;oBAC1F,sFAAsF;oBACtF,oFAAoF,CACrF,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED,IAAI,QAAmD,CAAC;IACxD,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QACxC,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;YAAE,SAAS;QAClE,IAAI,QAAQ,IAAI,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC5C,OAAO,CACL,sBAAsB,CAAC,8BAA8B,IAAI,CAAC,KAAK,sBAAsB;gBACrF,UAAU,QAAQ,CAAC,GAAG,YAAY,QAAQ,CAAC,IAAI,yCAAyC;gBACxF,yFAAyF;gBACzF,gFAAgF,CACjF,CAAC;QACJ,CAAC;QACD,QAAQ,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;IACzC,CAAC;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC1B,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,SAAS,CAAC,mDAAmD;QACpG,MAAM,MAAM,GAAG,IAAA,qBAAQ,EAAC,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAC/D,IAAI,MAAM,CAAC,KAAK,KAAK,aAAa,IAAI,MAAM,CAAC,OAAO;YAAE,SAAS,CAAC,yCAAyC;QACzG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;YACtE,OAAO,CACL,sBAAsB,CAAC,2CAA2C,CAAC,GAAG,CAAC,yBAAyB;gBAChG,gGAAgG;gBAChG,iGAAiG;gBACjG,8BAA8B,CAC/B,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAhDD,kCAgDC","sourcesContent":["/**\n * chain.ts — reading a pause/resume as ONE axis.\n *\n * WHY THIS FILE EXISTS. A pause and its resume produce TWO snapshots. On a\n * cross-executor resume (the checkpoint was persisted and a fresh executor\n * picked it up) the second run gets a fresh runtime: its `commitLog` starts at\n * index 0 and holds only the post-resume commits, and its `initialState` is\n * the state at the pause. Two logs, two disjoint axes — so a reader scrubbing\n * a resumed run saw only the second half unless the application had kept the\n * paused snapshot and stitched the halves itself. Every application that\n * pauses would write that stitching, and none of them own the arithmetic.\n *\n * THE HONEST BIT, up front: COMMIT INDICES ARE RUN-LOCAL. There is no global\n * index across a chain and this file does not invent one — `commitIdx` and\n * `lastCommitIdx` keep indexing their own source, and every stop carries the\n * {@link Stop.sourceIdx} they belong to. The cursor's STEPS are what run\n * across the whole chain.\n *\n * AND THE REFUSAL: a chain that is not ordered, or whose legs are not from one\n * lineage, is REFUSED rather than guessed at. The record carries TWO signals\n * and this file reads both:\n *\n * - The execution index the engine stamps into every `runtimeStageId` —\n *   globally monotonic per run and, deliberately, NOT reset on resume. So a\n *   later leg's first execution index must be past the earlier leg's last, and\n *   no stage may appear in two legs. This catches a backwards chain, a fresh\n *   run (which restarts at 0) and a same-executor resume (whose one snapshot\n *   already holds both halves).\n * - The later leg's `initialState`. On a resume the fresh runtime is seeded\n *   from the checkpoint, so that base IS the state at the pause — and the\n *   state the earlier legs FOLD TO must deep-equal it. This is what catches a\n *   leg from some OTHER lineage whose indices merely happen to be higher: the\n *   counters line up by accident, the state never does.\n *\n * A chart identity or a lineage id is NOT on the record, so nothing here\n * pretends to check one. And where the state signal is not on the record\n * either — a leg recorded before 9.17 carries no `initialState`; an earlier\n * leg with no base folds `'log-only'`; a leg with unreadable rows folds an\n * incomplete state — that check is SKIPPED, not faked: the chain then rests on\n * the index checks alone, and every fold's `basis` still says what it stood\n * on. That degradation is documented on `refuseChain`, on `timeTravel`'s\n * `@throws`, and in the README.\n */\n\nimport { kindOf } from '../capture/valueKinds.js';\nimport { parseRuntimeStageId } from '../ids/runtimeStageId.js';\nimport type { CommitBundle } from '../memory/types.js';\nimport { deepEqual, DELIM } from '../memory/utils.js';\nimport { type ReadSource, foldLegs } from './stateAt.js';\nimport type { TimeTravelSource } from './types.js';\n\n/** One leg of a chain: a source, its read log, and where it sits in the run. */\nexport interface ChainLeg {\n  readonly source: TimeTravelSource;\n  readonly log: readonly CommitBundle[];\n  /** Lowest execution index stamped in this leg; `undefined` for an id-less log. */\n  readonly firstExecutionIndex: number | undefined;\n  /** Highest execution index stamped in this leg. */\n  readonly lastExecutionIndex: number | undefined;\n}\n\n/** The execution-index span of one leg, read off its `runtimeStageId`s. */\nexport function spanOf(log: readonly CommitBundle[]): {\n  first: number | undefined;\n  last: number | undefined;\n  ids: Set<string>;\n} {\n  let first: number | undefined;\n  let last: number | undefined;\n  const ids = new Set<string>();\n  for (const bundle of log) {\n    const id = bundle.runtimeStageId;\n    if (!id) continue;\n    ids.add(id);\n    const { executionIndex } = parseRuntimeStageId(id);\n    if (Number.isNaN(executionIndex)) continue;\n    if (first === undefined || executionIndex < first) first = executionIndex;\n    if (last === undefined || executionIndex > last) last = executionIndex;\n  }\n  return { first, last, ids };\n}\n\n/**\n * Structural equality of two folded states, ignoring the paths the log was\n * redacted at.\n *\n * The fold reproduces `'REDACTED'` wherever the engine scrubbed a write, while\n * the checkpoint that seeded the resumed leg holds the real value — so those\n * paths CANNOT agree, and are not asked to. Everything else is decided by the\n * ONE equality law (`memory/equality.ts · deepEqual`, every value kind compared\n * as the record holds it; 9.44.2 — this walk had a law of its own, which held\n * any two RegExps, Errors or buffers equal). Both sides are copies of one\n * record, so an opaque value compares as `'copies'`. Only the containers above\n * a redacted path are walked here.\n */\nfunction sameState(a: unknown, b: unknown, redacted: ReadonlySet<string>, path: string): boolean {\n  if (!redactedBelow(path, redacted)) return deepEqual(a, b, 'copies');\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    return a.every((item, i) => sameState(item, b[i], redacted, path === '' ? String(i) : `${path}${DELIM}${i}`));\n  }\n  const plain = (v: unknown): v is Record<string, unknown> =>\n    v !== null && typeof v === 'object' && !Array.isArray(v) && kindOf(v) === 'plain';\n  if (!plain(a) || !plain(b)) return deepEqual(a, b, 'copies');\n  const present = (o: Record<string, unknown>) => Object.keys(o).filter((k) => o[k] !== undefined);\n  const leftKeys = present(a);\n  const rightKeys = new Set(present(b));\n  if (leftKeys.length !== rightKeys.size || !leftKeys.every((k) => rightKeys.has(k))) return false;\n  return leftKeys.every((k) => {\n    const childPath = path === '' ? k : `${path}${DELIM}${k}`;\n    return redacted.has(childPath) || sameState(a[k], b[k], redacted, childPath);\n  });\n}\n\n/** Is `path`, or a path below it, one the log was redacted at? */\nfunction redactedBelow(path: string, redacted: ReadonlySet<string>): boolean {\n  if (redacted.size === 0) return false;\n  if (path === '') return true;\n  for (const r of redacted) if (r === path || r.startsWith(`${path}${DELIM}`)) return true;\n  return false;\n}\n\n/**\n * Check that `legs` really are one run read in order, and say why not.\n *\n * Returns the refusal message, or `undefined` when the chain is sound. Three\n * distinct failures, because they are three different mistakes, checked in\n * this order:\n *\n * - REPEATED STAGE — one `runtimeStageId` appears in two legs. Ids are unique\n *   within a run, so a repeat means the same execution was recorded twice: a\n *   same-executor resume, whose snapshot ALREADY holds the whole log and needs\n *   no chaining, is the usual cause.\n * - OUT OF ORDER — a later leg's first execution index is not past the earlier\n *   leg's last. Either the sources were handed over backwards, or the second\n *   is not a continuation at all (a fresh run restarts the counter at 0, so an\n *   unrelated snapshot fails here rather than silently interleaving).\n * - WRONG LINEAGE — leg k's `initialState` is not the state legs 0..k-1 fold\n *   to. On a resume the later leg is seeded from the checkpoint, so its base\n *   IS the state at the pause; a leg that begins anywhere else is from some\n *   other run, however its indices happen to line up.\n *\n * THE LINEAGE CHECK RUNS ONLY WHERE THE RECORD ALLOWS IT, and is skipped —\n * never faked — otherwise: leg k must carry an `initialState` (a recording\n * made before 9.17 has none), and the fold of the legs before it must stand on\n * a real base (`basis: 'initial+log'`) with no unreadable rows (`skipped`\n * absent) — a log-only or gapped fold is not a state a real base may be held\n * against. On such a chain the two index checks are the whole defence, and\n * `foldLegs`' leg rule then CONTINUES the fold across the seam, which is the\n * right state for a real resume and is what `basis` reports. Paths the log\n * was redacted at are excluded from the comparison: the fold holds\n * `'REDACTED'` there and the checkpoint holds the value.\n */\nexport function refuseChain(legs: readonly ReadSource[]): string | undefined {\n  if (legs.length === 0) return 'timeTravel: a chain needs at least one source, got an empty array.';\n\n  const spans = legs.map((leg) => spanOf(leg.log));\n  const seen = new Map<string, number>();\n  for (const [i, span] of spans.entries()) {\n    for (const id of span.ids) {\n      const earlier = seen.get(id);\n      if (earlier !== undefined) {\n        return (\n          `timeTravel: sources ${earlier} and ${i} both record '${id}'. A runtimeStageId is unique ` +\n          'within a run, so these are not two legs of one run — a same-executor resume already ' +\n          'carries the whole log in ONE snapshot and must not be chained with the paused one.'\n        );\n      }\n      seen.set(id, i);\n    }\n  }\n\n  let previous: { idx: number; last: number } | undefined;\n  for (const [i, span] of spans.entries()) {\n    if (span.first === undefined || span.last === undefined) continue;\n    if (previous && span.first <= previous.last) {\n      return (\n        `timeTravel: source ${i} starts at execution index ${span.first}, which is not past ` +\n        `source ${previous.idx}'s last (${previous.last}). Chain the sources in run order, and ` +\n        'only sources from ONE lineage — the engine never resets the execution counter across a ' +\n        'resume, so a fresh run restarting at 0 is a different run, not a continuation.'\n      );\n    }\n    previous = { idx: i, last: span.last };\n  }\n\n  for (let k = 1; k < legs.length; k++) {\n    const base = legs[k].base;\n    if (!base || typeof base !== 'object') continue; // no signal on the record — documented degradation\n    const before = foldLegs(legs, k - 1, Number.POSITIVE_INFINITY);\n    if (before.basis !== 'initial+log' || before.skipped) continue; // not a state a real base can be held to\n    if (!sameState(before.state, base, new Set(before.redactedPaths), '')) {\n      return (\n        `timeTravel: source ${k}'s initialState is not the state source ${k - 1} folds to. On a resume ` +\n        \"the later leg's initialState IS the state at the pause, so a leg that begins anywhere else is \" +\n        'not from one lineage — a different chart, or another run of this one — even when its execution ' +\n        'indices happen to be higher.'\n      );\n    }\n  }\n  return undefined;\n}\n"]}

package/dist/types/lib/capture/freeze.d.ts

@@ -1,21 +1,42 @@
 /**
- * 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
  * ```
  */
 /**
@@ -25,8 +46,8 @@
  *   AND any expando (`arr.note = { … }`). The dev-mode snapshot relies on this contract.
  * - `'indices'` — the index elements only, so no key string is allocated per element; this is what
  *   keeps freezing a 10,000-element commit inside its budget (`bench/element-writes.ts`). An object
- *   hung on an array EXPANDO is then left unfrozen — the commit log's named hole
- *   (`EventLog · record`).
+ *   hung on an array EXPANDO is then left unfrozen, and unseen by {@link serveRecord} — the commit
+ *   log's named hole (`EventLog · record`; an array expando is out of contract for state).
  */
 export type ArrayWalk = 'every-key' | 'indices';
 /**
@@ -41,7 +62,30 @@ export type ArrayWalk = 'every-key' | 'indices';
  *   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).
  */
 export declare function deepFreeze<T>(obj: T, arrays?: ArrayWalk): T;
+/**
+ * {@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`.
+ */
+export declare function freezeRecord<T extends object>(record: T, arrays?: ArrayWalk): T;
+/**
+ * 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.
+ */
+export declare function serveRecord<T>(record: T): T;

package/dist/types/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/types/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/types/lib/memory/equality.d.ts

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

package/dist/types/lib/runner/ExecutionRuntime.d.ts

@@ -187,7 +187,10 @@ export declare class ExecutionRuntime {
      * The frozen, detached fold base served as {@link RuntimeSnapshot.initialState}.
      * Computed once (the base never changes after construction) and shared —
      * safe because it is deeply frozen, so no holder can mutate it or reach the
-     * engine through it.
+     * engine through it; a base holding a Date, Map, buffer … (what freezing
+     * cannot seal) is served by the public snapshot as a copy of its open paths
+     * (`runner/snapshot.ts · servedSnapshot`, `capture/freeze.ts · serveRecord`,
+     * 9.44.2).
      */
     private getFoldBase;
     getPipelines(): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "9.44.1",
+  "version": "9.44.2",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -53,6 +53,7 @@
     "check:layering": "node scripts/check-layering.mjs",
     "check:doc-snippets": "node scripts/check-doc-snippets.mjs",
     "audit:family": "node scripts/audit-family-versions.mjs",
+    "audit:consumers": "node scripts/audit-consumers.mjs",
     "lint": "eslint '{src,test}/**/*.ts' --ext .ts",
     "lint:fix": "eslint '{src,test}/**/*.ts' --ext .ts --fix",
     "format:fix": "prettier --config .prettierrc.js --write '{src,test}/**/*.ts'",