footprintjs 9.44.1 → 9.44.3

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

@@ -8,16 +8,22 @@
  * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no
  * longer rewrite the history every later answer is folded from: an assignment into a bundle throws
  * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:
- * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of
+ * the log's payload is the commit's own copy (`recordCommit` hands it the output of
  * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy
  * (`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

@@ -8,18 +8,24 @@
  * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no
  * longer rewrite the history every later answer is folded from: an assignment into a bundle throws
  * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:
- * the log's payload is the commit's own copy (`StageContext · commit` hands it the output of
+ * the log's payload is the commit's own copy (`recordCommit` hands it the output of
  * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy
  * (`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 (`recordCommit` 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/StageContext.d.ts

@@ -157,10 +157,10 @@ export declare class StageContext {
     /** Capture from this frame's OWN log. A manual/unaddressable frame stays unknown. */
     captureEmitPosition(): EmitSourcePosition | undefined;
     /**
-     * Install a parallel redacted mirror. Subsequent `commit()` calls will
-     * apply the already-computed redacted patches to this mirror in addition
-     * to the raw `sharedMemory` + `eventLog`. Child / next contexts inherit
-     * the mirror via `createNext` / `createChild`.
+     * Install a parallel redacted mirror. Subsequent `commit()` calls apply
+     * the already-computed redacted patches — the ones the log records — to
+     * this mirror, beside the raw patches on `sharedMemory` (`recordCommit`).
+     * Child / next contexts inherit the mirror via `createNext` / `createChild`.
      *
      * Called on a runtime's root frame by `ExecutionRuntime` when the run's policy keeps a mirror.
      */
@@ -384,19 +384,6 @@ export declare class StageContext {
      * surfaced as `CommitBundle.untrackedSources` on this stage's commit.
      */
     markUntrackedSource(source: UntrackedSource): void;
-    /**
-     * RFC-003 D2: the `untrackedSources` bundle fragment for commit() — `{}`
-     * when nothing was marked, so the spread keeps the field ABSENT (not
-     * empty-array-valued) and untouched charts stay byte-identical.
-     */
-    private untrackedSourcesFragment;
-    /**
-     * The `tags` bundle fragment for commit() — `{}` when the stage declares
-     * none, so an untagged chart's log is byte-identical to 9.20.0. Added after
-     * the payload encoding, so it is independent of `commitValues`; names, so
-     * redaction never sees it.
-     */
-    private tagsFragment;
     /** Register an observer that fires after commit() applies patches.
      *  Used by ScopeFacade to dispatch ScopeRecorder.onCommit events. */
     setCommitObserver(observer: (mutations: Record<string, {
@@ -494,22 +481,6 @@ export declare class StageContext {
      *   reads them post-run for the execution-tree snapshot.
      */
     commit(phase?: CommitPhase): void;
-    /**
-     * THE bundle of one commit (F10): the payload (an empty one on the lazy
-     * path, the buffer's on the other), then the stage's names, then the
-     * fragments — spread once, here, for both commit paths. Key order is the
-     * record's bytes: payload keys, `stage`, `stageId`, `runtimeStageId`,
-     * `untrackedSources?`, `tags?`, `phase?`.
-     */
-    private bundleFor;
-    /**
-     * The tail of both commit paths: notify the observer (ScopeFacade) with the
-     * tracked mutations, THEN release the staging state (#13b — see `commit`),
-     * so the observer sees the world as it was. D2's untracked-source markers
-     * and the declared tags release with it: one stamp per execution, so the
-     * engine's double-commit paths record them exactly once.
-     */
-    private finishCommit;
     /**
      * Throw away everything this stage has STAGED, without committing any of it.
      *