footprintjs 9.44.3 → 9.46.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.ts · runAddress`).
  * 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.ts · runAddress`, C2), held by its record frame (`RecordFrame · address`, C3).
  */
-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.ts · runAddress`).\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.ts · runAddress`, C2), held by its record frame (`RecordFrame · address`, C3).\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/lib/reactive/structuralWrite.js

@@ -6,7 +6,7 @@
  * path inside the value I read, put this". The value it read is BORROWED —
  * before a stage's first staged write it is a bare reference into committed
  * shared memory, and committed state is immutable-after-swap (see
- * `StageContext.firstTouchState`). Editing it in place would corrupt every
+ * `RecordFrame · firstTouch`). Editing it in place would corrupt every
  * in-flight stage AND leave the commit log with nothing to record.
  *
  * So the write path never mutates. It COPIES the containers along the path
@@ -106,4 +106,4 @@ function deleteInPath(root, segments) {
     return copy;
 }
 exports.deleteInPath = deleteInPath;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structuralWrite.js","sourceRoot":"","sources":["../../../src/lib/reactive/structuralWrite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/structuralWrite -- Build the NEXT value without touching the last one.\n *\n * Every deep write the typed scope intercepts has the same shape: \"at this\n * path inside the value I read, put this\". The value it read is BORROWED —\n * before a stage's first staged write it is a bare reference into committed\n * shared memory, and committed state is immutable-after-swap (see\n * `StageContext.firstTouchState`). Editing it in place would corrupt every\n * in-flight stage AND leave the commit log with nothing to record.\n *\n * So the write path never mutates. It COPIES the containers along the path\n * (and only those) and returns a new root, leaving every untouched sibling\n * shared by reference — the same zero-clone bargain the first-touch view\n * already makes. The buffer `structuredClone`s what it stages, so the\n * detaching happens once, at the boundary that needs it.\n */\n\n/*\n * Until 9.24.0 this module also owned `unwrapProxy`, a JSON round-trip of\n * every ASSIGNED value — the only way then to keep the scope's own Proxies\n * out of the buffer. It cost a `Date` its type and a `Map` its members, and\n * it made the trap and `$setValue` store different bytes for the same value\n * (the old landmine 1). The scope's handles are recognised now\n * (`handles.ts · unwrapHandles`, O(1) each), so the assigned value goes to\n * the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the\n * one detaching step — the same law `$setValue` has always had.\n */\n\n/** Shallow copy that preserves array-ness — the one container copy this module makes. */\nfunction copyContainer(node: unknown): any {\n  if (Array.isArray(node)) return [...node];\n  if (node !== null && typeof node === 'object') return { ...(node as Record<string, unknown>) };\n  // Not a container (primitive, null, undefined): the path continues INTO it,\n  // so it becomes a fresh object — the same coercion `nativeSet` performs.\n  return {};\n}\n\n/** An array index segment, or `undefined` when the segment names a property. */\nfunction indexOf(node: unknown, segment: string): number | undefined {\n  if (!Array.isArray(node)) return undefined;\n  const i = Number(segment);\n  return Number.isInteger(i) && i >= 0 ? i : undefined;\n}\n\n/**\n * Return a copy of `root` with `value` at `segments`, mutating nothing.\n *\n * Containers on the path are shallow-copied (arrays stay arrays); everything\n * off the path is shared by reference. An empty path returns `value` itself.\n */\nexport function setInPath(root: unknown, segments: readonly string[], value: unknown): unknown {\n  if (segments.length === 0) return value;\n  const next = copyContainer(root);\n  const segment = segments[0];\n  const index = indexOf(next, segment);\n  const child = index !== undefined ? next[index] : (next as Record<string, unknown>)[segment];\n  const replaced = setInPath(child, segments.slice(1), value);\n  if (index !== undefined) next[index] = replaced;\n  else (next as Record<string, unknown>)[segment] = replaced;\n  return next;\n}\n\n/**\n * Return a copy of `root` with the key at `segments` REMOVED, mutating nothing.\n *\n * On an array the slot is removed with `splice` (the array shrinks — `delete`\n * on an array index would leave a hole, which cannot survive\n * `structuredClone` round-trips as the same value). A path that does not\n * exist returns the root unchanged, by reference.\n */\nexport function deleteInPath(root: unknown, segments: readonly string[]): unknown {\n  if (segments.length === 0) return undefined;\n  if (root === null || typeof root !== 'object') return root;\n  const segment = segments[0];\n  const index = indexOf(root, segment);\n  if (segments.length === 1) {\n    if (index !== undefined) {\n      if (index >= (root as unknown[]).length) return root;\n      const copy = [...(root as unknown[])];\n      copy.splice(index, 1);\n      return copy;\n    }\n    if (!Object.prototype.hasOwnProperty.call(root, segment)) return root;\n    const copy = { ...(root as Record<string, unknown>) };\n    delete copy[segment];\n    return copy;\n  }\n  const child = index !== undefined ? (root as unknown[])[index] : (root as Record<string, unknown>)[segment];\n  const replaced = deleteInPath(child, segments.slice(1));\n  if (replaced === child) return root;\n  const copy = copyContainer(root);\n  if (index !== undefined) copy[index] = replaced;\n  else copy[segment] = replaced;\n  return copy;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"structuralWrite.js","sourceRoot":"","sources":["../../../src/lib/reactive/structuralWrite.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/structuralWrite -- Build the NEXT value without touching the last one.\n *\n * Every deep write the typed scope intercepts has the same shape: \"at this\n * path inside the value I read, put this\". The value it read is BORROWED —\n * before a stage's first staged write it is a bare reference into committed\n * shared memory, and committed state is immutable-after-swap (see\n * `RecordFrame · firstTouch`). Editing it in place would corrupt every\n * in-flight stage AND leave the commit log with nothing to record.\n *\n * So the write path never mutates. It COPIES the containers along the path\n * (and only those) and returns a new root, leaving every untouched sibling\n * shared by reference — the same zero-clone bargain the first-touch view\n * already makes. The buffer `structuredClone`s what it stages, so the\n * detaching happens once, at the boundary that needs it.\n */\n\n/*\n * Until 9.24.0 this module also owned `unwrapProxy`, a JSON round-trip of\n * every ASSIGNED value — the only way then to keep the scope's own Proxies\n * out of the buffer. It cost a `Date` its type and a `Map` its members, and\n * it made the trap and `$setValue` store different bytes for the same value\n * (the old landmine 1). The scope's handles are recognised now\n * (`handles.ts · unwrapHandles`, O(1) each), so the assigned value goes to\n * the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the\n * one detaching step — the same law `$setValue` has always had.\n */\n\n/** Shallow copy that preserves array-ness — the one container copy this module makes. */\nfunction copyContainer(node: unknown): any {\n  if (Array.isArray(node)) return [...node];\n  if (node !== null && typeof node === 'object') return { ...(node as Record<string, unknown>) };\n  // Not a container (primitive, null, undefined): the path continues INTO it,\n  // so it becomes a fresh object — the same coercion `nativeSet` performs.\n  return {};\n}\n\n/** An array index segment, or `undefined` when the segment names a property. */\nfunction indexOf(node: unknown, segment: string): number | undefined {\n  if (!Array.isArray(node)) return undefined;\n  const i = Number(segment);\n  return Number.isInteger(i) && i >= 0 ? i : undefined;\n}\n\n/**\n * Return a copy of `root` with `value` at `segments`, mutating nothing.\n *\n * Containers on the path are shallow-copied (arrays stay arrays); everything\n * off the path is shared by reference. An empty path returns `value` itself.\n */\nexport function setInPath(root: unknown, segments: readonly string[], value: unknown): unknown {\n  if (segments.length === 0) return value;\n  const next = copyContainer(root);\n  const segment = segments[0];\n  const index = indexOf(next, segment);\n  const child = index !== undefined ? next[index] : (next as Record<string, unknown>)[segment];\n  const replaced = setInPath(child, segments.slice(1), value);\n  if (index !== undefined) next[index] = replaced;\n  else (next as Record<string, unknown>)[segment] = replaced;\n  return next;\n}\n\n/**\n * Return a copy of `root` with the key at `segments` REMOVED, mutating nothing.\n *\n * On an array the slot is removed with `splice` (the array shrinks — `delete`\n * on an array index would leave a hole, which cannot survive\n * `structuredClone` round-trips as the same value). A path that does not\n * exist returns the root unchanged, by reference.\n */\nexport function deleteInPath(root: unknown, segments: readonly string[]): unknown {\n  if (segments.length === 0) return undefined;\n  if (root === null || typeof root !== 'object') return root;\n  const segment = segments[0];\n  const index = indexOf(root, segment);\n  if (segments.length === 1) {\n    if (index !== undefined) {\n      if (index >= (root as unknown[]).length) return root;\n      const copy = [...(root as unknown[])];\n      copy.splice(index, 1);\n      return copy;\n    }\n    if (!Object.prototype.hasOwnProperty.call(root, segment)) return root;\n    const copy = { ...(root as Record<string, unknown>) };\n    delete copy[segment];\n    return copy;\n  }\n  const child = index !== undefined ? (root as unknown[])[index] : (root as Record<string, unknown>)[segment];\n  const replaced = deleteInPath(child, segments.slice(1));\n  if (replaced === child) return root;\n  const copy = copyContainer(root);\n  if (index !== undefined) copy[index] = replaced;\n  else copy[segment] = replaced;\n  return copy;\n}\n"]}

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

@@ -0,0 +1,197 @@
+/**
+ * RecordFrame — the record half of one stage's frame (C3, L3).
+ *
+ * What a stage's frame needs to READ and WRITE the record, and nothing about the stage inside a run:
+ * where it writes (its address), what it read first (the first-touch base), what it staged (the lazy
+ * transaction buffer), which keys it read (the readKeys list), and where a commit lands (live state,
+ * the redacted mirror, the log — through `recordCommit`). The engine's frame (`StageContext`, L4)
+ * composes one and keeps the rest: retention, diagnostics, the dev-mode warnings, the commit observer
+ * and the redaction verdict.
+ *
+ * THE LAW:
+ *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands
+ *      over as data (C2: `['runs', <id>]` or `[]`, the root). It moves only before the first write:
+ *      the buffer keeps the address it was built at (the engine refuses a later move).
+ *   2. FIRST TOUCH. The committed generation the frame first touched — its first read OR first write —
+ *      is held by reference, never cloned: the read view before the first write and the buffer's
+ *      net-change diff base after it.
+ *   3. TWO TIERS. A read is served from the stage's own view (the buffer's working copy once the stage
+ *      wrote, else the first-touch base); a key absent there is served from LIVE state (at the
+ *      address, then the root). After the first write the buffer's diff base is first given a private
+ *      copy at that path (`TransactionBuffer · detachBase`).
+ *   4. LAZY BUFFER. The buffer is built at the first write — on the first-touch base, at the address,
+ *      under the encoding. A frame that never writes builds none, and its commit is the empty bundle.
+ *   5. READ KEYS. Under `writeProvenance: 'reads-prefix'` every noted read puts its user-level key
+ *      (dotted for a nested path) on the frame's list, once, in order; each staged row carries a copy
+ *      of the list as it stands when the row is staged.
+ *   6. COMMIT, RELEASE, DISCARD. `commit` takes the buffer's payload (none = the empty commit), then
+ *      the names, and hands both to `recordCommit`. `release` drops the buffer and the base; a frame
+ *      touched again re-anchors on the state as it stands then. The readKeys list survives a release,
+ *      and goes with `discard` (a failed attempt never happened).
+ */
+import type { EventLog } from './EventLog.js';
+import { type CommitStamp } from './recordCommit.js';
+import type { SharedMemory } from './SharedMemory.js';
+import { TransactionBuffer } from './TransactionBuffer.js';
+import type { CommitValuesMode, WriteProvenanceMode } from './types.js';
+/**
+ * The two dials that shape a frame's bytes: the log's value encoding and the per-row read prefix.
+ * Held by reference and swapped whole (`useEncoding`), never edited — the engine hands the run's
+ * frozen policy itself. Absent: `'full'` values and no read prefix.
+ */
+export interface RecordEncoding {
+    readonly commitValues: CommitValuesMode;
+    readonly writeProvenance: WriteProvenanceMode;
+}
+export declare class RecordFrame {
+    /** Live committed state — the heap every frame of the run shares. */
+    readonly state: SharedMemory;
+    /** The log the frame's commits land on, when the run keeps one. */
+    readonly log?: EventLog;
+    /** The redacted mirror the frame's commits land on, when the run keeps one ({@link useMirror}). */
+    private _mirror?;
+    /** Where the frame reads and writes (law 1). */
+    private _address;
+    /** The two dials (law 4, 5); absent → the record's defaults. */
+    private encoding?;
+    /**
+     * The committed generation at the frame's FIRST touch (law 2) — held by REFERENCE, never cloned.
+     * See {@link firstTouch} for the algorithm and the immutability invariant that makes a bare
+     * reference safe.
+     */
+    private base?;
+    /** The stage's staged writes — built at its first write (law 4), released at commit. */
+    private buffer?;
+    /**
+     * Keys tracked-read so far, in order (law 5) — the source of each staged row's `readKeys`. Only
+     * allocated under `'reads-prefix'`; insertion-ordered (a Set) and monotonic, which is what makes
+     * "last write's prefix == union" hold in delta mode.
+     */
+    private readKeys?;
+    constructor(state: SharedMemory, log?: EventLog, address?: readonly string[]);
+    /** Where the frame reads and writes (law 1). */
+    get address(): readonly string[];
+    /**
+     * Read and write at `address` from now on — before the frame's first write (law 1): the buffer keeps
+     * the address it was built at. The engine's one caller, `StageContext · useAddressOf`, refuses a move
+     * once the frame has staged.
+     */
+    useAddress(address: readonly string[]): void;
+    /** The two dials the frame encodes under from its next buffer and its next read on (law 4, 5). */
+    useEncoding(encoding: RecordEncoding): void;
+    /** The redacted mirror, if the run keeps one. */
+    get mirror(): SharedMemory | undefined;
+    /** Land every commit from now on on `mirror` too, with the scrubbed rows the log takes (`recordCommit`). */
+    useMirror(mirror: SharedMemory | undefined): void;
+    /** The absolute path of `key` under `path`: the frame's address, then the path, then the key. */
+    at(path: readonly string[], key: string): string[];
+    /**
+     * ── The first-touch base (#13) ───────────────────────────────────────────
+     *
+     * WHAT: returns the committed shared state as it was at this frame's FIRST touch (first read or
+     * first write), capturing the reference on first call. Serves two consumers: reads before the first
+     * write ({@link read}) 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. 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 snapshot reads and its commit baseline (the
+     * net-change diff base) there. #13's first cut anchored the lazy buffer at first WRITE — observably
+     * different when something else commits in the gap between this stage's first read and its first
+     * write. That gap is REACHABLE: fork siblings are namespace-isolated for run-scoped keys (each child
+     * writes under `runs/<childId>/`), but ROOT-level keys are shared — written via `setGlobal` from
+     * consumer scope code and, critically, by `SubflowInputMapper`'s output mapping
+     * (`parentContext.setGlobal`), which is exactly what runs when a subflow is a fork branch. A
+     * sibling's root-key commit landing in the gap would shift this stage's diff base, making its
+     * CommitBundle record a phantom change (or swallow a real one) relative to the eager engine.
+     * Anchoring the view at first touch restores the EXACT eager semantics — sequential AND parallel —
+     * at zero clone cost.
+     *
+     * Read visibility is two-tier, matching eager byte-for-byte: keys present in the view at first
+     * touch read repeatably from it; keys ABSENT from it fall back to LIVE state (the eager engine's
+     * exact fallback — a mid-flight sibling root-key write was always visible to reads, and stays
+     * visible; only the DIFF BASE is pinned).
+     */
+    private firstTouch;
+    /**
+     * The transaction buffer, created lazily on the frame's FIRST WRITE (#13).
+     *
+     * Reads NEVER construct it: read-your-writes only matters once a staged write exists, so before that
+     * {@link read} serves from the first-touch base and {@link commit} records an empty bundle — all with
+     * ZERO `structuredClone`s of the shared state.
+     *
+     * The buffer's base is the FIRST-TOUCH view, NOT the live state at write time: under parallel forks
+     * a sibling may have committed between this frame's first read and this write, and the net-change
+     * diff base must stay anchored at first touch to match the eager engine — see {@link firstTouch}.
+     */
+    getTransactionBuffer(): TransactionBuffer;
+    /** Has the frame staged a write since its last release — does its buffer exist? */
+    get hasStaged(): boolean;
+    /**
+     * The frame's read, mirroring the eager engine's read order byte-for-byte (law 3):
+     *
+     *    1. staged writes + first-touch snapshot — `buffer.get` over its workingCopy when the buffer
+     *       exists, else `nativeGet` over the zero-clone first-touch base (the buffer's base IS that
+     *       view, so the two tiers agree on content);
+     *    2. LIVE state via `SharedMemory · getValue` for keys absent from the snapshot — including its
+     *       address→root fallback. The eager engine had this exact live fallback for snapshot-missing
+     *       keys; byte-identity over purity. After the frame'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 frame that never writes performs zero clones of the
+     * shared state.
+     */
+    read(path: string[], key?: string): unknown;
+    /** Put a tracked read's user-level key on the readKeys list (law 5) — a no-op unless the frame keeps one. */
+    noteRead(path: readonly string[], key: string): void;
+    /**
+     * Live committed state at `key`: at the frame's address, else at the root — never the stage's own
+     * view. Typed as `SharedMemory · getValue` types it, which `StageContext · getRoot` hands on.
+     */
+    readLive(key: string): any;
+    /** Live committed state at `key` at the root — typed as `SharedMemory · getValue` (`StageContext · getGlobal`). */
+    readGlobal(key: string): any;
+    /** Did a staged op touch `path` — on it, above it or below it? (A report's question; never the hot path.) */
+    wasStaged(path: (string | number)[]): boolean;
+    /**
+     * The value at `path` in what the stage has seen — its working copy once it wrote, else its
+     * first-touch base — WITHOUT taking a private copy: for a report that only compares.
+     */
+    peek(path: (string | number)[]): unknown;
+    /** The value at `path` in the first-touch base — committed state as the frame first touched it. */
+    baseAt(path: (string | number)[]): unknown;
+    /**
+     * Record what the frame staged (law 6): the buffer's payload first — none, the empty commit, when
+     * it staged nothing (#13: zero clones) — then the names (`stampOf()`), read once the payload is
+     * built, and both to `recordCommit`. User code can run while the payload is built (a getter on a
+     * staged value, which the net-change compare and the clone invoke); what it adds to the names —
+     * an untracked read, say — is on the bundle.
+     */
+    commit(stampOf: () => CommitStamp): void;
+    /**
+     * End the frame's hold on state (#13b, law 6): drop the buffer (its working copy and whatever private
+     * copies its reads took) and the first-touch base (a reference that pins one committed-state
+     * GENERATION). Both re-create lazily: a later read re-anchors on the CURRENT committed state, and a
+     * later write builds a fresh buffer on it — so a second commit diffs against the state after the
+     * first. Without the release, the execution tree — which retains every frame for the lifetime of
+     * the run — retains one state generation per executed stage (measured O(N²) before copy-on-write;
+     * a 500-iteration agent OOMed a default Node heap, backlog #18).
+     */
+    release(): void;
+    /**
+     * Throw away everything the frame staged and read (law 6): the buffer, the first-touch base (the next
+     * attempt re-anchors on committed state as it stands NOW) and the readKeys list — a discarded
+     * attempt's reads must never reach the next attempt's `TraceEntry.readKeys`, or a backward slice
+     * would follow an edge that no committed write ever had. Nothing is recorded.
+     */
+    discard(): void;
+}

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.ts · runAddress`) — 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. */