footprintjs 9.46.0 → 9.46.1

package/CLAUDE.md

@@ -9,7 +9,7 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | src/lib/ | one job |
 |---|---|
 | capture/ | retention policies + bounded payload summarization (leaf; shared by tracking dials AND deferred-observer capture) + `valueKinds` (the ONE classifier of value kinds: `deepEqual`'s arms and what freezing seals, 9.44.2) + the shared leaves `invokeHook` (the one recorder-hook invoker both delivery tiers use), `circular` (dev-mode cycle probe), `summarizeValue` (the narrative one-liner); `lib/devMode.ts` — the dev-mode flag — is its sibling leaf (all four moved out of scope/ and recorder/ in F0: they closed the one memory ⇄ scope ⇄ recorder module cycle) |
-| memory/ | transactional state: SharedMemory heap, StageContext frames, `RecordFrame` (the record half of a frame, L3, C3: the address, the first-touch base, the two-tier read, the lazy buffer, the readKeys list, and the commit through `recordCommit`; StageContext composes it), TransactionBuffer staging (+ admission.ts, the admitted record's check; deltaEncoding.ts, the delta encoder's helpers), EventLog commit log — PLUS the ONE verb law (`verbs.ts`, L1: `applyVerb`, `foldRows`, `foldKey`; leaves `paths.ts` / `equality.ts` / `merge.ts`; `utils.ts` re-exports them) and trace analysis (backtrack.ts causalChain, commitLogUtils.ts) |
+| memory/ | transactional state: SharedMemory heap, StageContext frames, `RecordFrame` (the record half of a frame, L3, C3: the address, the first-touch base, the two-tier read, the lazy buffer (private since C4: staged only through `write(path, value, verb, scrub?)`, which carries a redaction verdict's bytes), the readKeys list, and the commit through `recordCommit`; StageContext composes it), the log's scrub (`scrub.ts`, L2: `scrubPatch` / `redactPatch`, C4), TransactionBuffer staging (+ admission.ts, the admitted record's check; deltaEncoding.ts, the delta encoder's helpers), EventLog commit log — PLUS the ONE verb law (`verbs.ts`, L1: `applyVerb`, `foldRows`, `foldKey`; leaves `paths.ts` / `equality.ts` / `merge.ts`; `utils.ts` re-exports them) and trace analysis (backtrack.ts causalChain, commitLogUtils.ts) |
 | schema/ | duck-typed validation (`.safeParse/.parse` ⇒ 'parseable') |
 | builder/ | fluent DSL → FlowChartSpec → StageNode graph; build-time StructureRecorder channel. NOT standalone: imports runner's makeRunnable (FlowChartBuilder.ts:18) |
 | scope/ | ScopeFacade per stage (tracked get/set, $emit, frozen args/env); built-in ScopeRecorders in scope/recorders/ |
@@ -24,11 +24,11 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | observer-queue/ | pure deferred-delivery pipeline (engine imports IT, never reverse) |
 | contract/, detach/ | I/O schema normalization (OpenAPI generation belongs to runner/RunnableChart); fire-and-forget child charts (drivers passed explicitly) |
 
-**The fence (F0):** a file imports only its own layer or BELOW — L0 values/leaves · L1 verbs · L2 staging+commit · L3 the log as a read model + the record half of a frame (`RecordFrame`) · L4 frame+run policy · L5 scope/recorders/hooks · L6 engine · L7 builder+executor · L8 the `src/*.ts` entry barrels. The table is DATA in `scripts/layering.config.cjs` (most specific pattern wins; an unplaced file is an error, and `memory/` has no directory default because it spans L0–L4) and has three readers, none with a copy: `.eslintrc.js` (generated `import/no-restricted-paths` zones + `import/no-cycle`, src only), `npm run check:layering` (value-level cycles at module AND file level + upward RUNTIME edges; type-only imports excluded — the set equals the compiled CJS `require` graph), `test/architecture/layering.test.ts`. Three edges are named on purpose — builder → `runner/RunnableChart.ts` (`makeRunnable`), engine → `reactive/handles.ts`, scope → `detach/spawn.ts` — plus a short `TYPE_ONLY_ALLOWANCES` list (upward imports tsc erases, which the lint rule cannot tell apart); both lists are live-checked and only shrink. A new src file under an unsplit directory inherits its layer; one under `memory/` (or an exact-path entry) must be added to LAYERS — an unplaced file fails lint and the script. Public symbols have ONE canonical door each — `test/architecture/exports.test.ts` fails on any symbol two of the six `package.json` doors both hand out unless it is in `SECOND_DOORS` (28 today, in four reasoned groups; an alias counts as a door).
+**The fence (F0):** a file imports only its own layer or BELOW — L0 values/leaves · L1 verbs · L2 staging+commit · L3 the log as a read model + the record half of a frame (`RecordFrame`) · L4 frame+run policy+the redaction verdict (`redaction.ts`, C4) · L5 scope/recorders/hooks · L6 engine · L7 builder+executor · L8 the `src/*.ts` entry barrels. The table is DATA in `scripts/layering.config.cjs` (most specific pattern wins; an unplaced file is an error, and `memory/` has no directory default because it spans L0–L4) and has three readers, none with a copy: `.eslintrc.js` (generated `import/no-restricted-paths` zones + `import/no-cycle`, src only), `npm run check:layering` (value-level cycles at module AND file level + upward RUNTIME edges; type-only imports excluded — the set equals the compiled CJS `require` graph), `test/architecture/layering.test.ts`. Three edges are named on purpose — builder → `runner/RunnableChart.ts` (`makeRunnable`), engine → `reactive/handles.ts`, scope → `detach/spawn.ts` — plus a short `TYPE_ONLY_ALLOWANCES` list (upward imports tsc erases, which the lint rule cannot tell apart); both lists are live-checked and only shrink. A new src file under an unsplit directory inherits its layer; one under `memory/` (or an exact-path entry) must be added to LAYERS — an unplaced file fails lint and the script. Public symbols have ONE canonical door each — `test/architecture/exports.test.ts` fails on any symbol two of the six `package.json` doors both hand out unless it is in `SECOND_DOORS` (28 today, in four reasoned groups; an alias counts as a door).
 
 ## Core state & flow
-- `SharedMemory` (memory/SharedMemory.ts) — address-scoped heap: the frame's record frame hands it the address (`RecordFrame · address`; the engine decides it in `StageContext.ts · runAddress` / `useAddressOf` from the ONE L4 constant `RUN_NAMESPACE`, C2/C3); committed state is **immutable-after-swap**, COPY-ON-WRITE since 9.29.0: every write (`applyPatch` → `verbs · nextGeneration`, `setValue`/`updateValue`) copies the root + the containers on each written path and SHARES every other subtree with the previous generation, then swaps. A generation is never edited; the seed is detached once at construction. Design: docs/design/2026-10-copy-on-write-commit.md.
-- `StageContext` (memory/StageContext.ts:29) — per-stage frame inside a run; composes `RecordFrame` (memory/RecordFrame.ts, L3, C3: the lazy TransactionBuffer, the first-touch base, the two-tier read, readKeys, the address); `commit()` → `RecordFrame · commit` (payload, then the names) → `memory/recordCommit.ts · recordCommit` (live apply → scrub → mirror → `EventLog.record`) → onCommit → `RecordFrame · release`. `runId` is readonly (the address is decided once, 9.46.0).
+- `SharedMemory` (memory/SharedMemory.ts) — address-scoped heap: the frame's record frame hands it the address (`RecordFrame · address`; the engine decides it in `runAddress.ts · runAddress` / `StageContext · useAddressOf` from the ONE L4 constant `runAddress.ts · RUN_NAMESPACE`, C2–C4); committed state is **immutable-after-swap**, COPY-ON-WRITE since 9.29.0: every write (`applyPatch` → `verbs · nextGeneration`, `setValue`/`updateValue`) copies the root + the containers on each written path and SHARES every other subtree with the previous generation, then swaps. A generation is never edited; the seed is detached once at construction. Design: docs/design/2026-10-copy-on-write-commit.md.
+- `StageContext` (memory/StageContext.ts:29) — per-stage frame inside a run; composes `RecordFrame` (memory/RecordFrame.ts, L3, C3: the lazy TransactionBuffer, the first-touch base, the two-tier read, readKeys, the address); `commit()` → `RecordFrame · commit` (payload, then the names) → `memory/recordCommit.ts · recordCommit` (live apply → scrub → mirror → `EventLog.record`) → onCommit → `RecordFrame · release`. `runId` is readonly (the address is decided once, 9.46.0). A staged write is `StageContext · stageWrite`: `redaction.ts · decideWrite` (the verdict) → `inheritByIdentity` (an object read under a selected name keeps its rule) → `RecordFrame · write(…, scrubOf(verdict))` (its bytes) → `markStagedWrite` (the run's marks, only once the write staged; C4, 9.46.1). Each step reads the rule when it acts.
 - `CommitBundle`/`EventLog` — one bundle per executed stage, `bundle.idx` == array position; encoding governed by `commitValues: 'full'|'delta'`.
 - `TraversalContext` (engine/narrative/types.ts:172) — THE per-event context (runId, runtimeStageId, parentRuntimeStageId, subflowPath, loopIteration); stamped on every FlowRecorder event.
 - `runtimeStageId` = `[subflowPath/]stageId#executionIndex`; counter shared by reference into subflow traversers → globally unique; NOT reset on resume.
@@ -54,13 +54,13 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 
 ## Change-impact map
 - **Trace verbs** (`set|merge|append|delete`, memory/types.ts:42) → ONE law, `memory/verbs.ts` (L1) — F2 deleted the three replicas. `applyVerb` is the ONLY function with an arm per verb (a fifth verb in the union stops compiling there; `TRAITS` — `isTotal` / `recordsTail` — says what a verb IS, pinned against the step), `placeVerb` puts its value or removes the key (`ABSENT`), and two loops fold it: `foldRows` folds ONE bundle's rows into a state with the clone DISCIPLINE as a parameter (`'private'` = the PUBLIC `applySmartMerge`, which keeps its 9.28.0 contract: base deep-cloned, fully detached result — 9.29.0; `'pathCopy'` = the engine's `nextGeneration` — live commit + redacted mirror — and the folds' `applySmartMergeInto` — `stateAt`, `EventLog.materialise`; `'byReference'` = `dryFold`, the admitted record's comparison fold — 9.30.0), and `foldKey` folds ONE path's rows across a log — `commitLogUtils · commitValueAt` (anchored at the last total row) and `slice/elementProvenance · arrayProvenance` (an OBSERVER of that fold: it keeps the births and has no verb switch); causalChain/findLastWriter only match paths. A bundle's merge delta is detached ONCE per bundle (`RecordedPayload`): `deepSmartMerge` dedups an array union BY REFERENCE, so the merge rows of one bundle must see the same objects (a per-row clone made `commitValueAt` double the elements — the 9.29.0 reader bug, fixed here); `foldKey` narrows that copy to its one path. **An unknown verb is REFUSED** (`UnknownVerbError`, public on `/trace`; R2) by `foldRows` (so `applySmartMerge`), `commitValueAt`, `arrayProvenance` — they used to fold it as a `merge`; `time-travel/bundles · bundleRefusal` asks the same `isVerb` and makes it a GAP instead. Pinned: the three old replicas live on as the CONTROL in test/lib/memory/property/verb-law-differential.property.test.ts (kept for the packet's lifetime). The delta encoder keeps VOCABULARY only since 9.30.0 (it picks a verb; its values come from `dryFold` of the stage's 'full' rows — `TransactionBuffer · fullRowsValue`; `replayPathVerbs`/`replayFamilyVerbs` deleted). NOT a second loop (9.22.1): `verbs.ts · supersededByNextSet` — the ONE repeated-path skip (CONSECUTIVE same-path `set` rows: only the last is applied), asked by `foldRows` before its step; its commit-side twin is the last-materialised-path memo in `toChangeOnlyPayload`. Rows are never dropped from the log; a non-consecutive skip is WRONG (a descendant op in between coerces/shells the container) — pinned by test/lib/memory/scenario/repeated-path-byte-identity.test.ts. Since 9.23.0 the clone in that memo loop (and every `structuredClone` in `toDeltaPayload`) is THE clone — the patch trees hold references until commit; no verb switch was touched.
-- **Write address** → ONE constant, `StageContext.ts · RUN_NAMESPACE` (L4), read by `runAddress` and `useAddressOf`; the frame's `RecordFrame` holds the address (C3). `SharedMemory` and the nested writers take the address as data and refuse a non-array; `TransactionBuffer` takes it too (C2, 9.45.0). `test/architecture/write-address.test.ts` refuses the namespace below L4, as a literal or a property (exceptions `RedactionRule · verdictOfRead` / `retainState` until C4).
+- **Write address** → ONE constant, `runAddress.ts · RUN_NAMESPACE` (an L4 leaf, C4), read by `runAddress` / `useAddressOf` and by `RedactionRule · verdictOfRead` / `retainState`; the frame's `RecordFrame` holds the address (C3). `SharedMemory` and the nested writers take the address as data and refuse a non-array; `TransactionBuffer` takes it too (C2, 9.45.0). `test/architecture/write-address.test.ts` refuses the namespace below L4, as a literal or a property — no exceptions since C4.
 - **StageContext.commit / dials** → ONE owner since 9.35.0 (F5): `memory/runPolicy.ts` — a frozen `RunPolicy` (the four dials + the `RedactionRule` + the mirror flag) built ONCE by `FlowChartExecutor · createTraverser` (run AND resume), handed to `ExecutionRuntime`, held BY REFERENCE by every `StageContext` (`inheritRun` in createNext/createChild) and by its `RecordFrame` as its encoding (`useEncoding`, through `StageContext · adoptPolicy`, the one place a frame's policy changes) and passed by `SubflowExecutor · executeSubflow` to the nested runtime BEFORE the seed. A fifth dial = the policy type + its consumer. The old per-dial `use*`/`get*` and `enableRedactedMirror` were removed in 9.36.0 (no compat shims — owner ruling). `commit()`'s FIRST act (9.23.0) is `materialiseWrites` — the `writeTracking` retained form is taken there, once per key, from `_pendingWrites` (bare references + the write-time verdict); anything that reads `_stageWrites` goes through `retainedWrites()` (a non-consuming fold, so a mid-run snapshot is honest), and `discardStaged` drops the pending map with the rest.
 - **runtimeStageId format** (`#`/`/` delimiters) → ONE grammar owner since 9.37.0 (F7): `src/lib/ids/` (L0 leaf: `runtimeStageId.ts` — `parseRuntimeStageId`, `isExecutionKey`, `stageIdOf`, `subflowPathOf`, `refuseReservedId`; `branchSegment.ts` — the `~` grammar). Every parser (ScopeFacade subflow path, subflowResults dual-keying, narrative buffering, store keys) calls it; none re-derives the grammar. R5: every id door (22 at build, plus the run-time dynamic-StageNode door) refuses `#` and `/`; stage ids may contain `~`. `TraversalContext` has ONE constructor (`engine/traversalContext.ts`); `depth` = subflow nesting read off the runtimeStageId on every stamp. Brands `RuntimeStageId`/`ExecutionIndex`/`CommitIdx` on `/trace` (types only).
 - **Subflow id prefixing** → ONE prefixer since 9.37.0: `engine/graph/prefixNodeTree.ts`, used by the builder AND the traverser (eager, lazy and `parallelForEach` mounts — lazy/branch roots were unprefixed before 9.37.0, so branch ids collided); change it + stageMap key composition + resume drilling; the builder's eager mounts all go through `FlowChartBuilder · _mountSubflow` (F10). test/lib/engine/branch-segment-prefixer-equivalence.test.ts stays as a guard.
 - **Checkpoint shape** (format 2 since 9.44.0, LEAN: only what resume reads + the pause's record — no `executionTree`/`subflowResults`; size independent of run length, pinned by test/lib/pause/checkpoint-size.test.ts; 9.39–9.43 refuse format 2, so upgrade readers before writers) → `runner/checkpoint.ts · buildPauseCheckpoint` ↔ `pause/record.ts · decodeCheckpoint` (one upcaster drops v0/v1 fields) ↔ `runner/resume.ts · planResume` (validation via `pause/record.ts · decodeCheckpoint`) ↔ `ResumeEntry.plan` (the path's mounts + captures + dispatcher continuations, the `pendingPauses` queue; refused up front when unwalkable, ambiguous, or a pending record is not a sibling) ↔ `SubflowExecutor · executeSubflow` resume hop (seed from the capture in place of the mapper's values — the mapper still runs, for the args — FIRST entry only) ↔ `ChildrenExecutor · raisePauses` (fills `pendingPauses`). 9.28.0 adds ONE optional field, `pendingPauses` (present only when parallel siblings wait); the redaction law adds `redactionMarks` (names only, present only when the run marked something); every stored checkpoint enters through `pause/record.ts · decodeCheckpoint` (`checkpointVersion: 1`, one upcaster from unversioned v0 which drops the legacy `continuationStageId`, one validator, one message set; 9.39.0). Pinned: a 9.27.0 checkpoint resumes, test/lib/pause/resume-real-chart-9.27.0-checkpoints.test.ts.
 - **Committed-state writers** (copy-on-write, 9.29.0) → anything that writes into `SharedMemory`'s state, a fold's working copy or the buffer's working copy must copy before it writes: `pathOps · ownSpine` for the containers on the path, `ownedRootOf` for the root, `own`/`adopt` for what it created. An in-place edit of a container it did not create edits every generation sharing it — the counted guard stays green while the generations property fails. A new READ path through `TransactionBuffer` goes through `get` (private after the first write) unless it only compares (`peek`); a read the working copy cannot answer is served from LIVE state (`RecordFrame · read`, as on 9.28.0) after `TransactionBuffer · detachBase` gives the diff base a private copy at that path — a private copy of the value handed out instead would change live state wherever 9.28.0 let an in-place edit in (a fork child's read of a parent key). `TransactionBuffer · merge` privatises its base first: `deepSmartMerge` dedups arrays BY REFERENCE, so the identity of the base is part of the bytes.
-- **Redaction** (9.19.0; the law restored to owner ruling (a)) has ONE owner: `memory/redaction.ts` `RedactionRule` (verdict per user-level path: `clear | whole | fields`), carried on the run's `RunPolicy` with the four dials (F5). THE LAW: a policy covers EVERYTHING the library retains or serves — log (both encodings), mirror, stageReads/stageWrites, every recorder event inline and deferred (and the rows built from them), narrative, snapshots, diagnostics, pause payloads, boundary records, logger lines — and NEVER the live heap or the resume checkpoint. The two true exceptions are the caller's own values: the `run()` rejection and the live fork result. It selects by NAME, never by content: state by path (`verdict`); a record handed out whole (root input/output — `FlowchartTraverser.execute`; subflow seed/exit — `SubflowExecutor`; pause payload — `engine/handlers/servedPause.ts`; thrown value — `retainStageError`) by its keys at every depth plus declared `fields` under a key of that name (`retainBoundary` — one decision per PATH via `servedByPath`: copy-on-write per path, the visited set only the current path's ancestor stack, a cycle edge landing on the served copy; a path rule is exact under shared references, a key-NAME rule masks a shared node everywhere); a diagnostic entry as the record `{ [name]: value }` (`retainDiagnostic`; `policy.diagnostics` ADDS diagnostic-only selectors, the only ones that reach flow-message text); a subflow mapper's copy by TAINT (`MapperTaint`, asked by `SubflowInputMapper` for both mappers; the `parallelForEach` items selector counts selected reads via `StageContext · selectedReads` and marks `item`/`into`): a value passed under its own name keeps that name's verdict, an object by reference (or the whole handed record, as fields) keeps its source's, anything computed after a selected read is marked whole (conservative); never value equality across names. A mark is a NAME, run-wide, until the key is deleted — and a pause carries the marks (names only) to the resumed run (`FlowchartCheckpoint.redactionMarks`, checked by `pause/record.ts`). A thrown value is walked with its `cause`/`errors`; an object a mapper passes on by reference is scanned for the selected values it read (planted → fields). Name-only patterns (`needsPath` false — no `.`, lookaround, or escape/class that can match `.`) are decided per object, so the walk shares decisions per (object, targets) — linear on a DAG or a linked history; only a path-dependent pattern walks paths, and past 1,000,000 visits it serves the unvisited remainder as the placeholder (one dev-mode warning), never fails the run. Inside a stage, an OBJECT read under a selected name and written under another keeps its rule (`StageContext · stageWrite`, by identity); a primitive or a new object copied across names is selected by its own name only. `StageContext.stageWrite` is the ONE write funnel (facade writes, subflow seed, outputMapper merge-back, resume re-seed) and `getValue` retention asks the same rule; the facade asks it for read/write recorder payloads. An inert rule never enumerates a payload. `emitPatterns` is the one separate scrub (`$emit` payloads, by event name). Two placeholders, historical: log/mirror `'REDACTED'`, scope-tier `'[REDACTED]'`. See `docs/guides/scope.md` → "The one law". Capture the retained form at runtime; no second tree walk or recorder-local policy.
+- **Redaction** (9.19.0; the law restored to owner ruling (a)) has ONE owner of the DECISION, `memory/redaction.ts` (L4 since C4): `RedactionRule` (verdict per user-level path: `clear | whole | fields`) and, per staged write, `decideWrite` → `inheritByIdentity` → (the record writes) → `markStagedWrite` (the marks, only once the write staged — a failed `$update` leaves no mark in `redactionMarks` or the report); the BYTES are the record's (`RecordFrame · write` registers `scrubOf(verdict)`, `memory/scrub.ts · scrubPatch` (L2) writes the log's placeholder at commit; no record file imports `redaction.ts`), carried on the run's `RunPolicy` with the four dials (F5). THE LAW: a policy covers EVERYTHING the library retains or serves — log (both encodings), mirror, stageReads/stageWrites, every recorder event inline and deferred (and the rows built from them), narrative, snapshots, diagnostics, pause payloads, boundary records, logger lines — and NEVER the live heap or the resume checkpoint. The two true exceptions are the caller's own values: the `run()` rejection and the live fork result. It selects by NAME, never by content: state by path (`verdict`); a record handed out whole (root input/output — `FlowchartTraverser.execute`; subflow seed/exit — `SubflowExecutor`; pause payload — `engine/handlers/servedPause.ts`; thrown value — `retainStageError`) by its keys at every depth plus declared `fields` under a key of that name (`retainBoundary` — one decision per PATH via `servedByPath`: copy-on-write per path, the visited set only the current path's ancestor stack, a cycle edge landing on the served copy; a path rule is exact under shared references, a key-NAME rule masks a shared node everywhere); a diagnostic entry as the record `{ [name]: value }` (`retainDiagnostic`; `policy.diagnostics` ADDS diagnostic-only selectors, the only ones that reach flow-message text); a subflow mapper's copy by TAINT (`MapperTaint`, asked by `SubflowInputMapper` for both mappers; the `parallelForEach` items selector counts selected reads via `StageContext · selectedReads` and marks `item`/`into`): a value passed under its own name keeps that name's verdict, an object by reference (or the whole handed record, as fields) keeps its source's, anything computed after a selected read is marked whole (conservative); never value equality across names. A mark is a NAME, run-wide, until the key is deleted — and a pause carries the marks (names only) to the resumed run (`FlowchartCheckpoint.redactionMarks`, checked by `pause/record.ts`). A thrown value is walked with its `cause`/`errors`; an object a mapper passes on by reference is scanned for the selected values it read (planted → fields). Name-only patterns (`needsPath` false — no `.`, lookaround, or escape/class that can match `.`) are decided per object, so the walk shares decisions per (object, targets) — linear on a DAG or a linked history; only a path-dependent pattern walks paths, and past 1,000,000 visits it serves the unvisited remainder as the placeholder (one dev-mode warning), never fails the run. Inside a stage, an OBJECT read under a selected name and written under another keeps its rule (`redaction.ts · inheritByIdentity`, by identity — decided before the write); a primitive or a new object copied across names is selected by its own name only. `StageContext.stageWrite` is the ONE write funnel (facade writes, subflow seed, outputMapper merge-back, resume re-seed) and `getValue` retention asks the same rule; the facade asks it for read/write recorder payloads. An inert rule never enumerates a payload. `emitPatterns` is the one separate scrub (`$emit` payloads, by event name). Two placeholders, historical, one per owner: log/mirror `'REDACTED'` (`placeholders.ts · LOG_PLACEHOLDER`, a record byte), scope-tier `'[REDACTED]'` (`redaction.ts · SCOPE_PLACEHOLDER`). See `docs/guides/scope.md` → "The one law". Capture the retained form at runtime; no second tree walk or recorder-local policy.
 - **Diagnostic retention** → `DiagnosticCollector` asks the current run rule before merging/storing: a named entry maps to the state key of its name (the run's keys/patterns/marks/fields, at every depth of the value), then the opt-in `RedactionPolicy.diagnostics` selectors (same path algorithm, rooted at the channel). Its internal retained-write bridge supplies legacy facade emits. Existing writers stay void. Only flow-message description/rationale are payloads (no name — diagnostic selectors only); keys/topology/timing stay present. Dynamic capture uses a per-visit engine flag, not a diagnostic bag. A redacted `logs.deciderRationale` also reaches decision explanations. Checkpoints keep retained diagnostic bags but preserve operational state; no retroactive scrub. See the scope guide's diagnostic contract.
 - **Traverser phases** → node-shape reads must use eff* overlay accessors (:646-703) or dynamic StageNode returns break; tail continuations must return ContinuationHops or stacks regrow; decider flat-dispatch must keep InvokerStamp or pause loses its invoker.
 

package/dist/esm/lib/decide/evaluator.js

@@ -9,7 +9,7 @@
  */
 import { summarizeValue } from '../capture/summarize.js';
 import { isDevMode } from '../devMode.js';
-import { SCOPE_PLACEHOLDER } from '../memory/placeholders.js';
+import { SCOPE_PLACEHOLDER } from '../memory/redaction.js';
 const OPERATOR_HANDLERS = {
     eq: (a, t) => a === t,
     ne: (a, t) => a !== t,
@@ -127,4 +127,4 @@ export function evaluateFilter(getValueFn, isRedactedFn, filter) {
         return { matched: false, conditions };
     return { matched: allMatched, conditions };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../src/lib/decide/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/evaluator -- Prisma-style filter evaluator for decision rules.\n *\n * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.\n * Evaluates each condition, records the result, returns matched/conditions.\n *\n * All keys in the filter are ANDed (all must match for the rule to match).\n * Decoupled from ScopeFacade — receives callbacks, not scope.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport { isDevMode } from '../devMode.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/placeholders.js';\nimport type { FilterCondition, WhereFilter } from './types.js';\n\n// -- Operator dispatch table -------------------------------------------------\n\ntype OperatorFn = (actual: unknown, threshold: unknown) => boolean;\n\nconst OPERATOR_HANDLERS: Record<string, OperatorFn> = {\n  eq: (a, t) => a === t,\n  ne: (a, t) => a !== t,\n  gt: (a, t) => (a as number) > (t as number),\n  gte: (a, t) => (a as number) >= (t as number),\n  lt: (a, t) => (a as number) < (t as number),\n  lte: (a, t) => (a as number) <= (t as number),\n  in: (a, t) => {\n    if (!Array.isArray(t)) return false;\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return t.includes(a);\n  },\n  notIn: (a, t) => {\n    if (!Array.isArray(t)) return true; // not in a non-array = vacuously true\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return !t.includes(a);\n  },\n};\n\n// -- Security: prototype pollution denylist ----------------------------------\n\nconst DENIED_KEYS = new Set([\n  '__proto__',\n  'constructor',\n  'prototype',\n  'toString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__',\n]);\n\n// -- Constants ---------------------------------------------------------------\n\nconst MAX_IN_ARRAY_SIZE = 1000;\nconst MAX_VALUE_LEN = 80;\n\n// -- Evaluator ---------------------------------------------------------------\n\n/**\n * Evaluates a Prisma-style filter against scope values.\n *\n * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)\n *\n * A filter with no evaluable conditions (`{}`, or only denied/non-object\n * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL\n * intuition where `where: {}` matches everything: in a decision rule, a rule\n * that asserts nothing should never win a branch — \"all zero conditions\n * passed\" is vacuous truth, and silently routing on it would fabricate\n * decision evidence. Want a catch-all? Use the explicit `defaultBranch`\n * argument of `decide()` instead of an empty `when`.\n *\n * ## Unknown operators → condition fails (+ dev-mode warning)\n *\n * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,\n * notIn`) records a failed condition — the rule can never spuriously match\n * through a typo (`gte` misspelled `gle`). With dev mode enabled\n * (`enableDevMode()`), a console warning names the unknown operator and key.\n *\n * @param getValueFn - Reads a value from scope by key (raw, for comparison)\n * @param isRedactedFn - Checks if a key is redacted (for evidence display)\n * @param filter - The WhereFilter to evaluate\n * @returns { matched, conditions } — matched = all conditions passed\n */\nexport function evaluateFilter<T extends object>(\n  getValueFn: (key: string) => unknown,\n  isRedactedFn: (key: string) => boolean,\n  filter: WhereFilter<T>,\n): { matched: boolean; conditions: FilterCondition[] } {\n  const conditions: FilterCondition[] = [];\n  let allMatched = true;\n\n  for (const [key, ops] of Object.entries(filter)) {\n    // Security: denied keys cause rule to fail (consistent with unknown operator behavior)\n    if (DENIED_KEYS.has(key)) {\n      allMatched = false;\n      continue;\n    }\n    if (!ops || typeof ops !== 'object') continue;\n\n    const actual = getValueFn(key);\n    const redacted = isRedactedFn(key);\n    const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);\n\n    // Evaluate each operator in the FilterOps for this key\n    for (const [op, threshold] of Object.entries(ops as Record<string, unknown>)) {\n      const handler = OPERATOR_HANDLERS[op];\n      if (!handler) {\n        // Unknown operator: treat as failed condition so rule doesn't spuriously match\n        if (isDevMode()) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[footprint] decide()/select() filter: unknown operator \"${op}\" on key \"${key}\" — ` +\n              `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`,\n          );\n        }\n        conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });\n        allMatched = false;\n        continue;\n      }\n\n      const result = handler(actual, threshold);\n      conditions.push({\n        key,\n        op,\n        threshold,\n        actualSummary: displayValue,\n        result,\n        redacted,\n      });\n\n      if (!result) allMatched = false;\n    }\n  }\n\n  // Empty filter (no evaluable conditions) should NOT match — prevents vacuous\n  // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` (\"match\n  // everything\") — see the function JSDoc. Catch-alls belong in decide()'s\n  // explicit defaultBranch, not in an empty rule.\n  if (conditions.length === 0) return { matched: false, conditions };\n\n  return { matched: allMatched, conditions };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../src/lib/decide/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/evaluator -- Prisma-style filter evaluator for decision rules.\n *\n * Pure function. Takes a WhereFilter, a value getter, and a redaction checker.\n * Evaluates each condition, records the result, returns matched/conditions.\n *\n * All keys in the filter are ANDed (all must match for the rule to match).\n * Decoupled from ScopeFacade — receives callbacks, not scope.\n */\n\nimport { summarizeValue } from '../capture/summarize.js';\nimport { isDevMode } from '../devMode.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/redaction.js';\nimport type { FilterCondition, WhereFilter } from './types.js';\n\n// -- Operator dispatch table -------------------------------------------------\n\ntype OperatorFn = (actual: unknown, threshold: unknown) => boolean;\n\nconst OPERATOR_HANDLERS: Record<string, OperatorFn> = {\n  eq: (a, t) => a === t,\n  ne: (a, t) => a !== t,\n  gt: (a, t) => (a as number) > (t as number),\n  gte: (a, t) => (a as number) >= (t as number),\n  lt: (a, t) => (a as number) < (t as number),\n  lte: (a, t) => (a as number) <= (t as number),\n  in: (a, t) => {\n    if (!Array.isArray(t)) return false;\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return t.includes(a);\n  },\n  notIn: (a, t) => {\n    if (!Array.isArray(t)) return true; // not in a non-array = vacuously true\n    if (t.length > MAX_IN_ARRAY_SIZE) {\n      throw new Error(`in/notIn array exceeds maximum size of ${MAX_IN_ARRAY_SIZE}`);\n    }\n    return !t.includes(a);\n  },\n};\n\n// -- Security: prototype pollution denylist ----------------------------------\n\nconst DENIED_KEYS = new Set([\n  '__proto__',\n  'constructor',\n  'prototype',\n  'toString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__',\n]);\n\n// -- Constants ---------------------------------------------------------------\n\nconst MAX_IN_ARRAY_SIZE = 1000;\nconst MAX_VALUE_LEN = 80;\n\n// -- Evaluator ---------------------------------------------------------------\n\n/**\n * Evaluates a Prisma-style filter against scope values.\n *\n * ## Empty filter → NO match (anti-vacuous-truth — inverts Prisma/SQL)\n *\n * A filter with no evaluable conditions (`{}`, or only denied/non-object\n * keys) returns `matched: false`. This deliberately INVERTS the Prisma/SQL\n * intuition where `where: {}` matches everything: in a decision rule, a rule\n * that asserts nothing should never win a branch — \"all zero conditions\n * passed\" is vacuous truth, and silently routing on it would fabricate\n * decision evidence. Want a catch-all? Use the explicit `defaultBranch`\n * argument of `decide()` instead of an empty `when`.\n *\n * ## Unknown operators → condition fails (+ dev-mode warning)\n *\n * An operator outside the supported set (`eq, ne, gt, gte, lt, lte, in,\n * notIn`) records a failed condition — the rule can never spuriously match\n * through a typo (`gte` misspelled `gle`). With dev mode enabled\n * (`enableDevMode()`), a console warning names the unknown operator and key.\n *\n * @param getValueFn - Reads a value from scope by key (raw, for comparison)\n * @param isRedactedFn - Checks if a key is redacted (for evidence display)\n * @param filter - The WhereFilter to evaluate\n * @returns { matched, conditions } — matched = all conditions passed\n */\nexport function evaluateFilter<T extends object>(\n  getValueFn: (key: string) => unknown,\n  isRedactedFn: (key: string) => boolean,\n  filter: WhereFilter<T>,\n): { matched: boolean; conditions: FilterCondition[] } {\n  const conditions: FilterCondition[] = [];\n  let allMatched = true;\n\n  for (const [key, ops] of Object.entries(filter)) {\n    // Security: denied keys cause rule to fail (consistent with unknown operator behavior)\n    if (DENIED_KEYS.has(key)) {\n      allMatched = false;\n      continue;\n    }\n    if (!ops || typeof ops !== 'object') continue;\n\n    const actual = getValueFn(key);\n    const redacted = isRedactedFn(key);\n    const displayValue = redacted ? SCOPE_PLACEHOLDER : summarizeValue(actual, MAX_VALUE_LEN);\n\n    // Evaluate each operator in the FilterOps for this key\n    for (const [op, threshold] of Object.entries(ops as Record<string, unknown>)) {\n      const handler = OPERATOR_HANDLERS[op];\n      if (!handler) {\n        // Unknown operator: treat as failed condition so rule doesn't spuriously match\n        if (isDevMode()) {\n          // eslint-disable-next-line no-console\n          console.warn(\n            `[footprint] decide()/select() filter: unknown operator \"${op}\" on key \"${key}\" — ` +\n              `condition never matches (valid operators: ${Object.keys(OPERATOR_HANDLERS).join(', ')})`,\n          );\n        }\n        conditions.push({ key, op, threshold, actualSummary: displayValue, result: false, redacted });\n        allMatched = false;\n        continue;\n      }\n\n      const result = handler(actual, threshold);\n      conditions.push({\n        key,\n        op,\n        threshold,\n        actualSummary: displayValue,\n        result,\n        redacted,\n      });\n\n      if (!result) allMatched = false;\n    }\n  }\n\n  // Empty filter (no evaluable conditions) should NOT match — prevents vacuous\n  // truth. NOTE: this deliberately inverts Prisma/SQL `where: {}` (\"match\n  // everything\") — see the function JSDoc. Catch-alls belong in decide()'s\n  // explicit defaultBranch, not in an empty rule.\n  if (conditions.length === 0) return { matched: false, conditions };\n\n  return { matched: allMatched, conditions };\n}\n"]}

package/dist/esm/lib/decide/evidence.js

@@ -7,7 +7,7 @@
  * Uses summarizeValue() at capture time (no raw object references held).
  */
 import { summarizeValue } from '../capture/summarize.js';
-import { SCOPE_PLACEHOLDER } from '../memory/placeholders.js';
+import { SCOPE_PLACEHOLDER } from '../memory/redaction.js';
 const MAX_VALUE_LEN = 80;
 let evidenceCounter = 0;
 /**
@@ -34,4 +34,4 @@ export class EvidenceCollector {
         return this.inputs;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/engine/handlers/servedPause.js

@@ -11,7 +11,7 @@
  * Total: a payload whose scrub fails (an uncloneable value under a selected
  * field) is served as the placeholder — never raw, and never a failed pause.
  */
-import { SCOPE_PLACEHOLDER } from '../../memory/placeholders.js';
+import { SCOPE_PLACEHOLDER } from '../../memory/redaction.js';
 export function servedPause(context, pauseData) {
     const rule = context.getRedactionRule();
     if (!rule)
@@ -23,4 +23,4 @@ export function servedPause(context, pauseData) {
         return SCOPE_PLACEHOLDER;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,10 +3,11 @@
  *
  * 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.
+ * transaction buffer) and which of it the log must not show (the scrub of each write), 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 DECISION —
+ * which value is secret (`redaction.ts · decideWrite`); the frame writes the bytes it is handed (C4).
  *
  * THE LAW:
  *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands
@@ -28,11 +29,17 @@
  *      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).
+ *   7. WRITE. `write(path, value, verb, scrub?)` is the one way to stage: `set`, `merge` or `delete`
+ *      at an absolute path (the address already joined — `at`), with the bytes of a redaction
+ *      verdict. `whole` → the log and the mirror carry `LOG_PLACEHOLDER` at the path; `fields` → at
+ *      each field inside the value (a literal key and, when dotted, the nested path) — wherever it
+ *      holds a value at commit (`scrub.ts`). No scrub → the value as it is. The frame never decides
+ *      a scrub, and nothing outside it reaches its buffer.
  */
+import type { OpVerb } from './deltaEncoding.js';
 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.
@@ -43,6 +50,21 @@ export interface RecordEncoding {
     readonly commitValues: CommitValuesMode;
     readonly writeProvenance: WriteProvenanceMode;
 }
+/**
+ * What a stage can stage (law 7) — the transaction buffer's op verbs (`deltaEncoding.ts · OpVerb`), one
+ * union. `append` is not one: it is how the log encodes a grown array (`'delta'`).
+ */
+export type WriteVerb = OpVerb;
+/**
+ * The bytes of a redaction verdict for one write (law 7): which of it the commit log and the redacted
+ * mirror must not show. The engine decides it (`redaction.ts · decideWrite`); the frame only writes it.
+ */
+export interface WriteScrub {
+    /** The whole value: `LOG_PLACEHOLDER` at the write's path. */
+    readonly whole?: boolean;
+    /** Dot-paths INSIDE the value, relative to it: `LOG_PLACEHOLDER` at each one that holds a value. */
+    readonly fields?: readonly string[];
+}
 export declare class RecordFrame {
     /** Live committed state — the heap every frame of the run shares. */
     readonly state: SharedMemory;
@@ -129,8 +151,21 @@ export declare class RecordFrame {
      * 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}.
+     *
+     * Private since C4: every write goes through {@link write}, so the scrub travels with the op.
+     */
+    private getTransactionBuffer;
+    /**
+     * Stage one write (law 7): `verb` at `path` — an absolute path, the address already joined
+     * ({@link at}) — and the bytes of its redaction verdict. The first write builds the buffer (law 4).
+     *
+     * The scrub registers paths, never values: `whole` marks the op's own path, `fields` each field
+     * inside the value (a literal key and, when dotted, the nested path); `recordCommit` puts the
+     * log's placeholder wherever one of them holds a value at commit, for the mirror and the log only
+     * (`scrub.ts`). Live state takes the value as it is. A path marked by a write that the net-change
+     * filter drops goes with it.
      */
-    getTransactionBuffer(): TransactionBuffer;
+    write(path: (string | number)[], value: unknown, verb: WriteVerb, scrub?: WriteScrub): void;
     /** Has the frame staged a write since its last release — does its buffer exist? */
     get hasStaged(): boolean;
     /**

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

@@ -3,10 +3,11 @@
  *
  * 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.
+ * transaction buffer) and which of it the log must not show (the scrub of each write), 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 DECISION —
+ * which value is secret (`redaction.ts · decideWrite`); the frame writes the bytes it is handed (C4).
  *
  * THE LAW:
  *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands
@@ -28,6 +29,12 @@
  *      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).
+ *   7. WRITE. `write(path, value, verb, scrub?)` is the one way to stage: `set`, `merge` or `delete`
+ *      at an absolute path (the address already joined — `at`), with the bytes of a redaction
+ *      verdict. `whole` → the log and the mirror carry `LOG_PLACEHOLDER` at the path; `fields` → at
+ *      each field inside the value (a literal key and, when dotted, the nested path) — wherever it
+ *      holds a value at commit (`scrub.ts`). No scrub → the value as it is. The frame never decides
+ *      a scrub, and nothing outside it reaches its buffer.
  */
 import { nativeGet } from './pathOps.js';
 import { recordCommit } from './recordCommit.js';
@@ -151,6 +158,8 @@ export class RecordFrame {
      * 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}.
+     *
+     * Private since C4: every write goes through {@link write}, so the scrub travels with the op.
      */
     getTransactionBuffer() {
         if (!this.buffer) {
@@ -163,6 +172,28 @@ export class RecordFrame {
         }
         return this.buffer;
     }
+    /**
+     * Stage one write (law 7): `verb` at `path` — an absolute path, the address already joined
+     * ({@link at}) — and the bytes of its redaction verdict. The first write builds the buffer (law 4).
+     *
+     * The scrub registers paths, never values: `whole` marks the op's own path, `fields` each field
+     * inside the value (a literal key and, when dotted, the nested path); `recordCommit` puts the
+     * log's placeholder wherever one of them holds a value at commit, for the mirror and the log only
+     * (`scrub.ts`). Live state takes the value as it is. A path marked by a write that the net-change
+     * filter drops goes with it.
+     */
+    write(path, value, verb, scrub) {
+        const buffer = this.getTransactionBuffer();
+        const whole = scrub?.whole === true;
+        if (verb === 'merge')
+            buffer.merge(path, value, whole);
+        else if (verb === 'delete')
+            buffer.delete(path, whole);
+        else
+            buffer.set(path, value, whole);
+        if (scrub?.fields !== undefined)
+            buffer.markRedactedFields(path, scrub.fields);
+    }
     /** Has the frame staged a write since its last release — does its buffer exist? */
     get hasStaged() {
         return this.buffer !== undefined;
@@ -262,4 +293,4 @@ export class RecordFrame {
         this.readKeys = undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecordFrame.js","sourceRoot":"","sources":["../../../../src/lib/memory/RecordFrame.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RecordFrame — the record half of one stage's frame (C3, L3).\n *\n * What a stage's frame needs to READ and WRITE the record, and nothing about the stage inside a run:\n * where it writes (its address), what it read first (the first-touch base), what it staged (the lazy\n * transaction buffer), which keys it read (the readKeys list), and where a commit lands (live state,\n * the redacted mirror, the log — through `recordCommit`). The engine's frame (`StageContext`, L4)\n * composes one and keeps the rest: retention, diagnostics, the dev-mode warnings, the commit observer\n * and the redaction verdict.\n *\n * THE LAW:\n *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands\n *      over as data (C2: `['runs', <id>]` or `[]`, the root). It moves only before the first write:\n *      the buffer keeps the address it was built at (the engine refuses a later move).\n *   2. FIRST TOUCH. The committed generation the frame first touched — its first read OR first write —\n *      is held by reference, never cloned: the read view before the first write and the buffer's\n *      net-change diff base after it.\n *   3. TWO TIERS. A read is served from the stage's own view (the buffer's working copy once the stage\n *      wrote, else the first-touch base); a key absent there is served from LIVE state (at the\n *      address, then the root). After the first write the buffer's diff base is first given a private\n *      copy at that path (`TransactionBuffer · detachBase`).\n *   4. LAZY BUFFER. The buffer is built at the first write — on the first-touch base, at the address,\n *      under the encoding. A frame that never writes builds none, and its commit is the empty bundle.\n *   5. READ KEYS. Under `writeProvenance: 'reads-prefix'` every noted read puts its user-level key\n *      (dotted for a nested path) on the frame's list, once, in order; each staged row carries a copy\n *      of the list as it stands when the row is staged.\n *   6. COMMIT, RELEASE, DISCARD. `commit` takes the buffer's payload (none = the empty commit), then\n *      the names, and hands both to `recordCommit`. `release` drops the buffer and the base; a frame\n *      touched again re-anchors on the state as it stands then. The readKeys list survives a release,\n *      and goes with `discard` (a failed attempt never happened).\n */\n\nimport type { EventLog } from './EventLog.js';\nimport { nativeGet } from './pathOps.js';\nimport { type CommitStamp, recordCommit } from './recordCommit.js';\nimport type { SharedMemory } from './SharedMemory.js';\nimport { TransactionBuffer } from './TransactionBuffer.js';\nimport type { CommitValuesMode, WriteProvenanceMode } from './types.js';\n\n/**\n * The two dials that shape a frame's bytes: the log's value encoding and the per-row read prefix.\n * Held by reference and swapped whole (`useEncoding`), never edited — the engine hands the run's\n * frozen policy itself. Absent: `'full'` values and no read prefix.\n */\nexport interface RecordEncoding {\n  readonly commitValues: CommitValuesMode;\n  readonly writeProvenance: WriteProvenanceMode;\n}\n\nexport class RecordFrame {\n  /** Live committed state — the heap every frame of the run shares. */\n  readonly state: SharedMemory;\n  /** The log the frame's commits land on, when the run keeps one. */\n  readonly log?: EventLog;\n  /** The redacted mirror the frame's commits land on, when the run keeps one ({@link useMirror}). */\n  private _mirror?: SharedMemory;\n  /** Where the frame reads and writes (law 1). */\n  private _address: readonly string[];\n  /** The two dials (law 4, 5); absent → the record's defaults. */\n  private encoding?: RecordEncoding;\n  /**\n   * The committed generation at the frame's FIRST touch (law 2) — held by REFERENCE, never cloned.\n   * See {@link firstTouch} for the algorithm and the immutability invariant that makes a bare\n   * reference safe.\n   */\n  private base?: Record<string, unknown>;\n  /** The stage's staged writes — built at its first write (law 4), released at commit. */\n  private buffer?: TransactionBuffer;\n  /**\n   * Keys tracked-read so far, in order (law 5) — the source of each staged row's `readKeys`. Only\n   * allocated under `'reads-prefix'`; insertion-ordered (a Set) and monotonic, which is what makes\n   * \"last write's prefix == union\" hold in delta mode.\n   */\n  private readKeys?: Set<string>;\n\n  constructor(state: SharedMemory, log?: EventLog, address: readonly string[] = []) {\n    this.state = state;\n    this.log = log;\n    this._address = address;\n  }\n\n  /** Where the frame reads and writes (law 1). */\n  get address(): readonly string[] {\n    return this._address;\n  }\n\n  /**\n   * Read and write at `address` from now on — before the frame's first write (law 1): the buffer keeps\n   * the address it was built at. The engine's one caller, `StageContext · useAddressOf`, refuses a move\n   * once the frame has staged.\n   */\n  useAddress(address: readonly string[]): void {\n    this._address = address;\n  }\n\n  /** The two dials the frame encodes under from its next buffer and its next read on (law 4, 5). */\n  useEncoding(encoding: RecordEncoding): void {\n    this.encoding = encoding;\n  }\n\n  /** The redacted mirror, if the run keeps one. */\n  get mirror(): SharedMemory | undefined {\n    return this._mirror;\n  }\n\n  /** Land every commit from now on on `mirror` too, with the scrubbed rows the log takes (`recordCommit`). */\n  useMirror(mirror: SharedMemory | undefined): void {\n    this._mirror = mirror;\n  }\n\n  /** The absolute path of `key` under `path`: the frame's address, then the path, then the key. */\n  at(path: readonly string[], key: string): string[] {\n    // Every read and write builds one. The root's is the path and the key; under an address, an\n    // index loop — the double spread `[...address, ...path, key]` costs a third more per call\n    // (as `utils · pathUnder` found for the address and the path).\n    const address = this._address;\n    if (address.length === 0) return [...path, key];\n    const out = new Array<string>(address.length + path.length + 1);\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    out[out.length - 1] = key;\n    return out;\n  }\n\n  /**\n   * ── The first-touch base (#13) ───────────────────────────────────────────\n   *\n   * WHAT: returns the committed shared state as it was at this frame's FIRST touch (first read or\n   * first write), capturing the reference on first call. Serves two consumers: reads before the first\n   * write ({@link read}) and the transaction buffer's diff base ({@link getTransactionBuffer}).\n   *\n   * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed state is\n   * immutable-after-swap. Every write to `SharedMemory` builds the NEXT generation and swaps it in\n   * (copy-on-write, 9.29.0: `applyPatch` via `nextGeneration`, and `setValue`/`updateValue` too) — it\n   * copies the root and the containers on each written path, shares the rest, and never edits a\n   * container of the generation a stage captured here. Holding the reference therefore gives this\n   * stage a stable snapshot at zero cost — no clone, which is the entire point of #13. The transaction\n   * buffer's net-change diff base rests on the same guarantee: it IS this view.\n   *\n   * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the state into the buffer at\n   * the stage's first ACCESS, anchoring both its snapshot reads and its commit baseline (the\n   * net-change diff base) there. #13's first cut anchored the lazy buffer at first WRITE — observably\n   * different when something else commits in the gap between this stage's first read and its first\n   * write. That gap is REACHABLE: fork siblings are namespace-isolated for run-scoped keys (each child\n   * writes under `runs/<childId>/`), but ROOT-level keys are shared — written via `setGlobal` from\n   * consumer scope code and, critically, by `SubflowInputMapper`'s output mapping\n   * (`parentContext.setGlobal`), which is exactly what runs when a subflow is a fork branch. A\n   * sibling's root-key commit landing in the gap would shift this stage's diff base, making its\n   * CommitBundle record a phantom change (or swallow a real one) relative to the eager engine.\n   * Anchoring the view at first touch restores the EXACT eager semantics — sequential AND parallel —\n   * at zero clone cost.\n   *\n   * Read visibility is two-tier, matching eager byte-for-byte: keys present in the view at first\n   * touch read repeatably from it; keys ABSENT from it fall back to LIVE state (the eager engine's\n   * exact fallback — a mid-flight sibling root-key write was always visible to reads, and stays\n   * visible; only the DIFF BASE is pinned).\n   */\n  private firstTouch(): Record<string, unknown> {\n    if (!this.base) {\n      this.base = this.state.getState();\n    }\n    return this.base;\n  }\n\n  /**\n   * The transaction buffer, created lazily on the frame's FIRST WRITE (#13).\n   *\n   * Reads NEVER construct it: read-your-writes only matters once a staged write exists, so before that\n   * {@link read} serves from the first-touch base and {@link commit} records an empty bundle — all with\n   * ZERO `structuredClone`s of the shared state.\n   *\n   * The buffer's base is the FIRST-TOUCH view, NOT the live state at write time: under parallel forks\n   * a sibling may have committed between this frame's first read and this write, and the net-change\n   * diff base must stay anchored at first touch to match the eager engine — see {@link firstTouch}.\n   */\n  getTransactionBuffer(): TransactionBuffer {\n    if (!this.buffer) {\n      // Per-write provenance (#P1): hand the buffer a live view of this frame's read prefix —\n      // evaluated AT EACH WRITE, so each staged op captures exactly the reads that preceded it.\n      const readKeysProvider =\n        this.encoding?.writeProvenance === 'reads-prefix' ? () => [...(this.readKeys ?? [])] : undefined;\n      // The frame's address (9.30.0: the admitted record reads the containers there as where the\n      // stage writes, never as a value it read).\n      this.buffer = new TransactionBuffer(\n        this.firstTouch(),\n        this.encoding?.commitValues,\n        readKeysProvider,\n        this._address,\n      );\n    }\n    return this.buffer;\n  }\n\n  /** Has the frame staged a write since its last release — does its buffer exist? */\n  get hasStaged(): boolean {\n    return this.buffer !== undefined;\n  }\n\n  /**\n   * The frame's read, mirroring the eager engine's read order byte-for-byte (law 3):\n   *\n   *    1. staged writes + first-touch snapshot — `buffer.get` over its workingCopy when the buffer\n   *       exists, else `nativeGet` over the zero-clone first-touch base (the buffer's base IS that\n   *       view, so the two tiers agree on content);\n   *    2. LIVE state via `SharedMemory · getValue` for keys absent from the snapshot — including its\n   *       address→root fallback. The eager engine had this exact live fallback for snapshot-missing\n   *       keys; byte-identity over purity. After the frame's first write such a value can be the very\n   *       container the buffer's diff base holds at the path (the stage deleted or unset it, or\n   *       replaced a container above it), so the base is detached there first\n   *       (`TransactionBuffer · detachBase`): an in-place edit of the value (out of contract) written\n   *       back is recorded, as on 9.28.0, whose base was a clone taken at the first write.\n   *\n   * Reads never construct the buffer (#13): a frame that never writes performs zero clones of the\n   * shared state.\n   */\n  read(path: string[], key?: string): unknown {\n    const at = this.at(path, key as string);\n    const fromSnapshot = this.buffer ? this.buffer.get(at) : nativeGet(this.firstTouch(), at);\n    if (typeof fromSnapshot !== 'undefined') return fromSnapshot;\n    const live = this.state.getValue(this._address, path, key);\n    // Tier 2 after the first write: keep the diff base exact (see above).\n    if (this.buffer && live !== null && typeof live === 'object') this.buffer.detachBase(at);\n    return live;\n  }\n\n  /** Put a tracked read's user-level key on the readKeys list (law 5) — a no-op unless the frame keeps one. */\n  noteRead(path: readonly string[], key: string): void {\n    if (this.encoding?.writeProvenance === 'reads-prefix') {\n      (this.readKeys ??= new Set()).add(path.length > 0 ? [...path, key].join('.') : key);\n    }\n  }\n\n  /**\n   * Live committed state at `key`: at the frame's address, else at the root — never the stage's own\n   * view. Typed as `SharedMemory · getValue` types it, which `StageContext · getRoot` hands on.\n   */\n  readLive(key: string) {\n    return this.state.getValue(this._address, [], key);\n  }\n\n  /** Live committed state at `key` at the root — typed as `SharedMemory · getValue` (`StageContext · getGlobal`). */\n  readGlobal(key: string) {\n    return this.state.getValue([], [], key);\n  }\n\n  /** Did a staged op touch `path` — on it, above it or below it? (A report's question; never the hot path.) */\n  wasStaged(path: (string | number)[]): boolean {\n    return this.buffer !== undefined && this.buffer.wasStaged(path);\n  }\n\n  /**\n   * The value at `path` in what the stage has seen — its working copy once it wrote, else its\n   * first-touch base — WITHOUT taking a private copy: for a report that only compares.\n   */\n  peek(path: (string | number)[]): unknown {\n    return this.buffer ? this.buffer.peek(path) : nativeGet(this.firstTouch(), path);\n  }\n\n  /** The value at `path` in the first-touch base — committed state as the frame first touched it. */\n  baseAt(path: (string | number)[]): unknown {\n    return nativeGet(this.firstTouch(), path);\n  }\n\n  /**\n   * Record what the frame staged (law 6): the buffer's payload first — none, the empty commit, when\n   * it staged nothing (#13: zero clones) — then the names (`stampOf()`), read once the payload is\n   * built, and both to `recordCommit`. User code can run while the payload is built (a getter on a\n   * staged value, which the net-change compare and the clone invoke); what it adds to the names —\n   * an untracked read, say — is on the bundle.\n   */\n  commit(stampOf: () => CommitStamp): void {\n    const payload = this.buffer?.commit();\n    recordCommit(payload, stampOf(), { state: this.state, mirror: this._mirror, log: this.log });\n  }\n\n  /**\n   * End the frame's hold on state (#13b, law 6): drop the buffer (its working copy and whatever private\n   * copies its reads took) and the first-touch base (a reference that pins one committed-state\n   * GENERATION). Both re-create lazily: a later read re-anchors on the CURRENT committed state, and a\n   * later write builds a fresh buffer on it — so a second commit diffs against the state after the\n   * first. Without the release, the execution tree — which retains every frame for the lifetime of\n   * the run — retains one state generation per executed stage (measured O(N²) before copy-on-write;\n   * a 500-iteration agent OOMed a default Node heap, backlog #18).\n   */\n  release(): void {\n    this.buffer = undefined;\n    this.base = undefined;\n  }\n\n  /**\n   * Throw away everything the frame staged and read (law 6): the buffer, the first-touch base (the next\n   * attempt re-anchors on committed state as it stands NOW) and the readKeys list — a discarded\n   * attempt's reads must never reach the next attempt's `TraceEntry.readKeys`, or a backward slice\n   * would follow an edge that no committed write ever had. Nothing is recorded.\n   */\n  discard(): void {\n    this.release();\n    this.readKeys = undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecordFrame.js","sourceRoot":"","sources":["../../../../src/lib/memory/RecordFrame.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RecordFrame — the record half of one stage's frame (C3, L3).\n *\n * What a stage's frame needs to READ and WRITE the record, and nothing about the stage inside a run:\n * where it writes (its address), what it read first (the first-touch base), what it staged (the lazy\n * transaction buffer) and which of it the log must not show (the scrub of each write), which keys it\n * read (the readKeys list), and where a commit lands (live state, the redacted mirror, the log —\n * through `recordCommit`). The engine's frame (`StageContext`, L4) composes one and keeps the rest:\n * retention, diagnostics, the dev-mode warnings, the commit observer and the redaction DECISION —\n * which value is secret (`redaction.ts · decideWrite`); the frame writes the bytes it is handed (C4).\n *\n * THE LAW:\n *   1. ADDRESS. The frame reads and writes at its address, a path prefix the engine computed and hands\n *      over as data (C2: `['runs', <id>]` or `[]`, the root). It moves only before the first write:\n *      the buffer keeps the address it was built at (the engine refuses a later move).\n *   2. FIRST TOUCH. The committed generation the frame first touched — its first read OR first write —\n *      is held by reference, never cloned: the read view before the first write and the buffer's\n *      net-change diff base after it.\n *   3. TWO TIERS. A read is served from the stage's own view (the buffer's working copy once the stage\n *      wrote, else the first-touch base); a key absent there is served from LIVE state (at the\n *      address, then the root). After the first write the buffer's diff base is first given a private\n *      copy at that path (`TransactionBuffer · detachBase`).\n *   4. LAZY BUFFER. The buffer is built at the first write — on the first-touch base, at the address,\n *      under the encoding. A frame that never writes builds none, and its commit is the empty bundle.\n *   5. READ KEYS. Under `writeProvenance: 'reads-prefix'` every noted read puts its user-level key\n *      (dotted for a nested path) on the frame's list, once, in order; each staged row carries a copy\n *      of the list as it stands when the row is staged.\n *   6. COMMIT, RELEASE, DISCARD. `commit` takes the buffer's payload (none = the empty commit), then\n *      the names, and hands both to `recordCommit`. `release` drops the buffer and the base; a frame\n *      touched again re-anchors on the state as it stands then. The readKeys list survives a release,\n *      and goes with `discard` (a failed attempt never happened).\n *   7. WRITE. `write(path, value, verb, scrub?)` is the one way to stage: `set`, `merge` or `delete`\n *      at an absolute path (the address already joined — `at`), with the bytes of a redaction\n *      verdict. `whole` → the log and the mirror carry `LOG_PLACEHOLDER` at the path; `fields` → at\n *      each field inside the value (a literal key and, when dotted, the nested path) — wherever it\n *      holds a value at commit (`scrub.ts`). No scrub → the value as it is. The frame never decides\n *      a scrub, and nothing outside it reaches its buffer.\n */\n\nimport type { OpVerb } from './deltaEncoding.js';\nimport type { EventLog } from './EventLog.js';\nimport { nativeGet } from './pathOps.js';\nimport { type CommitStamp, recordCommit } from './recordCommit.js';\nimport type { SharedMemory } from './SharedMemory.js';\nimport { TransactionBuffer } from './TransactionBuffer.js';\nimport type { CommitValuesMode, WriteProvenanceMode } from './types.js';\n\n/**\n * The two dials that shape a frame's bytes: the log's value encoding and the per-row read prefix.\n * Held by reference and swapped whole (`useEncoding`), never edited — the engine hands the run's\n * frozen policy itself. Absent: `'full'` values and no read prefix.\n */\nexport interface RecordEncoding {\n  readonly commitValues: CommitValuesMode;\n  readonly writeProvenance: WriteProvenanceMode;\n}\n\n/**\n * What a stage can stage (law 7) — the transaction buffer's op verbs (`deltaEncoding.ts · OpVerb`), one\n * union. `append` is not one: it is how the log encodes a grown array (`'delta'`).\n */\nexport type WriteVerb = OpVerb;\n\n/**\n * The bytes of a redaction verdict for one write (law 7): which of it the commit log and the redacted\n * mirror must not show. The engine decides it (`redaction.ts · decideWrite`); the frame only writes it.\n */\nexport interface WriteScrub {\n  /** The whole value: `LOG_PLACEHOLDER` at the write's path. */\n  readonly whole?: boolean;\n  /** Dot-paths INSIDE the value, relative to it: `LOG_PLACEHOLDER` at each one that holds a value. */\n  readonly fields?: readonly string[];\n}\n\nexport class RecordFrame {\n  /** Live committed state — the heap every frame of the run shares. */\n  readonly state: SharedMemory;\n  /** The log the frame's commits land on, when the run keeps one. */\n  readonly log?: EventLog;\n  /** The redacted mirror the frame's commits land on, when the run keeps one ({@link useMirror}). */\n  private _mirror?: SharedMemory;\n  /** Where the frame reads and writes (law 1). */\n  private _address: readonly string[];\n  /** The two dials (law 4, 5); absent → the record's defaults. */\n  private encoding?: RecordEncoding;\n  /**\n   * The committed generation at the frame's FIRST touch (law 2) — held by REFERENCE, never cloned.\n   * See {@link firstTouch} for the algorithm and the immutability invariant that makes a bare\n   * reference safe.\n   */\n  private base?: Record<string, unknown>;\n  /** The stage's staged writes — built at its first write (law 4), released at commit. */\n  private buffer?: TransactionBuffer;\n  /**\n   * Keys tracked-read so far, in order (law 5) — the source of each staged row's `readKeys`. Only\n   * allocated under `'reads-prefix'`; insertion-ordered (a Set) and monotonic, which is what makes\n   * \"last write's prefix == union\" hold in delta mode.\n   */\n  private readKeys?: Set<string>;\n\n  constructor(state: SharedMemory, log?: EventLog, address: readonly string[] = []) {\n    this.state = state;\n    this.log = log;\n    this._address = address;\n  }\n\n  /** Where the frame reads and writes (law 1). */\n  get address(): readonly string[] {\n    return this._address;\n  }\n\n  /**\n   * Read and write at `address` from now on — before the frame's first write (law 1): the buffer keeps\n   * the address it was built at. The engine's one caller, `StageContext · useAddressOf`, refuses a move\n   * once the frame has staged.\n   */\n  useAddress(address: readonly string[]): void {\n    this._address = address;\n  }\n\n  /** The two dials the frame encodes under from its next buffer and its next read on (law 4, 5). */\n  useEncoding(encoding: RecordEncoding): void {\n    this.encoding = encoding;\n  }\n\n  /** The redacted mirror, if the run keeps one. */\n  get mirror(): SharedMemory | undefined {\n    return this._mirror;\n  }\n\n  /** Land every commit from now on on `mirror` too, with the scrubbed rows the log takes (`recordCommit`). */\n  useMirror(mirror: SharedMemory | undefined): void {\n    this._mirror = mirror;\n  }\n\n  /** The absolute path of `key` under `path`: the frame's address, then the path, then the key. */\n  at(path: readonly string[], key: string): string[] {\n    // Every read and write builds one. The root's is the path and the key; under an address, an\n    // index loop — the double spread `[...address, ...path, key]` costs a third more per call\n    // (as `utils · pathUnder` found for the address and the path).\n    const address = this._address;\n    if (address.length === 0) return [...path, key];\n    const out = new Array<string>(address.length + path.length + 1);\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    out[out.length - 1] = key;\n    return out;\n  }\n\n  /**\n   * ── The first-touch base (#13) ───────────────────────────────────────────\n   *\n   * WHAT: returns the committed shared state as it was at this frame's FIRST touch (first read or\n   * first write), capturing the reference on first call. Serves two consumers: reads before the first\n   * write ({@link read}) and the transaction buffer's diff base ({@link getTransactionBuffer}).\n   *\n   * WHY A BARE REFERENCE IS SAFE — the invariant this rests on: committed state is\n   * immutable-after-swap. Every write to `SharedMemory` builds the NEXT generation and swaps it in\n   * (copy-on-write, 9.29.0: `applyPatch` via `nextGeneration`, and `setValue`/`updateValue` too) — it\n   * copies the root and the containers on each written path, shares the rest, and never edits a\n   * container of the generation a stage captured here. Holding the reference therefore gives this\n   * stage a stable snapshot at zero cost — no clone, which is the entire point of #13. The transaction\n   * buffer's net-change diff base rests on the same guarantee: it IS this view.\n   *\n   * WHY FIRST TOUCH, not first write: the pre-#13 eager engine cloned the state into the buffer at\n   * the stage's first ACCESS, anchoring both its snapshot reads and its commit baseline (the\n   * net-change diff base) there. #13's first cut anchored the lazy buffer at first WRITE — observably\n   * different when something else commits in the gap between this stage's first read and its first\n   * write. That gap is REACHABLE: fork siblings are namespace-isolated for run-scoped keys (each child\n   * writes under `runs/<childId>/`), but ROOT-level keys are shared — written via `setGlobal` from\n   * consumer scope code and, critically, by `SubflowInputMapper`'s output mapping\n   * (`parentContext.setGlobal`), which is exactly what runs when a subflow is a fork branch. A\n   * sibling's root-key commit landing in the gap would shift this stage's diff base, making its\n   * CommitBundle record a phantom change (or swallow a real one) relative to the eager engine.\n   * Anchoring the view at first touch restores the EXACT eager semantics — sequential AND parallel —\n   * at zero clone cost.\n   *\n   * Read visibility is two-tier, matching eager byte-for-byte: keys present in the view at first\n   * touch read repeatably from it; keys ABSENT from it fall back to LIVE state (the eager engine's\n   * exact fallback — a mid-flight sibling root-key write was always visible to reads, and stays\n   * visible; only the DIFF BASE is pinned).\n   */\n  private firstTouch(): Record<string, unknown> {\n    if (!this.base) {\n      this.base = this.state.getState();\n    }\n    return this.base;\n  }\n\n  /**\n   * The transaction buffer, created lazily on the frame's FIRST WRITE (#13).\n   *\n   * Reads NEVER construct it: read-your-writes only matters once a staged write exists, so before that\n   * {@link read} serves from the first-touch base and {@link commit} records an empty bundle — all with\n   * ZERO `structuredClone`s of the shared state.\n   *\n   * The buffer's base is the FIRST-TOUCH view, NOT the live state at write time: under parallel forks\n   * a sibling may have committed between this frame's first read and this write, and the net-change\n   * diff base must stay anchored at first touch to match the eager engine — see {@link firstTouch}.\n   *\n   * Private since C4: every write goes through {@link write}, so the scrub travels with the op.\n   */\n  private getTransactionBuffer(): TransactionBuffer {\n    if (!this.buffer) {\n      // Per-write provenance (#P1): hand the buffer a live view of this frame's read prefix —\n      // evaluated AT EACH WRITE, so each staged op captures exactly the reads that preceded it.\n      const readKeysProvider =\n        this.encoding?.writeProvenance === 'reads-prefix' ? () => [...(this.readKeys ?? [])] : undefined;\n      // The frame's address (9.30.0: the admitted record reads the containers there as where the\n      // stage writes, never as a value it read).\n      this.buffer = new TransactionBuffer(\n        this.firstTouch(),\n        this.encoding?.commitValues,\n        readKeysProvider,\n        this._address,\n      );\n    }\n    return this.buffer;\n  }\n\n  /**\n   * Stage one write (law 7): `verb` at `path` — an absolute path, the address already joined\n   * ({@link at}) — and the bytes of its redaction verdict. The first write builds the buffer (law 4).\n   *\n   * The scrub registers paths, never values: `whole` marks the op's own path, `fields` each field\n   * inside the value (a literal key and, when dotted, the nested path); `recordCommit` puts the\n   * log's placeholder wherever one of them holds a value at commit, for the mirror and the log only\n   * (`scrub.ts`). Live state takes the value as it is. A path marked by a write that the net-change\n   * filter drops goes with it.\n   */\n  write(path: (string | number)[], value: unknown, verb: WriteVerb, scrub?: WriteScrub): void {\n    const buffer = this.getTransactionBuffer();\n    const whole = scrub?.whole === true;\n    if (verb === 'merge') buffer.merge(path, value, whole);\n    else if (verb === 'delete') buffer.delete(path, whole);\n    else buffer.set(path, value, whole);\n    if (scrub?.fields !== undefined) buffer.markRedactedFields(path, scrub.fields);\n  }\n\n  /** Has the frame staged a write since its last release — does its buffer exist? */\n  get hasStaged(): boolean {\n    return this.buffer !== undefined;\n  }\n\n  /**\n   * The frame's read, mirroring the eager engine's read order byte-for-byte (law 3):\n   *\n   *    1. staged writes + first-touch snapshot — `buffer.get` over its workingCopy when the buffer\n   *       exists, else `nativeGet` over the zero-clone first-touch base (the buffer's base IS that\n   *       view, so the two tiers agree on content);\n   *    2. LIVE state via `SharedMemory · getValue` for keys absent from the snapshot — including its\n   *       address→root fallback. The eager engine had this exact live fallback for snapshot-missing\n   *       keys; byte-identity over purity. After the frame's first write such a value can be the very\n   *       container the buffer's diff base holds at the path (the stage deleted or unset it, or\n   *       replaced a container above it), so the base is detached there first\n   *       (`TransactionBuffer · detachBase`): an in-place edit of the value (out of contract) written\n   *       back is recorded, as on 9.28.0, whose base was a clone taken at the first write.\n   *\n   * Reads never construct the buffer (#13): a frame that never writes performs zero clones of the\n   * shared state.\n   */\n  read(path: string[], key?: string): unknown {\n    const at = this.at(path, key as string);\n    const fromSnapshot = this.buffer ? this.buffer.get(at) : nativeGet(this.firstTouch(), at);\n    if (typeof fromSnapshot !== 'undefined') return fromSnapshot;\n    const live = this.state.getValue(this._address, path, key);\n    // Tier 2 after the first write: keep the diff base exact (see above).\n    if (this.buffer && live !== null && typeof live === 'object') this.buffer.detachBase(at);\n    return live;\n  }\n\n  /** Put a tracked read's user-level key on the readKeys list (law 5) — a no-op unless the frame keeps one. */\n  noteRead(path: readonly string[], key: string): void {\n    if (this.encoding?.writeProvenance === 'reads-prefix') {\n      (this.readKeys ??= new Set()).add(path.length > 0 ? [...path, key].join('.') : key);\n    }\n  }\n\n  /**\n   * Live committed state at `key`: at the frame's address, else at the root — never the stage's own\n   * view. Typed as `SharedMemory · getValue` types it, which `StageContext · getRoot` hands on.\n   */\n  readLive(key: string) {\n    return this.state.getValue(this._address, [], key);\n  }\n\n  /** Live committed state at `key` at the root — typed as `SharedMemory · getValue` (`StageContext · getGlobal`). */\n  readGlobal(key: string) {\n    return this.state.getValue([], [], key);\n  }\n\n  /** Did a staged op touch `path` — on it, above it or below it? (A report's question; never the hot path.) */\n  wasStaged(path: (string | number)[]): boolean {\n    return this.buffer !== undefined && this.buffer.wasStaged(path);\n  }\n\n  /**\n   * The value at `path` in what the stage has seen — its working copy once it wrote, else its\n   * first-touch base — WITHOUT taking a private copy: for a report that only compares.\n   */\n  peek(path: (string | number)[]): unknown {\n    return this.buffer ? this.buffer.peek(path) : nativeGet(this.firstTouch(), path);\n  }\n\n  /** The value at `path` in the first-touch base — committed state as the frame first touched it. */\n  baseAt(path: (string | number)[]): unknown {\n    return nativeGet(this.firstTouch(), path);\n  }\n\n  /**\n   * Record what the frame staged (law 6): the buffer's payload first — none, the empty commit, when\n   * it staged nothing (#13: zero clones) — then the names (`stampOf()`), read once the payload is\n   * built, and both to `recordCommit`. User code can run while the payload is built (a getter on a\n   * staged value, which the net-change compare and the clone invoke); what it adds to the names —\n   * an untracked read, say — is on the bundle.\n   */\n  commit(stampOf: () => CommitStamp): void {\n    const payload = this.buffer?.commit();\n    recordCommit(payload, stampOf(), { state: this.state, mirror: this._mirror, log: this.log });\n  }\n\n  /**\n   * End the frame's hold on state (#13b, law 6): drop the buffer (its working copy and whatever private\n   * copies its reads took) and the first-touch base (a reference that pins one committed-state\n   * GENERATION). Both re-create lazily: a later read re-anchors on the CURRENT committed state, and a\n   * later write builds a fresh buffer on it — so a second commit diffs against the state after the\n   * first. Without the release, the execution tree — which retains every frame for the lifetime of\n   * the run — retains one state generation per executed stage (measured O(N²) before copy-on-write;\n   * a 500-iteration agent OOMed a default Node heap, backlog #18).\n   */\n  release(): void {\n    this.buffer = undefined;\n    this.base = undefined;\n  }\n\n  /**\n   * Throw away everything the frame staged and read (law 6): the buffer, the first-touch base (the next\n   * attempt re-anchors on committed state as it stands NOW) and the readKeys list — a discarded\n   * attempt's reads must never reach the next attempt's `TraceEntry.readKeys`, or a backward slice\n   * would follow an edge that no committed write ever had. Nothing is recorded.\n   */\n  discard(): void {\n    this.release();\n    this.readKeys = undefined;\n  }\n}\n"]}

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

@@ -3,7 +3,7 @@
  *
  * Like a runtime heap with namespace isolation:
  * - 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
+ *   (C2: the engine's frame decides it, `runAddress.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

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

@@ -3,7 +3,7 @@
  *
  * Like a runtime heap with namespace isolation:
  * - 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
+ *   (C2: the engine's frame decides it, `runAddress.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
@@ -79,4 +79,4 @@ export class SharedMemory {
         this.context = nextGeneration(this.context, updates, overwrite, trace);
     }
 }
-//# 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 * - A value is written at an ADDRESS — a path prefix the caller computed\n *   (C2: the engine's frame decides it, `StageContext.ts · runAddress`) — and read\n *   there first, then at the root\n * - Default values seed the root, and the container at an address when a\n *   write creates it\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  /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */\n  updateValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    updateNestedValue(next, address, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */\n  setValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    setNestedValue(next, address, 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(address: readonly 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(address, path);\n    ownSpine(root, [...(runPath || globalPath), key], owned);\n    return root;\n  }\n\n  /**\n   * Reads a value from the store.\n   * Looks up at `address` first, falls back to the root.\n   */\n  getValue(address?: readonly string[], path?: string[], key?: string): any {\n    const { globalPath, runPath } = getRunAndGlobalPaths(address, 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SharedMemory.js","sourceRoot":"","sources":["../../../../src/lib/memory/SharedMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAErH,MAAM,OAAO,YAAY;IACf,OAAO,GAA2B,EAAE,CAAC;IACrC,cAAc,CAAW;IAEjC,YAAY,aAAuB,EAAE,cAAwB;QAC3D,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,MAAM,IAAI,GAAG,gBAAgB,CAAC,cAAc,IAAI,EAAE,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,uEAAuE;QACvE,wEAAwE;QACxE,mEAAmE;QACnE,4DAA4D;QAC5D,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7E,CAAC;IAED,0CAA0C;IAC1C,gBAAgB;QACd,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChF,CAAC;IAED,2GAA2G;IAC3G,WAAW,CAAC,OAA0B,EAAE,IAAc,EAAE,GAAW,EAAE,KAAc;QACjF,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAClD,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,4GAA4G;IAC5G,QAAQ,CAAC,OAA0B,EAAE,IAAc,EAAE,GAAW,EAAE,KAAc;QAC9E,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAClD,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACzE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,OAA0B,EAAE,IAAc,EAAE,GAAW;QACzE,MAAM,KAAK,GAAG,IAAI,OAAO,EAAU,CAAC;QACpC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC9C,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACpE,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,OAA2B,EAAE,IAAe,EAAE,GAAY;QACjE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACpE,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/E,OAAO,OAAO,KAAK,KAAK,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAC9F,CAAC;IAED,sGAAsG;IACtG,QAAQ;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,kGAAkG;IAClG,UAAU,CAAC,SAAsB,EAAE,OAAoB,EAAE,KAAmB;QAC1E,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;CACF","sourcesContent":["/**\n * SharedMemory — The shared state container for all flowchart execution\n *\n * Like a runtime heap with namespace isolation:\n * - A value is written at an ADDRESS — a path prefix the caller computed\n *   (C2: the engine's frame decides it, `runAddress.ts · runAddress`) — and read\n *   there first, then at the root\n * - Default values seed the root, and the container at an address when a\n *   write creates it\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  /** Updates a value at `address` + `path` using merge semantics, as a new generation (path copy + swap). */\n  updateValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    updateNestedValue(next, address, path, key, value, this.getDefaultValues());\n    this.context = next;\n  }\n\n  /** Sets a value at `address` + `path` using overwrite semantics, as a new generation (path copy + swap). */\n  setValue(address: readonly string[], path: string[], key: string, value: unknown) {\n    const next = this.ownedPathTo(address, path, key);\n    setNestedValue(next, address, 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(address: readonly 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(address, path);\n    ownSpine(root, [...(runPath || globalPath), key], owned);\n    return root;\n  }\n\n  /**\n   * Reads a value from the store.\n   * Looks up at `address` first, falls back to the root.\n   */\n  getValue(address?: readonly string[], path?: string[], key?: string): any {\n    const { globalPath, runPath } = getRunAndGlobalPaths(address, 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"]}