footprintjs 9.28.0 → 9.30.0

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

@@ -5,15 +5,31 @@
  * - Each run gets its own namespace (runs/{id}/)
  * - Default values can be initialised and preserved
  * - Accepts commit bundles from TransactionBuffer
+ *
+ * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
+ * `context` is a GENERATION, and a generation is never edited. Every write —
+ * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next
+ * generation by copying the root and the containers on each written path,
+ * shares every other subtree with the generation before it, and swaps. So a
+ * generation a stage captured (its first-touch view, its transaction
+ * buffer's diff base) stays exactly what it was, and a write costs O(what it
+ * wrote), not O(state).
  */
-import { mergeContextWins } from './pathOps.js';
-import { applySmartMerge, getNestedValue, getRunAndGlobalPaths, setNestedValue, updateNestedValue } from './utils.js';
+import { mergeContextWins, ownedRootOf, ownSpine } from './pathOps.js';
+import { getNestedValue, getRunAndGlobalPaths, nextGeneration, setNestedValue, updateNestedValue } from './utils.js';
 export class SharedMemory {
     context = {};
     _defaultValues;
     constructor(defaultValues, initialContext) {
         this._defaultValues = defaultValues;
-        this.context = mergeContextWins(initialContext || {}, defaultValues || {});
+        const seed = mergeContextWins(initialContext || {}, defaultValues || {});
+        // Detached ONCE, here: `mergeContextWins` copies only the top level, so
+        // the seed's nested values are the caller's own objects. Before 9.29.0
+        // the first commit's whole-state clone detached them (and until then a
+        // caller mutating its `initialContext` changed live state with no row);
+        // nothing re-clones the state any more, so the seed is detached at
+        // construction — one clone per runtime, not one per commit.
+        this.context = Object.keys(seed).length > 0 ? structuredClone(seed) : seed;
     }
     /** Gets a clone of the default values. */
     getDefaultValues() {
@@ -23,13 +39,28 @@ export class SharedMemory {
     getRuns() {
         return this.context.runs;
     }
-    /** Updates a value using merge semantics. */
+    /** Updates a value using merge semantics, as a new generation (path copy + swap). */
     updateValue(runId, path, key, value) {
-        updateNestedValue(this.context, runId, path, key, value, this.getDefaultValues());
+        const next = this.ownedPathTo(runId, path, key);
+        updateNestedValue(next, runId, path, key, value, this.getDefaultValues());
+        this.context = next;
     }
-    /** Sets a value using overwrite semantics. */
+    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
     setValue(runId, path, key, value) {
-        setNestedValue(this.context, runId, path, key, value, this.getDefaultValues());
+        const next = this.ownedPathTo(runId, path, key);
+        setNestedValue(next, runId, path, key, value, this.getDefaultValues());
+        this.context = next;
+    }
+    /**
+     * A copy of the current generation's root whose containers on the way to
+     * `key` are owned — the in-place helpers above then edit only copies.
+     */
+    ownedPathTo(runId, path, key) {
+        const owned = new WeakSet();
+        const root = ownedRootOf(this.context, owned);
+        const { runPath, globalPath } = getRunAndGlobalPaths(runId, path);
+        ownSpine(root, [...(runPath || globalPath), key], owned);
+        return root;
     }
     /**
      * Reads a value from the store.
@@ -40,13 +71,13 @@ export class SharedMemory {
         const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;
         return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);
     }
-    /** Gets the entire state as a JSON object. */
+    /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */
     getState() {
         return this.context;
     }
-    /** Applies a commit bundle from TransactionBuffer. */
+    /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */
     applyPatch(overwrite, updates, trace) {
-        this.context = applySmartMerge(this.context, updates, overwrite, trace);
+        this.context = nextGeneration(this.context, updates, overwrite, trace);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SharedMemory.js","sourceRoot":"","sources":["../../../../src/lib/memory/SharedMemory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SharedMemory — The shared state container for all flowchart execution\n *\n * Like a runtime heap with namespace isolation:\n * - Each run gets its own namespace (runs/{id}/)\n * - Default values can be initialised and preserved\n * - Accepts commit bundles from TransactionBuffer\n *\n * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):\n * `context` is a GENERATION, and a generation is never edited. Every write —\n * `applyPatch` (a stage commit), `setValue`, `updateValue` — builds the next\n * generation by copying the root and the containers on each written path,\n * shares every other subtree with the generation before it, and swaps. So a\n * generation a stage captured (its first-touch view, its transaction\n * buffer's diff base) stays exactly what it was, and a write costs O(what it\n * wrote), not O(state).\n */\n\nimport { mergeContextWins, ownedRootOf, ownSpine } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\nimport { getNestedValue, getRunAndGlobalPaths, nextGeneration, setNestedValue, updateNestedValue } from './utils.js';\n\nexport class SharedMemory {\n  private context: { [key: string]: any } = {};\n  private _defaultValues?: unknown;\n\n  constructor(defaultValues?: unknown, initialContext?: unknown) {\n    this._defaultValues = defaultValues;\n    const seed = mergeContextWins(initialContext || {}, defaultValues || {});\n    // Detached ONCE, here: `mergeContextWins` copies only the top level, so\n    // the seed's nested values are the caller's own objects. Before 9.29.0\n    // the first commit's whole-state clone detached them (and until then a\n    // caller mutating its `initialContext` changed live state with no row);\n    // nothing re-clones the state any more, so the seed is detached at\n    // construction — one clone per runtime, not one per commit.\n    this.context = Object.keys(seed).length > 0 ? structuredClone(seed) : seed;\n  }\n\n  /** Gets a clone of the default values. */\n  getDefaultValues() {\n    return this._defaultValues ? structuredClone(this._defaultValues) : undefined;\n  }\n\n  /** Gets all run namespaces. */\n  getRuns() {\n    return this.context.runs;\n  }\n\n  /** Updates a value using merge semantics, as a new generation (path copy + swap). */\n  updateValue(runId: string, path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(runId, path, key);\n    updateNestedValue(next, runId, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */\n  setValue(runId: string, path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(runId, path, key);\n    setNestedValue(next, runId, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /**\n   * A copy of the current generation's root whose containers on the way to\n   * `key` are owned — the in-place helpers above then edit only copies.\n   */\n  private ownedPathTo(runId: string, path: string[], key: string): { [key: string]: any } {\n    const owned = new WeakSet<object>();\n    const root = ownedRootOf(this.context, owned);\n    const { runPath, globalPath } = getRunAndGlobalPaths(runId, path);\n    ownSpine(root, [...(runPath || globalPath), key], owned);\n    return root;\n  }\n\n  /**\n   * Reads a value from the store.\n   * Looks up in run namespace first, falls back to global.\n   */\n  getValue(runId?: string, path?: string[], key?: string): any {\n    const { globalPath, runPath } = getRunAndGlobalPaths(runId, path);\n    const value = runPath ? getNestedValue(this.context, runPath, key) : undefined;\n    return typeof value !== 'undefined' ? value : getNestedValue(this.context, globalPath, key);\n  }\n\n  /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */\n  getState(): Record<string, unknown> {\n    return this.context;\n  }\n\n  /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */\n  applyPatch(overwrite: MemoryPatch, updates: MemoryPatch, trace: TraceEntry[]): void {\n    this.context = nextGeneration(this.context, updates, overwrite, trace);\n  }\n}\n"]}

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

@@ -91,6 +91,15 @@ export declare class StageContext {
      * facade path never allocates it.
      */
     private _nestedReads?;
+    /**
+     * Dev mode only: the root keys whose LAST tracked read was served from
+     * committed state — before this stage's first write, when no transaction
+     * buffer exists yet. Such a read is the committed object itself, so an
+     * in-place edit of it moves the buffer's diff base too (copy-on-write,
+     * 9.29.0); {@link warnOnBorrowedMutation} checks these keys even when the
+     * stage wrote them. Never allocated outside `enableDevMode()`.
+     */
+    private _viewReads?;
     /**
      * Has this frame committed at least once? The borrowed-read guard runs on
      * the FIRST commit only — see {@link warnOnBorrowedMutation}. The frame
@@ -304,14 +313,14 @@ export declare class StageContext {
      * and the transaction buffer's diff base ({@link getTransactionBuffer}).
      *
      * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed
-     * state is immutable-after-swap. `SharedMemory.applyPatch` routes through
-     * `applySmartMerge`, which `structuredClone`s the current state, mutates
-     * only the clone, and swaps `SharedMemory.context` to it — the object a
-     * stage captured here is never edited afterwards. (`SharedMemory.setValue`/
-     * `updateValue` DO mutate in place, but have no callers during traversal;
-     * every runtime write reaches state through a stage commit's `applyPatch`.)
-     * Holding the reference therefore gives this stage a stable snapshot at
-     * zero cost — no clone, which is the entire point of #13.
+     * state is immutable-after-swap. Every write to `SharedMemory` builds the
+     * NEXT generation and swaps it in (copy-on-write, 9.29.0: `applyPatch` via
+     * `nextGeneration`, and `setValue`/`updateValue` too) — it copies the root
+     * and the containers on each written path, shares the rest, and never
+     * edits a container of the generation a stage captured here. Holding the
+     * reference therefore gives this stage a stable snapshot at zero cost — no
+     * clone, which is the entire point of #13. The transaction buffer's
+     * net-change diff base rests on the same guarantee: it IS this view.
      *
      * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the
      * state into the buffer at the stage's first ACCESS, anchoring both its
@@ -371,7 +380,13 @@ export declare class StageContext {
      *    2. LIVE state via `sharedMemory.getValue` for keys absent from the
      *       snapshot — including its run→global namespace fallback. The eager
      *       engine had this exact live fallback for snapshot-missing keys;
-     *       byte-identity over purity.
+     *       byte-identity over purity. After the stage's first write such a
+     *       value can be the very container the buffer's diff base holds at
+     *       the path (the stage deleted or unset it, or replaced a container
+     *       above it), so the base is detached there first
+     *       (`TransactionBuffer · detachBase`): an in-place edit of the value
+     *       (out of contract) written back is recorded, as on 9.28.0, whose
+     *       base was a clone taken at the first write.
      *
      *  Reads never construct the buffer (#13): a stage that never writes
      *  performs zero clones of the shared state. */
@@ -447,22 +462,34 @@ export declare class StageContext {
      * subflow merge-back into a committed branch parent) other stages have
      * legitimately moved the state they were compared against.
      *
+     * A key the stage DID stage is still checked when its last read came from
+     * committed state ({@link _viewReads} — read before the first write):
+     * that read was the committed object itself, and the buffer's diff base IS
+     * that object (copy-on-write, 9.29.0), so an in-place edit followed by a
+     * write of the key commits NO change — live state keeps the edit, the log
+     * does not. Compared against committed state, not the written value, so a
+     * legitimate write never trips it.
+     *
      * Costs nothing outside `enableDevMode()`.
      */
     private warnOnBorrowedMutation;
+    /** The staged-key half of {@link warnOnBorrowedMutation}: did committed state itself move under a read? */
+    private warnOnCommittedMutation;
     /**
      * Flush staged writes to shared memory and RELEASE the per-stage staging
      * state (#13b).
      *
-     * Commit is the stage's lifecycle end: `buffer` (2 full-state clones) and
-     * `stateView` (a reference that pins one full committed-state GENERATION —
-     * `applySmartMerge` clones + swaps the whole state per commit, so every
-     * stage's view is a distinct object) are only needed DURING execution, as
-     * the read snapshot + net-change diff base. The execution tree retains
-     * every StageContext for the lifetime of the run, so WITHOUT the release
-     * a long loop retains one state generation + two clones per executed
-     * stage — measured O(N²): 563.8MB at N=200 on an agent-style chart; a
-     * 500-iteration agent OOMed a default Node heap (backlog #18).
+     * Commit is the stage's lifecycle end: `buffer` (its working copy and
+     * whatever private copies its reads took) and `stateView` (a reference that
+     * pins one committed-state GENERATION) are only needed DURING execution,
+     * as the read snapshot + net-change diff base. The execution tree retains
+     * every StageContext for the lifetime of the run, so WITHOUT the release a
+     * long loop retains one state generation per executed stage — measured
+     * O(N²) before copy-on-write (9.29.0), when each generation and each
+     * buffer was a whole-state clone: 563.8MB at N=200 on an agent-style
+     * chart; a 500-iteration agent OOMed a default Node heap (backlog #18).
+     * Generations now share every unchanged subtree, but a pinned one still
+     * keeps the containers later commits replaced alive.
      *
      * RE-USE AFTER COMMIT stays correct because both fields re-create lazily:
      * - a later READ re-anchors via {@link firstTouchState} on the CURRENT