footprintjs 9.44.3 → 9.45.0

package/dist/lib/memory/utils.js

@@ -11,6 +11,8 @@
  * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,
  * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.
  * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.
+ * The writers take an ADDRESS, a path prefix their caller computed, and never
+ * name one (C2: the engine decides where a stage writes, `StageContext · address`).
  * Zero external dependencies.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -31,54 +33,70 @@ Object.defineProperty(exports, "dryFold", { enumerable: true, get: function () {
 Object.defineProperty(exports, "nextGeneration", { enumerable: true, get: function () { return verbs_js_1.nextGeneration; } });
 Object.defineProperty(exports, "supersededByNextSet", { enumerable: true, get: function () { return verbs_js_1.supersededByNextSet; } });
 /**
- * Resolves run-namespaced and global paths.
- * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.
+ * The two places a value at `path` can sit: under `address` (`runPath`, absent
+ * for the root address `[]`) and at the root (`globalPath`). `address` is a
+ * path prefix the caller computed — for the engine, a frame's run namespace
+ * (`StageContext · address`, C2).
  */
-function getRunAndGlobalPaths(runId, path = []) {
+function getRunAndGlobalPaths(address = [], path = []) {
     return {
-        runPath: runId ? ['runs', runId, ...path] : undefined,
+        runPath: addressOf(address).length > 0 ? pathUnder(address, path) : undefined,
         globalPath: [...path],
     };
 }
 exports.getRunAndGlobalPaths = getRunAndGlobalPaths;
+/** An address is an array. A run id still passed in its place (C2) is refused, never spread into its characters. */
+function addressOf(address) {
+    if (Array.isArray(address))
+        return address;
+    throw new TypeError(`footprintjs: an address is an array path prefix, got ${address === null ? 'null' : typeof address}`);
+}
+/**
+ * `address` then `path`, as one new array. An index loop, because the double
+ * spread `[...address, ...path]` costs twice as much and a frame builds one on
+ * every read it serves from live state (a fork child reading a root key).
+ */
+function pathUnder(address, path) {
+    const out = new Array(address.length + path.length);
+    for (let i = 0; i < address.length; i++)
+        out[i] = address[i];
+    for (let i = 0; i < path.length; i++)
+        out[address.length + i] = path[i];
+    return out;
+}
 /**
- * Sets a value at a nested path, creating intermediate objects as needed.
+ * The container at `address` + `path` inside `obj`, each missing one created
+ * on the way: the one AT the address from `defaultValues` when given, every
+ * other one empty. The one walk both nested writers share.
  */
-function setNestedValue(obj, runId, _path, field, value, defaultValues) {
-    const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);
-    const path = runPath || globalPath;
-    const pathCopy = [...path];
+function containerAt(obj, address = [], path = [], defaultValues) {
+    const segments = pathUnder(addressOf(address), path);
     let current = obj;
-    while (pathCopy.length > 0) {
-        const key = pathCopy.shift();
+    for (let i = 0; i < segments.length; i++) {
+        const key = segments[i];
         if (!Object.prototype.hasOwnProperty.call(current, key)) {
-            current[key] = key === runId && defaultValues ? defaultValues : {};
+            current[key] = i === address.length - 1 && defaultValues ? defaultValues : {};
         }
         current = current[key];
     }
-    current[field] = value;
+    return current;
+}
+/**
+ * Sets a value at a nested path under `address`, creating intermediate objects as needed.
+ */
+function setNestedValue(obj, address, path, field, value, defaultValues) {
+    containerAt(obj, address, path, defaultValues)[field] = value;
     return obj;
 }
 exports.setNestedValue = setNestedValue;
 /**
- * Deep-merges a value into the object at the specified path.
+ * Deep-merges a value into the object at a nested path under `address`.
  * - Arrays: concatenate
  * - Objects: shallow merge at each level
  * - Primitives: replace
  */
-function updateNestedValue(obj, runId, _path, field, value, defaultValues) {
-    const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);
-    const path = runPath || globalPath;
-    const pathCopy = [...path];
-    let current = obj;
-    while (pathCopy.length > 0) {
-        const key = pathCopy.shift();
-        if (!Object.prototype.hasOwnProperty.call(current, key)) {
-            current[key] = key === runId && defaultValues ? defaultValues : {};
-        }
-        current = current[key];
-    }
-    updateValue(current, field, value);
+function updateNestedValue(obj, address, path, field, value, defaultValues) {
+    updateValue(containerAt(obj, address, path, defaultValues), field, value);
     return obj;
 }
 exports.updateNestedValue = updateNestedValue;
@@ -129,4 +147,4 @@ function getNestedValue(root, path, field) {
     return undefined;
 }
 exports.getNestedValue = getNestedValue;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — nested-object helpers for the heap, and the memory leaves' one\n * re-export surface.\n *\n * The helpers here (`setNestedValue`, `updateNestedValue`, `updateValue`,\n * `getNestedValue`) walk a nested object by path with\n * prototype-pollution protection. Everything else this file used to hold has an\n * owner of its own and is re-exported, so no importer moved: the path codec\n * (`paths.ts`), structural equality (`equality.ts`) and the union merge\n * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,\n * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.\n * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.\n * Zero external dependencies.\n */\n\nimport { nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport { DELIM } from './paths.js';\nimport type { MemoryPatch } from './types.js';\n\nexport { deepEqual } from './equality.js';\nexport { deepSmartMerge } from './merge.js';\nexport { DELIM, normalisePath, pathSegments } from './paths.js';\nexport { applySmartMerge, applySmartMergeInto, dryFold, nextGeneration, supersededByNextSet } from './verbs.js';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — nested-object helpers for the heap, and the memory leaves' one\n * re-export surface.\n *\n * The helpers here (`setNestedValue`, `updateNestedValue`, `updateValue`,\n * `getNestedValue`) walk a nested object by path with\n * prototype-pollution protection. Everything else this file used to hold has an\n * owner of its own and is re-exported, so no importer moved: the path codec\n * (`paths.ts`), structural equality (`equality.ts`) and the union merge\n * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,\n * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.\n * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.\n * The writers take an ADDRESS, a path prefix their caller computed, and never\n * name one (C2: the engine decides where a stage writes, `StageContext · address`).\n * Zero external dependencies.\n */\n\nimport { nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport { DELIM } from './paths.js';\nimport type { MemoryPatch } from './types.js';\n\nexport { deepEqual } from './equality.js';\nexport { deepSmartMerge } from './merge.js';\nexport { DELIM, normalisePath, pathSegments } from './paths.js';\nexport { applySmartMerge, applySmartMergeInto, dryFold, nextGeneration, supersededByNextSet } from './verbs.js';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * The two places a value at `path` can sit: under `address` (`runPath`, absent\n * for the root address `[]`) and at the root (`globalPath`). `address` is a\n * path prefix the caller computed — for the engine, a frame's run namespace\n * (`StageContext · address`, C2).\n */\nexport function getRunAndGlobalPaths(address: readonly string[] = [], path: (string | number)[] = []) {\n  return {\n    runPath: addressOf(address).length > 0 ? pathUnder(address, path) : undefined,\n    globalPath: [...path],\n  };\n}\n\n/** An address is an array. A run id still passed in its place (C2) is refused, never spread into its characters. */\nfunction addressOf(address: readonly string[]): readonly string[] {\n  if (Array.isArray(address)) return address;\n  throw new TypeError(\n    `footprintjs: an address is an array path prefix, got ${address === null ? 'null' : typeof address}`,\n  );\n}\n\n/**\n * `address` then `path`, as one new array. An index loop, because the double\n * spread `[...address, ...path]` costs twice as much and a frame builds one on\n * every read it serves from live state (a fork child reading a root key).\n */\nfunction pathUnder(address: readonly string[], path: readonly (string | number)[]): (string | number)[] {\n  const out = new Array<string | number>(address.length + path.length);\n  for (let i = 0; i < address.length; i++) out[i] = address[i];\n  for (let i = 0; i < path.length; i++) out[address.length + i] = path[i];\n  return out;\n}\n\n/**\n * The container at `address` + `path` inside `obj`, each missing one created\n * on the way: the one AT the address from `defaultValues` when given, every\n * other one empty. The one walk both nested writers share.\n */\nfunction containerAt(\n  obj: NestedObject,\n  address: readonly string[] = [],\n  path: readonly (string | number)[] = [],\n  defaultValues?: unknown,\n): NestedObject {\n  const segments = pathUnder(addressOf(address), path);\n  let current = obj;\n  for (let i = 0; i < segments.length; i++) {\n    const key = segments[i];\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = i === address.length - 1 && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  return current;\n}\n\n/**\n * Sets a value at a nested path under `address`, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  address: readonly string[],\n  path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  containerAt(obj, address, path, defaultValues)[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at a nested path under `address`.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  address: readonly string[],\n  path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  updateValue(containerAt(obj, address, path, defaultValues), field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n"]}

package/dist/types/lib/memory/SharedMemory.d.ts

@@ -2,8 +2,11 @@
  * SharedMemory — The shared state container for all flowchart execution
  *
  * Like a runtime heap with namespace isolation:
- * - Each run gets its own namespace (runs/{id}/)
- * - Default values can be initialised and preserved
+ * - A value is written at an ADDRESS — a path prefix the caller computed
+ *   (C2: the engine's frame decides it, `StageContext · address`) — and read
+ *   there first, then at the root
+ * - Default values seed the root, and the container at an address when a
+ *   write creates it
  * - Accepts commit bundles from TransactionBuffer
  *
  * COPY-ON-WRITE (9.29.0 — docs/design/2026-10-copy-on-write-commit.md):
@@ -22,12 +25,10 @@ export declare class SharedMemory {
     constructor(defaultValues?: unknown, initialContext?: unknown);
     /** Gets a clone of the default values. */
     getDefaultValues(): {} | undefined;
-    /** Gets all run namespaces. */
-    getRuns(): any;
-    /** Updates a value using merge semantics, as a new generation (path copy + swap). */
-    updateValue(runId: string, path: string[], key: string, value: unknown): void;
-    /** Sets a value using overwrite semantics, as a new generation (path copy + swap). */
-    setValue(runId: string, path: string[], key: string, value: unknown): void;
+    /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */
+    updateValue(address: readonly string[], path: string[], key: string, value: unknown): void;
+    /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */
+    setValue(address: readonly string[], path: string[], key: string, value: unknown): void;
     /**
      * 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.
@@ -35,9 +36,9 @@ export declare class SharedMemory {
     private ownedPathTo;
     /**
      * Reads a value from the store.
-     * Looks up in run namespace first, falls back to global.
+     * Looks up at `address` first, falls back to the root.
      */
-    getValue(runId?: string, path?: string[], key?: string): any;
+    getValue(address?: readonly string[], path?: string[], key?: string): any;
     /** Gets the entire state as a JSON object — the current generation, by reference. Never mutate it. */
     getState(): Record<string, unknown>;
     /** Applies a commit bundle from TransactionBuffer: builds the next generation and swaps it in. */

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

@@ -311,7 +311,13 @@ export declare class StageContext {
      *  stay anchored at first touch to match the eager engine — see
      *  {@link firstTouchState}. */
     getTransactionBuffer(): TransactionBuffer;
-    /** Builds an absolute path inside the shared memory (run namespace). */
+    /**
+     * Where this frame writes and reads: `['runs', <id>]`, or `[]` (the root) with
+     * no run id. Handed to the record layer as data (C2): the buffer's address,
+     * and where `SharedMemory · getValue` looks before the root.
+     */
+    private get address();
+    /** Builds an absolute path inside the shared memory: this frame's {@link address}, then the path. */
     private withNamespace;
     /** The run namespace writes and reads go to: {@link addressRunId}, else `runId`. */
     private get namespaceId();

package/dist/types/lib/memory/TransactionBuffer.d.ts

@@ -128,8 +128,9 @@ export declare class TransactionBuffer {
      */
     private detachedBase?;
     /**
-     * Where the stage writes (9.30.0): `['runs', runId]` for a run-namespaced
-     * stage, `[]` otherwise. Its containers are the stage's ADDRESS, not a value
+     * Where the stage writes (9.30.0): a path prefix its frame computed and
+     * hands over as data (C2 — for the engine, the frame's run namespace, or
+     * `[]` for the root). Its containers are the stage's ADDRESS, not a value
      * the stage reads (every read it makes is a key below it), so a shell a
      * write leaves there is no part of the read-back the record must hold.
      */
@@ -275,7 +276,7 @@ export declare class TransactionBuffer {
      *  - a container still SHARED with committed state at the same position is
      *    replaced by a private deep copy when it is the value read, or by a
      *    shallow copy when it is a container on the way to it (so a read of
-     *    `runs/<id>/k` copies `k`, not every run's namespace);
+     *    `k` under a fork child's address copies `k`, not every child's namespace);
      *  - a container the stage STAGED (or anything else the buffer did not
      *    take from committed state) is handed back by reference, as before;
      *  - a container the buffer owns is walked on — and when it is the value

package/dist/types/lib/memory/utils.d.ts

@@ -10,6 +10,8 @@
  * (`merge.ts`) at L0, and the verb law (`verbs.ts`) at L1 — `applySmartMerge`,
  * `nextGeneration`, `applySmartMergeInto`, `dryFold`, `supersededByNextSet`.
  * The log's scrub, `redactPatch`, moved to its owner `redaction.ts` in 9.33.0.
+ * The writers take an ADDRESS, a path prefix their caller computed, and never
+ * name one (C2: the engine decides where a stage writes, `StageContext · address`).
  * Zero external dependencies.
  */
 export { deepEqual } from './equality.js';
@@ -20,24 +22,26 @@ type NestedObject = {
     [key: string]: any;
 };
 /**
- * Resolves run-namespaced and global paths.
- * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.
+ * The two places a value at `path` can sit: under `address` (`runPath`, absent
+ * for the root address `[]`) and at the root (`globalPath`). `address` is a
+ * path prefix the caller computed — for the engine, a frame's run namespace
+ * (`StageContext · address`, C2).
  */
-export declare function getRunAndGlobalPaths(runId?: string, path?: (string | number)[]): {
+export declare function getRunAndGlobalPaths(address?: readonly string[], path?: (string | number)[]): {
     runPath: (string | number)[] | undefined;
     globalPath: (string | number)[];
 };
 /**
- * Sets a value at a nested path, creating intermediate objects as needed.
+ * Sets a value at a nested path under `address`, creating intermediate objects as needed.
  */
-export declare function setNestedValue<T>(obj: NestedObject, runId: string, _path: string[], field: string, value: T, defaultValues?: unknown): NestedObject;
+export declare function setNestedValue<T>(obj: NestedObject, address: readonly string[], path: string[], field: string, value: T, defaultValues?: unknown): NestedObject;
 /**
- * Deep-merges a value into the object at the specified path.
+ * Deep-merges a value into the object at a nested path under `address`.
  * - Arrays: concatenate
  * - Objects: shallow merge at each level
  * - Primitives: replace
  */
-export declare function updateNestedValue<T>(obj: any, runId: string | undefined, _path: (string | number)[], field: string | number, value: T, defaultValues?: unknown): any;
+export declare function updateNestedValue<T>(obj: any, address: readonly string[], path: (string | number)[], field: string | number, value: T, defaultValues?: unknown): any;
 /**
  * In-place value update with merge semantics.
  * - Arrays (non-empty): concatenate onto existing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "9.44.3",
+  "version": "9.45.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",