footprintjs 9.46.0 → 9.47.0

package/dist/esm/trace.js

@@ -47,9 +47,10 @@ export { walkSubflowSpec } from './lib/engine/walkSubflowSpec.js';
 export { pathSegments } from './lib/memory/utils.js';
 // The refusal the commit-log readers raise for a row whose verb is not
 // set | merge | append | delete (`commitValueAt`, `arrayProvenance`, and
-// `applySmartMerge` on `/advanced`): a foreign or corrupted log fails loudly,
+// `applySmartMerge` below): a foreign or corrupted log fails loudly,
 // naming the row, instead of being folded as a merge.
 export { UnknownVerbError } from './lib/memory/index.js';
+export { applySmartMerge } from './lib/memory/verbs.js';
 export { buildCommitIndex, commitIndexOf, commitValueAt, commitValueAtWithBasis, findCommit, findCommits, findLastWriter, findLastWriterWithBasis, 
 // One stage, one record (F8, 9.39.0): does a log record its continuations
 // (`CommitBundle.phase`), and — for a log written before it — the ONE legacy
@@ -72,4 +73,4 @@ export { InOutRecorder, inOutRecorder, ROOT_RUNTIME_STAGE_ID, ROOT_SUBFLOW_ID }
 export { ControlDepRecorder, controlDepRecorder } from './lib/recorder/ControlDepRecorder.js';
 export { QualityRecorder } from './lib/recorder/QualityRecorder.js';
 export { formatQualityTrace, qualityTrace } from './lib/recorder/qualityTrace.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,YAAY,GACb,MAAM,6BAA6B,CAAC;AAErC,6EAA6E;AAC7E,6EAA6E;AAC7E,gFAAgF;AAChF,gFAAgF;AAChF,wEAAwE;AACxE,wDAAwD;AACxD,4CAA4C;AAC5C,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,6EAA6E;AAC7E,+EAA+E;AAC/E,yEAAyE;AACzE,8EAA8E;AAC9E,oEAAoE;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,uEAAuE;AACvE,yEAAyE;AACzE,8EAA8E;AAC9E,sDAAsD;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAazD,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,UAAU,EACV,WAAW,EACX,cAAc,EACd,uBAAuB;AACvB,0EAA0E;AAC1E,6EAA6E;AAC7E,8CAA8C;AAC9C,iBAAiB,EACjB,aAAa,GACd,MAAM,gCAAgC,CAAC;AA0CxC,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,SAAS,EACT,OAAO,EACP,QAAQ,EACR,UAAU,GACX,MAAM,4BAA4B,CAAC;AAepC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AA2C7F,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAa9B,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,mEAAmE;AACnE,iEAAiE;AACjE,iEAAiE;AACjE,4CAA4C;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAShE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAUtE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAKxF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAOvH,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAI9F,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAIpE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC","sourcesContent":["/**\n * footprintjs/trace — Execution tracing, debugging, and backtracking utilities.\n *\n * Runtime stage IDs, commit log queries, and recorder base classes.\n *\n * @example\n * ```typescript\n * import { parseRuntimeStageId, findLastWriter, KeyedStore, SequenceStore } from 'footprintjs/trace';\n *\n * // Parse a runtimeStageId\n * const { stageId, executionIndex } = parseRuntimeStageId('call-llm#5');\n *\n * // Backtrack: who wrote 'systemPrompt' before commit at idx 8?\n * const writer = findLastWriter(commitLog, 'systemPrompt', 8);\n *\n * // v5 primary API: compose a Store as a field (one purpose per recorder).\n * // KeyedStore<T> — 1:1 (one entry per step)\n * class MyRecorder {\n *   readonly id = 'my-recorder';\n *   private store = new KeyedStore<MyEntry>();\n *   onWrite(e) { this.store.set(e.runtimeStageId, { ... }); }\n * }\n *\n * // SequenceStore<T> — 1:N (multiple entries per step, ordering matters)\n * class AuditRecorder {\n *   readonly id = 'audit';\n *   private store = new SequenceStore<AuditEntry>();\n *   onRead(e) { this.store.push({ runtimeStageId: e.runtimeStageId, ... }); }\n * }\n * ```\n */\n\n// Runtime stage ID — unique execution step identifiers\nexport type { CommitIdx, ExecutionCounter, ExecutionIndex, RuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport {\n  buildRuntimeStageId,\n  createExecutionCounter,\n  parseRuntimeStageId,\n  splitStageId,\n} from './lib/ids/runtimeStageId.js';\n\n// Generated branch segments — the subflow path segments `addParallelForEach`\n// mints for its branches (`<stageId>~<index>`). A branch is addressed by the\n// ORDINARY grammar above, so nothing here is needed to READ one; these exist so\n// a consumer can TELL a generated branch from a hand-authored subflow (to label\n// it \"branch 2 of review-chunks\" instead of a subflow name), and so the\n// reserved marker is discoverable rather than folklore.\n// Design: docs/design/execution-control.md.\nexport {\n  BRANCH_SEGMENT_MARKER,\n  buildBranchSegment,\n  hasBranchSegmentMarker,\n  isBranchSegment,\n  parseBranchSegment,\n} from './lib/ids/branchSegment.js';\n\n// walkSubflowSpec — flat ordered traversal of a subflow's structure\n// (consume via StructureRecorder.onSubflowMounted's subflowSpec payload)\nexport type { WalkerItem, WalkerOptions } from './lib/engine/walkSubflowSpec.js';\nexport { walkSubflowSpec } from './lib/engine/walkSubflowSpec.js';\n\n// Path segments — the supported way to take a `TraceEntry.path` apart. Paths\n// are joined with an ASCII Unit-Separator (never a dot: a state key may itself\n// contain a dot, so a dot separator would make `['a.b']` and `['a','b']`\n// indistinguishable), which is an encoding, not a display character. Render a\n// path through this instead of splitting on the delimiter yourself.\nexport { pathSegments } from './lib/memory/utils.js';\n\n// The refusal the commit-log readers raise for a row whose verb is not\n// set | merge | append | delete (`commitValueAt`, `arrayProvenance`, and\n// `applySmartMerge` on `/advanced`): a foreign or corrupted log fails loudly,\n// naming the row, instead of being folded as a merge.\nexport { UnknownVerbError } from './lib/memory/index.js';\n\n// Commit log queries — typed utilities for backtracking.\n// commitValueAt reconstructs the FULL value of a key at a commit index —\n// required under `commitValues: 'delta'` (#13c-B), where an `append`\n// bundle's `overwrite[key]` holds only the tail.\nexport type {\n  ValueBasis,\n  ValueBasisOptions,\n  ValueWithBasis,\n  WriterBasis,\n  WriterWithBasis,\n} from './lib/memory/commitLogUtils.js';\nexport {\n  buildCommitIndex,\n  commitIndexOf,\n  commitValueAt,\n  commitValueAtWithBasis,\n  findCommit,\n  findCommits,\n  findLastWriter,\n  findLastWriterWithBasis,\n  // One stage, one record (F8, 9.39.0): does a log record its continuations\n  // (`CommitBundle.phase`), and — for a log written before it — the ONE legacy\n  // reader that infers them the way 9.38.0 did.\n  inferLegacyPhases,\n  recordsPhases,\n} from './lib/memory/commitLogUtils.js';\nexport type { CommitPhase } from './lib/memory/types.js';\n\n// ── time-travel/ — the READER'S cursor over a finished trace ──────────────\n// A Trace is what the run recorded; time travel is a cursor over it with a\n// Fold at each stop. It is NOT the engine's walk and never becomes a second\n// live cursor: everything below is a read-time query over already-collected\n// data.\n//\n// `stateAt(snapshot | subtree, commitIdx)` is the fold — the run's\n// `initialState` replayed through `commitLog[0..commitIdx]` with the SAME verb\n// switch the live commit uses, returned detached and frozen, and honest about\n// how it was derived (`basis`) and where the log was scrubbed (`redacted`).\n//\n// `timeTravel(snapshot)` is the cursor: stops, prev/next/jumpTo, marks beside\n// the log, and `drill(mount)` into a subflow's own log — the same interface,\n// its own base. How stops are DERIVED is the seam (`TimeTravelStrategy`);\n// footprintjs ships `commitStops` (one stop per executed stage) because that\n// is the only stop grammar the substrate itself knows — and, since 9.21.0,\n// `tagStops(tags?)`: the stops a chart DECLARED at build time (`.tag()`),\n// read back off `CommitBundle.tags`, so a stored recording scrubs by its own\n// milestones with no id conventions in the reader.\n// See src/lib/time-travel/README.md.\nexport type {\n  AxisRefusal,\n  AxisSplit,\n  BookendedAxis,\n  FoldBasis,\n  FoldedState,\n  FoldSource,\n  LogGap,\n  Mark,\n  Move,\n  MoveRefusal,\n  Stop,\n  StopFilter,\n  StopKind,\n  TimeTravel,\n  TimeTravelOptions,\n  TimeTravelSource,\n  TimeTravelStrategy,\n} from './lib/time-travel/index.js';\nexport {\n  commitStops,\n  commitStopsStrategy,\n  filterStops,\n  isCommitBundle,\n  splitAxis,\n  stateAt,\n  tagStops,\n  timeTravel,\n} from './lib/time-travel/index.js';\n\n// Causal chain — backward program slicing on commit log (DAG).\n// RFC-003 D3: `CausalEdge` (typed/keyed/weighted parent links on\n// `CausalNode.parentEdges`) + the `controlDeps` option (`ControlDepLookup`)\n// add control-dependence edges to the slice.\nexport type {\n  CausalChainOptions,\n  CausalEdge,\n  CausalNode,\n  ControlDependency,\n  ControlDepLookup,\n  EdgeWeigher,\n  KeysReadLookup,\n} from './lib/memory/backtrack.js';\nexport { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/backtrack.js';\n// RFC-003 D2 — honesty markers: the untracked read paths a stage consumed\n// (`CommitBundle.untrackedSources` → `CausalNode.incompleteSources`).\nexport type { UntrackedSource } from './lib/memory/types.js';\n\n// ── slice/ — variable-first slicing, both directions (triage query layer) ──\n// One contract for every triage surface (UI panel, LLM tool, offline\n// autopsy agent): variable in → slice out.\n//\n// BACKWARD — `sliceForKey` anchors at the key's last writer then delegates\n// to causalChain; `arrayProvenance` / `elementProvenance` (append-fold)\n// answer element-level questions like \"which stage produced history[7]?\" —\n// the fix for the agent mega-key problem, with honest attribution labels.\n//\n// FORWARD — `forwardSliceForKey` walks the other way: from a write, through\n// the value's LIVE RANGE (it lives until the key's next write), to every\n// stage that read it and every write those reads fed. `keyTimeline` is the\n// flat chronological view of the same facts. Fed edges are EXACT under the\n// `writeProvenance: 'reads-prefix'` dial and stamped CONSERVATIVE without\n// it — never the other way round. See src/lib/slice/README.md.\nexport type {\n  ArrayProvenance,\n  AttributionBasis,\n  ElementBirth,\n  FedBasis,\n  ForwardEdge,\n  ForwardNode,\n  ForwardRead,\n  ForwardSlice,\n  ForwardSliceJSON,\n  HonestyNote,\n  HonestyNoteCode,\n  KeyMoment,\n  KeysReadSource,\n  KeyTimeline,\n  MissingProvenanceReason,\n  MissingSliceReason,\n  ReadsCoverage,\n  SliceJSON,\n  StateKey,\n  VariableSlice,\n} from './lib/slice/index.js';\nexport type { ForwardSliceForKeyOptions, KeyTimelineOptions, SliceForKeyOptions } from './lib/slice/index.js';\nexport {\n  arrayProvenance,\n  elementProvenance,\n  formatForwardSlice,\n  formatSlice,\n  formatTimeline,\n  forwardSliceForKey,\n  forwardSliceToJSON,\n  keysReadFromExecutionTree,\n  keysReadFromMap,\n  keyTimeline,\n  normaliseStateKey,\n  resolveKeysReadSource,\n  sliceForKey,\n  sliceToJSON,\n} from './lib/slice/index.js';\n\n// ── honesty — the ONE registry of what a reader cannot see ─────────────────\n// The honesty signals this door's readers produce — a slice's `HonestyNote.code` and `missing`\n// reason, a fed edge's and an element birth's `basis`, a fold's `basis` and `redacted` paths, a\n// `LogGap`, a causal node's `incompleteSources` and `truncated` — each has a code here and the ONE\n// sentence that says what it means, so a lens or an agent tool explains any of them from one place\n// instead of keeping its own table. The unions of those codes exported above (`HonestyNoteCode`,\n// `MissingSliceReason`, `MissingProvenanceReason`, `FedBasis`, `AttributionBasis`, `FoldBasis`) are\n// subsets of `HonestyCode`, and test/architecture/honesty-vocabulary.test.ts fails on a union of\n// string literals this door exports that is neither registered nor named there as a different kind\n// of word. See src/lib/memory/README.md.\nexport type { HonestyCode } from './lib/memory/index.js';\nexport { HONESTY_CODES } from './lib/memory/index.js';\n\n// ── v5 Stores (concrete, composable — primary recorder API) ─────\n// Compose these via `new Store<T>()` as a field on your recorder\n// class. One purpose per recorder: stores are storage; recorders\n// are event-hook interface implementations.\nexport { BoundaryStateStore } from './lib/recorder/BoundaryStateStore.js';\nexport { KeyedStore } from './lib/recorder/KeyedStore.js';\nexport { SequenceStore } from './lib/recorder/SequenceStore.js';\n\n// ── v5.1 Commit grouping primitive ──────────────────────────────\n// Interval index over commit indices. Built incrementally during\n// traversal: open() on boundary entry, close() on exit. Query at any\n// commit position with enclosing()/overlapping(). Generic over TLabel\n// — footprintjs owns ZERO knowledge of what consumers use as labels.\n// See docs/design/commit-range-index.md for the full contract.\nexport type { RangeEntry, RangeToken } from './lib/recorder/CommitRangeIndex.js';\nexport { CommitRangeIndex } from './lib/recorder/CommitRangeIndex.js';\n\n// TopologyRecorder — composition graph accumulator (subflows + control-flow edges)\nexport type {\n  Topology,\n  TopologyEdge,\n  TopologyIncomingKind,\n  TopologyNode,\n  TopologyRecorderOptions,\n} from './lib/recorder/TopologyRecorder.js';\nexport { TopologyRecorder, topologyRecorder } from './lib/recorder/TopologyRecorder.js';\n\n// InOutRecorder — chart in/out stream (entry/exit pairs at every chart boundary,\n// including the top-level run and every subflow)\nexport type { InOutEntry, InOutPhase, InOutRecorderOptions } from './lib/recorder/InOutRecorder.js';\nexport { InOutRecorder, inOutRecorder, ROOT_RUNTIME_STAGE_ID, ROOT_SUBFLOW_ID } from './lib/recorder/InOutRecorder.js';\n\n// ControlDepRecorder — control-dependence tracking (RFC-003 D5): records\n// onDecision/onSelected + the D1 runtime ancestor chain, answers \"which\n// decision allowed this stage to run?\" — the built-in producer for\n// causalChain's `controlDeps` option.\nexport type { ControlDecisionRecord, ControlDepRecorderOptions } from './lib/recorder/ControlDepRecorder.js';\nexport { ControlDepRecorder, controlDepRecorder } from './lib/recorder/ControlDepRecorder.js';\n\n// QualityRecorder — per-step quality scoring with backtracking\nexport type { QualityEntry, QualityRecorderOptions, QualityScoringFn } from './lib/recorder/QualityRecorder.js';\nexport { QualityRecorder } from './lib/recorder/QualityRecorder.js';\n\n// qualityTrace — Quality Stack Trace (backtrack from low-scoring steps)\nexport type { QualityFrame, QualityStackTrace } from './lib/recorder/qualityTrace.js';\nexport { formatQualityTrace, qualityTrace } from './lib/recorder/qualityTrace.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,YAAY,GACb,MAAM,6BAA6B,CAAC;AAErC,6EAA6E;AAC7E,6EAA6E;AAC7E,gFAAgF;AAChF,gFAAgF;AAChF,wEAAwE;AACxE,wDAAwD;AACxD,4CAA4C;AAC5C,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AAKpC,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,6EAA6E;AAC7E,+EAA+E;AAC/E,yEAAyE;AACzE,8EAA8E;AAC9E,oEAAoE;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,uEAAuE;AACvE,yEAAyE;AACzE,qEAAqE;AACrE,sDAAsD;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAQzD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAaxD,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,UAAU,EACV,WAAW,EACX,cAAc,EACd,uBAAuB;AACvB,0EAA0E;AAC1E,6EAA6E;AAC7E,8CAA8C;AAC9C,iBAAiB,EACjB,aAAa,GACd,MAAM,gCAAgC,CAAC;AA0CxC,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,SAAS,EACT,OAAO,EACP,QAAQ,EACR,UAAU,GACX,MAAM,4BAA4B,CAAC;AAepC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AA2C7F,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAa9B,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,mEAAmE;AACnE,iEAAiE;AACjE,iEAAiE;AACjE,4CAA4C;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAShE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAUtE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAKxF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAOvH,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAI9F,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAIpE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC","sourcesContent":["/**\n * footprintjs/trace — Execution tracing, debugging, and backtracking utilities.\n *\n * Runtime stage IDs, commit log queries, and recorder base classes.\n *\n * @example\n * ```typescript\n * import { parseRuntimeStageId, findLastWriter, KeyedStore, SequenceStore } from 'footprintjs/trace';\n *\n * // Parse a runtimeStageId\n * const { stageId, executionIndex } = parseRuntimeStageId('call-llm#5');\n *\n * // Backtrack: who wrote 'systemPrompt' before commit at idx 8?\n * const writer = findLastWriter(commitLog, 'systemPrompt', 8);\n *\n * // v5 primary API: compose a Store as a field (one purpose per recorder).\n * // KeyedStore<T> — 1:1 (one entry per step)\n * class MyRecorder {\n *   readonly id = 'my-recorder';\n *   private store = new KeyedStore<MyEntry>();\n *   onWrite(e) { this.store.set(e.runtimeStageId, { ... }); }\n * }\n *\n * // SequenceStore<T> — 1:N (multiple entries per step, ordering matters)\n * class AuditRecorder {\n *   readonly id = 'audit';\n *   private store = new SequenceStore<AuditEntry>();\n *   onRead(e) { this.store.push({ runtimeStageId: e.runtimeStageId, ... }); }\n * }\n * ```\n */\n\n// Runtime stage ID — unique execution step identifiers\nexport type { CommitIdx, ExecutionCounter, ExecutionIndex, RuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport {\n  buildRuntimeStageId,\n  createExecutionCounter,\n  parseRuntimeStageId,\n  splitStageId,\n} from './lib/ids/runtimeStageId.js';\n\n// Generated branch segments — the subflow path segments `addParallelForEach`\n// mints for its branches (`<stageId>~<index>`). A branch is addressed by the\n// ORDINARY grammar above, so nothing here is needed to READ one; these exist so\n// a consumer can TELL a generated branch from a hand-authored subflow (to label\n// it \"branch 2 of review-chunks\" instead of a subflow name), and so the\n// reserved marker is discoverable rather than folklore.\n// Design: docs/design/execution-control.md.\nexport {\n  BRANCH_SEGMENT_MARKER,\n  buildBranchSegment,\n  hasBranchSegmentMarker,\n  isBranchSegment,\n  parseBranchSegment,\n} from './lib/ids/branchSegment.js';\n\n// walkSubflowSpec — flat ordered traversal of a subflow's structure\n// (consume via StructureRecorder.onSubflowMounted's subflowSpec payload)\nexport type { WalkerItem, WalkerOptions } from './lib/engine/walkSubflowSpec.js';\nexport { walkSubflowSpec } from './lib/engine/walkSubflowSpec.js';\n\n// Path segments — the supported way to take a `TraceEntry.path` apart. Paths\n// are joined with an ASCII Unit-Separator (never a dot: a state key may itself\n// contain a dot, so a dot separator would make `['a.b']` and `['a','b']`\n// indistinguishable), which is an encoding, not a display character. Render a\n// path through this instead of splitting on the delimiter yourself.\nexport { pathSegments } from './lib/memory/utils.js';\n\n// The refusal the commit-log readers raise for a row whose verb is not\n// set | merge | append | delete (`commitValueAt`, `arrayProvenance`, and\n// `applySmartMerge` below): a foreign or corrupted log fails loudly,\n// naming the row, instead of being folded as a merge.\nexport { UnknownVerbError } from './lib/memory/index.js';\n\n// The record's own shapes — one bundle per executed stage (`CommitBundle`), its\n// rows (`TraceEntry`) and its value patches (`MemoryPatch`) — and the one fold\n// of a bundle onto a state that hands back a fully detached result\n// (`applySmartMerge`, the verb law's public door). Also on `/advanced` until 10.0.0;\n// a record is WRITTEN through `footprintjs/write`. See docs/guides/record-contract.md.\nexport type { CommitBundle, MemoryPatch, TraceEntry } from './lib/memory/types.js';\nexport { applySmartMerge } from './lib/memory/verbs.js';\n\n// Commit log queries — typed utilities for backtracking.\n// commitValueAt reconstructs the FULL value of a key at a commit index —\n// required under `commitValues: 'delta'` (#13c-B), where an `append`\n// bundle's `overwrite[key]` holds only the tail.\nexport type {\n  ValueBasis,\n  ValueBasisOptions,\n  ValueWithBasis,\n  WriterBasis,\n  WriterWithBasis,\n} from './lib/memory/commitLogUtils.js';\nexport {\n  buildCommitIndex,\n  commitIndexOf,\n  commitValueAt,\n  commitValueAtWithBasis,\n  findCommit,\n  findCommits,\n  findLastWriter,\n  findLastWriterWithBasis,\n  // One stage, one record (F8, 9.39.0): does a log record its continuations\n  // (`CommitBundle.phase`), and — for a log written before it — the ONE legacy\n  // reader that infers them the way 9.38.0 did.\n  inferLegacyPhases,\n  recordsPhases,\n} from './lib/memory/commitLogUtils.js';\nexport type { CommitPhase } from './lib/memory/types.js';\n\n// ── time-travel/ — the READER'S cursor over a finished trace ──────────────\n// A Trace is what the run recorded; time travel is a cursor over it with a\n// Fold at each stop. It is NOT the engine's walk and never becomes a second\n// live cursor: everything below is a read-time query over already-collected\n// data.\n//\n// `stateAt(snapshot | subtree, commitIdx)` is the fold — the run's\n// `initialState` replayed through `commitLog[0..commitIdx]` with the SAME verb\n// switch the live commit uses, returned detached and frozen, and honest about\n// how it was derived (`basis`) and where the log was scrubbed (`redacted`).\n//\n// `timeTravel(snapshot)` is the cursor: stops, prev/next/jumpTo, marks beside\n// the log, and `drill(mount)` into a subflow's own log — the same interface,\n// its own base. How stops are DERIVED is the seam (`TimeTravelStrategy`);\n// footprintjs ships `commitStops` (one stop per executed stage) because that\n// is the only stop grammar the substrate itself knows — and, since 9.21.0,\n// `tagStops(tags?)`: the stops a chart DECLARED at build time (`.tag()`),\n// read back off `CommitBundle.tags`, so a stored recording scrubs by its own\n// milestones with no id conventions in the reader.\n// See src/lib/time-travel/README.md.\nexport type {\n  AxisRefusal,\n  AxisSplit,\n  BookendedAxis,\n  FoldBasis,\n  FoldedState,\n  FoldSource,\n  LogGap,\n  Mark,\n  Move,\n  MoveRefusal,\n  Stop,\n  StopFilter,\n  StopKind,\n  TimeTravel,\n  TimeTravelOptions,\n  TimeTravelSource,\n  TimeTravelStrategy,\n} from './lib/time-travel/index.js';\nexport {\n  commitStops,\n  commitStopsStrategy,\n  filterStops,\n  isCommitBundle,\n  splitAxis,\n  stateAt,\n  tagStops,\n  timeTravel,\n} from './lib/time-travel/index.js';\n\n// Causal chain — backward program slicing on commit log (DAG).\n// RFC-003 D3: `CausalEdge` (typed/keyed/weighted parent links on\n// `CausalNode.parentEdges`) + the `controlDeps` option (`ControlDepLookup`)\n// add control-dependence edges to the slice.\nexport type {\n  CausalChainOptions,\n  CausalEdge,\n  CausalNode,\n  ControlDependency,\n  ControlDepLookup,\n  EdgeWeigher,\n  KeysReadLookup,\n} from './lib/memory/backtrack.js';\nexport { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/backtrack.js';\n// RFC-003 D2 — honesty markers: the untracked read paths a stage consumed\n// (`CommitBundle.untrackedSources` → `CausalNode.incompleteSources`).\nexport type { UntrackedSource } from './lib/memory/types.js';\n\n// ── slice/ — variable-first slicing, both directions (triage query layer) ──\n// One contract for every triage surface (UI panel, LLM tool, offline\n// autopsy agent): variable in → slice out.\n//\n// BACKWARD — `sliceForKey` anchors at the key's last writer then delegates\n// to causalChain; `arrayProvenance` / `elementProvenance` (append-fold)\n// answer element-level questions like \"which stage produced history[7]?\" —\n// the fix for the agent mega-key problem, with honest attribution labels.\n//\n// FORWARD — `forwardSliceForKey` walks the other way: from a write, through\n// the value's LIVE RANGE (it lives until the key's next write), to every\n// stage that read it and every write those reads fed. `keyTimeline` is the\n// flat chronological view of the same facts. Fed edges are EXACT under the\n// `writeProvenance: 'reads-prefix'` dial and stamped CONSERVATIVE without\n// it — never the other way round. See src/lib/slice/README.md.\nexport type {\n  ArrayProvenance,\n  AttributionBasis,\n  ElementBirth,\n  FedBasis,\n  ForwardEdge,\n  ForwardNode,\n  ForwardRead,\n  ForwardSlice,\n  ForwardSliceJSON,\n  HonestyNote,\n  HonestyNoteCode,\n  KeyMoment,\n  KeysReadSource,\n  KeyTimeline,\n  MissingProvenanceReason,\n  MissingSliceReason,\n  ReadsCoverage,\n  SliceJSON,\n  StateKey,\n  VariableSlice,\n} from './lib/slice/index.js';\nexport type { ForwardSliceForKeyOptions, KeyTimelineOptions, SliceForKeyOptions } from './lib/slice/index.js';\nexport {\n  arrayProvenance,\n  elementProvenance,\n  formatForwardSlice,\n  formatSlice,\n  formatTimeline,\n  forwardSliceForKey,\n  forwardSliceToJSON,\n  keysReadFromExecutionTree,\n  keysReadFromMap,\n  keyTimeline,\n  normaliseStateKey,\n  resolveKeysReadSource,\n  sliceForKey,\n  sliceToJSON,\n} from './lib/slice/index.js';\n\n// ── honesty — the ONE registry of what a reader cannot see ─────────────────\n// The honesty signals this door's readers produce — a slice's `HonestyNote.code` and `missing`\n// reason, a fed edge's and an element birth's `basis`, a fold's `basis` and `redacted` paths, a\n// `LogGap`, a causal node's `incompleteSources` and `truncated` — each has a code here and the ONE\n// sentence that says what it means, so a lens or an agent tool explains any of them from one place\n// instead of keeping its own table. The unions of those codes exported above (`HonestyNoteCode`,\n// `MissingSliceReason`, `MissingProvenanceReason`, `FedBasis`, `AttributionBasis`, `FoldBasis`) are\n// subsets of `HonestyCode`, and test/architecture/honesty-vocabulary.test.ts fails on a union of\n// string literals this door exports that is neither registered nor named there as a different kind\n// of word. See src/lib/memory/README.md.\nexport type { HonestyCode } from './lib/memory/index.js';\nexport { HONESTY_CODES } from './lib/memory/index.js';\n\n// ── v5 Stores (concrete, composable — primary recorder API) ─────\n// Compose these via `new Store<T>()` as a field on your recorder\n// class. One purpose per recorder: stores are storage; recorders\n// are event-hook interface implementations.\nexport { BoundaryStateStore } from './lib/recorder/BoundaryStateStore.js';\nexport { KeyedStore } from './lib/recorder/KeyedStore.js';\nexport { SequenceStore } from './lib/recorder/SequenceStore.js';\n\n// ── v5.1 Commit grouping primitive ──────────────────────────────\n// Interval index over commit indices. Built incrementally during\n// traversal: open() on boundary entry, close() on exit. Query at any\n// commit position with enclosing()/overlapping(). Generic over TLabel\n// — footprintjs owns ZERO knowledge of what consumers use as labels.\n// See docs/design/commit-range-index.md for the full contract.\nexport type { RangeEntry, RangeToken } from './lib/recorder/CommitRangeIndex.js';\nexport { CommitRangeIndex } from './lib/recorder/CommitRangeIndex.js';\n\n// TopologyRecorder — composition graph accumulator (subflows + control-flow edges)\nexport type {\n  Topology,\n  TopologyEdge,\n  TopologyIncomingKind,\n  TopologyNode,\n  TopologyRecorderOptions,\n} from './lib/recorder/TopologyRecorder.js';\nexport { TopologyRecorder, topologyRecorder } from './lib/recorder/TopologyRecorder.js';\n\n// InOutRecorder — chart in/out stream (entry/exit pairs at every chart boundary,\n// including the top-level run and every subflow)\nexport type { InOutEntry, InOutPhase, InOutRecorderOptions } from './lib/recorder/InOutRecorder.js';\nexport { InOutRecorder, inOutRecorder, ROOT_RUNTIME_STAGE_ID, ROOT_SUBFLOW_ID } from './lib/recorder/InOutRecorder.js';\n\n// ControlDepRecorder — control-dependence tracking (RFC-003 D5): records\n// onDecision/onSelected + the D1 runtime ancestor chain, answers \"which\n// decision allowed this stage to run?\" — the built-in producer for\n// causalChain's `controlDeps` option.\nexport type { ControlDecisionRecord, ControlDepRecorderOptions } from './lib/recorder/ControlDepRecorder.js';\nexport { ControlDepRecorder, controlDepRecorder } from './lib/recorder/ControlDepRecorder.js';\n\n// QualityRecorder — per-step quality scoring with backtracking\nexport type { QualityEntry, QualityRecorderOptions, QualityScoringFn } from './lib/recorder/QualityRecorder.js';\nexport { QualityRecorder } from './lib/recorder/QualityRecorder.js';\n\n// qualityTrace — Quality Stack Trace (backtrack from low-scoring steps)\nexport type { QualityFrame, QualityStackTrace } from './lib/recorder/qualityTrace.js';\nexport { formatQualityTrace, qualityTrace } from './lib/recorder/qualityTrace.js';\n"]}

package/dist/esm/write.d.ts

@@ -0,0 +1,47 @@
+/**
+ * footprintjs/write — the public way to write a record.
+ *
+ * A record is what a run wrote: a frozen base and an append-only log of bundles, one per step
+ * (docs/guides/record-contract.md). This door hands out the classes the engine itself writes one
+ * with — there is no wrapper, so a record written here and one a flowchart wrote come from the same
+ * code and the same bytes:
+ *
+ *   - `SharedMemory` — the heap: live state, one generation per commit (copy-on-write);
+ *   - `EventLog`     — the log: the fold base and the bundles, frozen as they are recorded;
+ *   - `RecordFrame`  — one step's frame: what it read (`read`, `noteRead`), what it staged
+ *                      (`write`, with a redaction verdict's bytes as `WriteScrub`), and its
+ *                      commit onto the heap and the log (`commit`, named by a `CommitStamp`).
+ *
+ * The step's encoding is two dials (`RecordEncoding`): `commitValues` (`'full'` | `'delta'`) and
+ * `writeProvenance` (`'off'` | `'reads-prefix'`, `WriteProvenanceMode`).
+ *
+ * Every type this door names is the record's own: nothing here loads or names the engine
+ * (test/architecture/write-door.test.ts). Its names and the bytes they write are promised under the
+ * record fixtures' re-pin policy (test/fixtures/README.md): a refactor never moves a byte.
+ *
+ * @example
+ * ```typescript
+ * import { EventLog, RecordFrame, SharedMemory } from 'footprintjs/write';
+ * import { stateAt } from 'footprintjs/trace';
+ *
+ * const state = new SharedMemory(undefined, { count: 0 }); // the heap, seeded
+ * const log = new EventLog(state.getState());              // its fold base is the seed
+ *
+ * const frame = new RecordFrame(state, log);               // one step, at the root
+ * frame.useEncoding({ commitValues: 'full', writeProvenance: 'reads-prefix' });
+ * const count = frame.read([], 'count') as number;
+ * frame.noteRead([], 'count');                             // the bundle names the read
+ * frame.write(frame.at([], 'count'), count + 1, 'set');
+ * frame.commit(() => ({ stage: 'Increment', stageId: 'increment', runtimeStageId: 'increment#0' }));
+ *
+ * stateAt({ initialState: log.getInitialState(), commitLog: log.list() }, 0).state; // { count: 1 }
+ * ```
+ *
+ * @module write
+ */
+export { EventLog } from './lib/memory/EventLog.js';
+export { SharedMemory } from './lib/memory/SharedMemory.js';
+export type { CommitStamp } from './lib/memory/recordCommit.js';
+export type { RecordEncoding, WriteScrub, WriteVerb } from './lib/memory/RecordFrame.js';
+export { RecordFrame } from './lib/memory/RecordFrame.js';
+export type { WriteProvenanceMode } from './lib/memory/types.js';

package/dist/esm/write.js

@@ -0,0 +1,46 @@
+/**
+ * footprintjs/write — the public way to write a record.
+ *
+ * A record is what a run wrote: a frozen base and an append-only log of bundles, one per step
+ * (docs/guides/record-contract.md). This door hands out the classes the engine itself writes one
+ * with — there is no wrapper, so a record written here and one a flowchart wrote come from the same
+ * code and the same bytes:
+ *
+ *   - `SharedMemory` — the heap: live state, one generation per commit (copy-on-write);
+ *   - `EventLog`     — the log: the fold base and the bundles, frozen as they are recorded;
+ *   - `RecordFrame`  — one step's frame: what it read (`read`, `noteRead`), what it staged
+ *                      (`write`, with a redaction verdict's bytes as `WriteScrub`), and its
+ *                      commit onto the heap and the log (`commit`, named by a `CommitStamp`).
+ *
+ * The step's encoding is two dials (`RecordEncoding`): `commitValues` (`'full'` | `'delta'`) and
+ * `writeProvenance` (`'off'` | `'reads-prefix'`, `WriteProvenanceMode`).
+ *
+ * Every type this door names is the record's own: nothing here loads or names the engine
+ * (test/architecture/write-door.test.ts). Its names and the bytes they write are promised under the
+ * record fixtures' re-pin policy (test/fixtures/README.md): a refactor never moves a byte.
+ *
+ * @example
+ * ```typescript
+ * import { EventLog, RecordFrame, SharedMemory } from 'footprintjs/write';
+ * import { stateAt } from 'footprintjs/trace';
+ *
+ * const state = new SharedMemory(undefined, { count: 0 }); // the heap, seeded
+ * const log = new EventLog(state.getState());              // its fold base is the seed
+ *
+ * const frame = new RecordFrame(state, log);               // one step, at the root
+ * frame.useEncoding({ commitValues: 'full', writeProvenance: 'reads-prefix' });
+ * const count = frame.read([], 'count') as number;
+ * frame.noteRead([], 'count');                             // the bundle names the read
+ * frame.write(frame.at([], 'count'), count + 1, 'set');
+ * frame.commit(() => ({ stage: 'Increment', stageId: 'increment', runtimeStageId: 'increment#0' }));
+ *
+ * stateAt({ initialState: log.getInitialState(), commitLog: log.list() }, 0).state; // { count: 1 }
+ * ```
+ *
+ * @module write
+ */
+// The heap and the log.
+export { EventLog } from './lib/memory/EventLog.js';
+export { SharedMemory } from './lib/memory/SharedMemory.js';
+export { RecordFrame } from './lib/memory/RecordFrame.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JpdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd3JpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F3Q0c7QUFFSCx3QkFBd0I7QUFDeEIsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUs1RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGZvb3RwcmludGpzL3dyaXRlIOKAlCB0aGUgcHVibGljIHdheSB0byB3cml0ZSBhIHJlY29yZC5cbiAqXG4gKiBBIHJlY29yZCBpcyB3aGF0IGEgcnVuIHdyb3RlOiBhIGZyb3plbiBiYXNlIGFuZCBhbiBhcHBlbmQtb25seSBsb2cgb2YgYnVuZGxlcywgb25lIHBlciBzdGVwXG4gKiAoZG9jcy9ndWlkZXMvcmVjb3JkLWNvbnRyYWN0Lm1kKS4gVGhpcyBkb29yIGhhbmRzIG91dCB0aGUgY2xhc3NlcyB0aGUgZW5naW5lIGl0c2VsZiB3cml0ZXMgb25lXG4gKiB3aXRoIOKAlCB0aGVyZSBpcyBubyB3cmFwcGVyLCBzbyBhIHJlY29yZCB3cml0dGVuIGhlcmUgYW5kIG9uZSBhIGZsb3djaGFydCB3cm90ZSBjb21lIGZyb20gdGhlIHNhbWVcbiAqIGNvZGUgYW5kIHRoZSBzYW1lIGJ5dGVzOlxuICpcbiAqICAgLSBgU2hhcmVkTWVtb3J5YCDigJQgdGhlIGhlYXA6IGxpdmUgc3RhdGUsIG9uZSBnZW5lcmF0aW9uIHBlciBjb21taXQgKGNvcHktb24td3JpdGUpO1xuICogICAtIGBFdmVudExvZ2AgICAgIOKAlCB0aGUgbG9nOiB0aGUgZm9sZCBiYXNlIGFuZCB0aGUgYnVuZGxlcywgZnJvemVuIGFzIHRoZXkgYXJlIHJlY29yZGVkO1xuICogICAtIGBSZWNvcmRGcmFtZWAgIOKAlCBvbmUgc3RlcCdzIGZyYW1lOiB3aGF0IGl0IHJlYWQgKGByZWFkYCwgYG5vdGVSZWFkYCksIHdoYXQgaXQgc3RhZ2VkXG4gKiAgICAgICAgICAgICAgICAgICAgICAoYHdyaXRlYCwgd2l0aCBhIHJlZGFjdGlvbiB2ZXJkaWN0J3MgYnl0ZXMgYXMgYFdyaXRlU2NydWJgKSwgYW5kIGl0c1xuICogICAgICAgICAgICAgICAgICAgICAgY29tbWl0IG9udG8gdGhlIGhlYXAgYW5kIHRoZSBsb2cgKGBjb21taXRgLCBuYW1lZCBieSBhIGBDb21taXRTdGFtcGApLlxuICpcbiAqIFRoZSBzdGVwJ3MgZW5jb2RpbmcgaXMgdHdvIGRpYWxzIChgUmVjb3JkRW5jb2RpbmdgKTogYGNvbW1pdFZhbHVlc2AgKGAnZnVsbCdgIHwgYCdkZWx0YSdgKSBhbmRcbiAqIGB3cml0ZVByb3ZlbmFuY2VgIChgJ29mZidgIHwgYCdyZWFkcy1wcmVmaXgnYCwgYFdyaXRlUHJvdmVuYW5jZU1vZGVgKS5cbiAqXG4gKiBFdmVyeSB0eXBlIHRoaXMgZG9vciBuYW1lcyBpcyB0aGUgcmVjb3JkJ3Mgb3duOiBub3RoaW5nIGhlcmUgbG9hZHMgb3IgbmFtZXMgdGhlIGVuZ2luZVxuICogKHRlc3QvYXJjaGl0ZWN0dXJlL3dyaXRlLWRvb3IudGVzdC50cykuIEl0cyBuYW1lcyBhbmQgdGhlIGJ5dGVzIHRoZXkgd3JpdGUgYXJlIHByb21pc2VkIHVuZGVyIHRoZVxuICogcmVjb3JkIGZpeHR1cmVzJyByZS1waW4gcG9saWN5ICh0ZXN0L2ZpeHR1cmVzL1JFQURNRS5tZCk6IGEgcmVmYWN0b3IgbmV2ZXIgbW92ZXMgYSBieXRlLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpbXBvcnQgeyBFdmVudExvZywgUmVjb3JkRnJhbWUsIFNoYXJlZE1lbW9yeSB9IGZyb20gJ2Zvb3RwcmludGpzL3dyaXRlJztcbiAqIGltcG9ydCB7IHN0YXRlQXQgfSBmcm9tICdmb290cHJpbnRqcy90cmFjZSc7XG4gKlxuICogY29uc3Qgc3RhdGUgPSBuZXcgU2hhcmVkTWVtb3J5KHVuZGVmaW5lZCwgeyBjb3VudDogMCB9KTsgLy8gdGhlIGhlYXAsIHNlZWRlZFxuICogY29uc3QgbG9nID0gbmV3IEV2ZW50TG9nKHN0YXRlLmdldFN0YXRlKCkpOyAgICAgICAgICAgICAgLy8gaXRzIGZvbGQgYmFzZSBpcyB0aGUgc2VlZFxuICpcbiAqIGNvbnN0IGZyYW1lID0gbmV3IFJlY29yZEZyYW1lKHN0YXRlLCBsb2cpOyAgICAgICAgICAgICAgIC8vIG9uZSBzdGVwLCBhdCB0aGUgcm9vdFxuICogZnJhbWUudXNlRW5jb2RpbmcoeyBjb21taXRWYWx1ZXM6ICdmdWxsJywgd3JpdGVQcm92ZW5hbmNlOiAncmVhZHMtcHJlZml4JyB9KTtcbiAqIGNvbnN0IGNvdW50ID0gZnJhbWUucmVhZChbXSwgJ2NvdW50JykgYXMgbnVtYmVyO1xuICogZnJhbWUubm90ZVJlYWQoW10sICdjb3VudCcpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gdGhlIGJ1bmRsZSBuYW1lcyB0aGUgcmVhZFxuICogZnJhbWUud3JpdGUoZnJhbWUuYXQoW10sICdjb3VudCcpLCBjb3VudCArIDEsICdzZXQnKTtcbiAqIGZyYW1lLmNvbW1pdCgoKSA9PiAoeyBzdGFnZTogJ0luY3JlbWVudCcsIHN0YWdlSWQ6ICdpbmNyZW1lbnQnLCBydW50aW1lU3RhZ2VJZDogJ2luY3JlbWVudCMwJyB9KSk7XG4gKlxuICogc3RhdGVBdCh7IGluaXRpYWxTdGF0ZTogbG9nLmdldEluaXRpYWxTdGF0ZSgpLCBjb21taXRMb2c6IGxvZy5saXN0KCkgfSwgMCkuc3RhdGU7IC8vIHsgY291bnQ6IDEgfVxuICogYGBgXG4gKlxuICogQG1vZHVsZSB3cml0ZVxuICovXG5cbi8vIFRoZSBoZWFwIGFuZCB0aGUgbG9nLlxuZXhwb3J0IHsgRXZlbnRMb2cgfSBmcm9tICcuL2xpYi9tZW1vcnkvRXZlbnRMb2cuanMnO1xuZXhwb3J0IHsgU2hhcmVkTWVtb3J5IH0gZnJvbSAnLi9saWIvbWVtb3J5L1NoYXJlZE1lbW9yeS5qcyc7XG5cbi8vIE9uZSBzdGVwJ3MgZnJhbWUsIGFuZCB3aGF0IGl0IHRha2VzOiB0aGUgZGlhbHMsIHRoZSB2ZXJicywgYSB2ZXJkaWN0J3MgYnl0ZXMsIHRoZSBuYW1lcyBvbiBpdHMgYnVuZGxlLlxuZXhwb3J0IHR5cGUgeyBDb21taXRTdGFtcCB9IGZyb20gJy4vbGliL21lbW9yeS9yZWNvcmRDb21taXQuanMnO1xuZXhwb3J0IHR5cGUgeyBSZWNvcmRFbmNvZGluZywgV3JpdGVTY3J1YiwgV3JpdGVWZXJiIH0gZnJvbSAnLi9saWIvbWVtb3J5L1JlY29yZEZyYW1lLmpzJztcbmV4cG9ydCB7IFJlY29yZEZyYW1lIH0gZnJvbSAnLi9saWIvbWVtb3J5L1JlY29yZEZyYW1lLmpzJztcbmV4cG9ydCB0eXBlIHsgV3JpdGVQcm92ZW5hbmNlTW9kZSB9IGZyb20gJy4vbGliL21lbW9yeS90eXBlcy5qcyc7XG4iXX0=

package/dist/index.js

@@ -5,11 +5,13 @@
  * The flowchart pattern for backend code.
  * Build → Run → Observe.
  *
- * **Three import paths:**
+ * **The common import paths:**
  * ```ts
  * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here
  * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories
- * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals
+ * import { stateAt, causalChain }         from 'footprintjs/trace';     // read a finished run
+ * import { RecordFrame, EventLog }        from 'footprintjs/write';     // write a record yourself
+ * import { StageContext }                 from 'footprintjs/advanced';  // engine internals
  * ```
  *
  * @module
@@ -129,4 +131,4 @@ Object.defineProperty(exports, "isDevMode", { enumerable: true, get: function ()
 // same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.
 var stringifySnapshot_js_1 = require("./lib/runner/stringifySnapshot.js");
 Object.defineProperty(exports, "stringifySnapshot", { enumerable: true, get: function () { return stringifySnapshot_js_1.stringifySnapshot; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AA6BvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAoBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAkBvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAmC1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAoDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAmBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AA0B1B,6BAA6B;AAC7B,kDAAiD;AAAxC,sGAAA,SAAS,OAAA;AAiElB,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,+CAA4E;AAAnE,4GAAA,cAAc,OAAA;AAAE,2GAAA,aAAa,OAAA;AAAE,uGAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,0EAAsE;AAA7D,yHAAA,iBAAiB,OAAA","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/**\n * The four observability dials `FlowChartExecutorOptions` inherits.\n * @category Run\n */\nexport type { RunDials } from './lib/memory/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'clone'` by default for attach options / `'summary'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  FlowThrottledEvent,\n  ResumeLink,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type { JsonSchema } from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type {\n  FlowchartCheckpoint,\n  PausableHandler,\n  PausedExecution,\n  PendingPause,\n  RedactionMarks,\n} from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n// A run's record as JSON without the engine's recursion limit (9.26.0): the\n// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.\nexport { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AA6BvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAoBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAkBvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAmC1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAoDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAmBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AA0B1B,6BAA6B;AAC7B,kDAAiD;AAAxC,sGAAA,SAAS,OAAA;AAiElB,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,+CAA4E;AAAnE,4GAAA,cAAc,OAAA;AAAE,2GAAA,aAAa,OAAA;AAAE,uGAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,0EAAsE;AAA7D,yHAAA,iBAAiB,OAAA","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **The common import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { stateAt, causalChain }         from 'footprintjs/trace';     // read a finished run\n * import { RecordFrame, EventLog }        from 'footprintjs/write';     // write a record yourself\n * import { StageContext }                 from 'footprintjs/advanced';  // engine internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/**\n * @category Quick Start\n *\n * Config for `.addParallelForEach()` — one branch per item, branch count\n * decided at run time from the payload. `maxBranches` and `into` are required\n * on purpose (see docs/design/execution-control.md).\n */\nexport type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureStageTaggedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  DefaultBranch,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/**\n * The four observability dials `FlowChartExecutorOptions` inherits.\n * @category Run\n */\nexport type { RunDials } from './lib/memory/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * Every `attach*Recorder` call accepts an options bag:\n * `executor.attachScopeRecorder(rec, { delivery: 'deferred' })` takes the\n * recorder OUT of the engine's hot path — events are captured into one\n * bounded, totally-ordered queue and delivered at the next microtask\n * checkpoint (\"one beat behind\"). Omit `delivery` for the historical\n * synchronous call (byte-identical to previous releases). Accounting\n * surfaces on `snapshot.observerStats`; `executor.drainObservers()` settles\n * async listeners before shutdown. See `docs/guides/observers-deferred.md`.\n */\nexport type {\n  AttachRecorderOptions,\n  ObserverDelivery,\n  ObserverDrainResult,\n  ObserverStats,\n} from './lib/runner/index.js';\n\n/**\n * @category Observe — Delivery tier (RFC-001 deferred observers)\n *\n * `CapturePolicy` — how a deferred event's payload is materialized at\n * capture time (`'clone'` by default for attach options / `'summary'` / `'ref'`). `OverflowPolicy`\n * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /\n * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes\n * embedded in `ObserverStats`. Types only — the observer-queue module\n * itself is internal; consumers use the attach options.\n */\nexport type { CapturePolicy, DispatcherStats, ListenerStats, OverflowPolicy } from './lib/observer-queue/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowStageRetryEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  FlowThrottledEvent,\n  ResumeLink,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type { JsonSchema } from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type {\n  FlowchartCheckpoint,\n  PausableHandler,\n  PausedExecution,\n  PendingPause,\n  RedactionMarks,\n} from './lib/pause/index.js';\n\n/**\n * @category Pause/Resume\n *\n * `interrupt(scope, { reason, expects? })` — stop mid-stage to ask a question,\n * and get the answer back at the same call site when the run resumes. Resume\n * re-enters the stage from its TOP (stages are atomic), so keep the half\n * before the call idempotent.\n */\nexport type { InterruptPayload } from './lib/pause/index.js';\n\n/** @category Pause/Resume */\nexport { interrupt } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Commit-values encoding for the COMMIT LOG (#13c-B) — the third dial of\n * the family, and the only LOSSLESS one (it changes the log's encoding,\n * never its information). `'full'` (default — every surviving `set` stores\n * the full final value, byte-identical to history) / `'delta'` (array\n * net-changes that are \"base plus a tail\" commit as an `append` verb\n * storing only the tail; `deleteValue()` commits as a real `delete` verb;\n * one trace entry per surviving path). Replay reconstructs every step's\n * full state exactly. Consumers reading `bundle.overwrite[key]` as the full\n * value must use `commitValueAt` from `footprintjs/trace`. Pass as\n * `new FlowChartExecutor(chart, { commitValues })` or call\n * `executor.setCommitValues(mode)` before `run()`; the active mode is the\n * snapshot discriminant `getSnapshot().commitValues`.\n */\nexport type { CommitValuesMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n// A run's record as JSON without the engine's recursion limit (9.26.0): the\n// same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.\nexport { stringifySnapshot } from './lib/runner/stringifySnapshot.js';\n"]}

package/dist/lib/decide/evaluator.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateFilter = void 0;
 const summarize_js_1 = require("../capture/summarize.js");
 const devMode_js_1 = require("../devMode.js");
-const placeholders_js_1 = require("../memory/placeholders.js");
+const redaction_js_1 = require("../memory/redaction.js");
 const OPERATOR_HANDLERS = {
     eq: (a, t) => a === t,
     ne: (a, t) => a !== t,
@@ -94,7 +94,7 @@ function evaluateFilter(getValueFn, isRedactedFn, filter) {
             continue;
         const actual = getValueFn(key);
         const redacted = isRedactedFn(key);
-        const displayValue = redacted ? placeholders_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(actual, MAX_VALUE_LEN);
+        const displayValue = redacted ? redaction_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(actual, MAX_VALUE_LEN);
         // Evaluate each operator in the FilterOps for this key
         for (const [op, threshold] of Object.entries(ops)) {
             const handler = OPERATOR_HANDLERS[op];
@@ -131,4 +131,4 @@ function evaluateFilter(getValueFn, isRedactedFn, filter) {
     return { matched: allMatched, conditions };
 }
 exports.evaluateFilter = evaluateFilter;
-//# 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":";AAAA;;;;;;;;GAQG;;;AAEH,0DAAyD;AACzD,8CAA0C;AAC1C,yDAA2D;AAO3D,MAAM,iBAAiB,GAA+B;IACpD,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACrB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC;IACrB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,GAAI,CAAY;IAC3C,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,IAAK,CAAY;IAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,GAAI,CAAY;IAC3C,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAE,CAAY,IAAK,CAAY;IAC7C,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACX,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QACpC,IAAI,CAAC,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,0CAA0C,iBAAiB,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IACD,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACd,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC,CAAC,sCAAsC;QAC1E,IAAI,CAAC,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,0CAA0C,iBAAiB,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;CACF,CAAC;AAEF,+EAA+E;AAE/E,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;IAC1B,WAAW;IACX,aAAa;IACb,WAAW;IACX,UAAU;IACV,SAAS;IACT,gBAAgB;IAChB,eAAe;IACf,sBAAsB;IACtB,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;CACnB,CAAC,CAAC;AAEH,+EAA+E;AAE/E,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAC/B,MAAM,aAAa,GAAG,EAAE,CAAC;AAEzB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,cAAc,CAC5B,UAAoC,EACpC,YAAsC,EACtC,MAAsB;IAEtB,MAAM,UAAU,GAAsB,EAAE,CAAC;IACzC,IAAI,UAAU,GAAG,IAAI,CAAC;IAEtB,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAChD,uFAAuF;QACvF,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,UAAU,GAAG,KAAK,CAAC;YACnB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS;QAE9C,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QACnC,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,gCAAiB,CAAC,CAAC,CAAC,IAAA,6BAAc,EAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAE1F,uDAAuD;QACvD,KAAK,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAA8B,CAAC,EAAE,CAAC;YAC7E,MAAM,OAAO,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC;YACtC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,+EAA+E;gBAC/E,IAAI,IAAA,sBAAS,GAAE,EAAE,CAAC;oBAChB,sCAAsC;oBACtC,OAAO,CAAC,IAAI,CACV,2DAA2D,EAAE,aAAa,GAAG,MAAM;wBACjF,6CAA6C,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC5F,CAAC;gBACJ,CAAC;gBACD,UAAU,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAC9F,UAAU,GAAG,KAAK,CAAC;gBACnB,SAAS;YACX,CAAC;YAED,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC1C,UAAU,CAAC,IAAI,CAAC;gBACd,GAAG;gBACH,EAAE;gBACF,SAAS;gBACT,aAAa,EAAE,YAAY;gBAC3B,MAAM;gBACN,QAAQ;aACT,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM;gBAAE,UAAU,GAAG,KAAK,CAAC;QAClC,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,wEAAwE;IACxE,yEAAyE;IACzE,gDAAgD;IAChD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAEnE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;AAC7C,CAAC;AA1DD,wCA0DC","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/lib/decide/evidence.js

@@ -10,7 +10,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceCollector = void 0;
 const summarize_js_1 = require("../capture/summarize.js");
-const placeholders_js_1 = require("../memory/placeholders.js");
+const redaction_js_1 = require("../memory/redaction.js");
 const MAX_VALUE_LEN = 80;
 let evidenceCounter = 0;
 /**
@@ -28,7 +28,7 @@ class EvidenceCollector {
             return;
         this.inputs.push({
             key: event.key,
-            valueSummary: event.redacted ? placeholders_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(event.value, MAX_VALUE_LEN),
+            valueSummary: event.redacted ? redaction_js_1.SCOPE_PLACEHOLDER : (0, summarize_js_1.summarizeValue)(event.value, MAX_VALUE_LEN),
             redacted: event.redacted === true,
         });
     }
@@ -38,4 +38,4 @@ class EvidenceCollector {
     }
 }
 exports.EvidenceCollector = EvidenceCollector;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -14,7 +14,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.servedPause = void 0;
-const placeholders_js_1 = require("../../memory/placeholders.js");
+const redaction_js_1 = require("../../memory/redaction.js");
 function servedPause(context, pauseData) {
     const rule = context.getRedactionRule();
     if (!rule)
@@ -23,8 +23,8 @@ function servedPause(context, pauseData) {
         return rule.retainBoundary(pauseData);
     }
     catch {
-        return placeholders_js_1.SCOPE_PLACEHOLDER;
+        return redaction_js_1.SCOPE_PLACEHOLDER;
     }
 }
 exports.servedPause = servedPause;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/memory/EventLog.js

@@ -92,7 +92,7 @@ class EventLog {
     /**
      * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle
      * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle
-     * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it
+     * built for the log alone; a caller of this class (`footprintjs/write`) hands over a bundle it
      * will no longer edit — its own object is the one frozen.
      */
     record(bundle) {
@@ -149,4 +149,4 @@ class EventLog {
     }
 }
 exports.EventLog = EventLog;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../../src/lib/memory/EventLog.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EventLog — Time-travel snapshot storage for flowchart execution\n *\n * Like git history: stores commit bundles (diffs), not full snapshots.\n *\n * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is\n * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the\n * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no\n * longer rewrite the history every later answer is folded from: an assignment into a bundle throws\n * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:\n * the log's payload is the commit's own copy (`recordCommit` hands it the output of\n * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy\n * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by\n * test/lib/memory/property/record-reachability.property.test.ts.\n *\n * What `Object.freeze` cannot seal — a Date's time, a Map's or Set's entries, a buffer's bytes, a\n * RegExp, an Error's stack — is never handed out to a reader (9.44.2): `record` remembers that a\n * bundle holds such a value (`capture/freeze.ts · freezeRecord`), and `list()` — like the public\n * snapshot, `runner/snapshot.ts · servedSnapshot` — serves that bundle as a copy of its open paths\n * (`serveRecord`, mapped at its first serve): fresh frozen containers down to each such value, a\n * fresh copy of it, every other part the log's own. A reader edits only its own copy; every later\n * serve reads the record as recorded. `recorded()` is the engine's own, unserved read. Named holes: an object hung on an array EXPANDO (arrays are walked\n * by index — the `'indices'` walk, which keeps the freeze inside its budget; an expando is out of\n * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's\n * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or\n * `replace` advance it.\n */\n\nimport { freezeRecord, serveRecord } from '../capture/freeze.js';\nimport type { EmitSourcePosition, LogAddress } from './eventPosition.js';\nimport type { CommitBundle, MemoryPatch } from './types.js';\nimport { applySmartMergeInto } from './utils.js';\n\nexport class EventLog {\n  /** Base snapshot BEFORE the first stage mutates anything. */\n  private base: any;\n  /** Ordered list of commit bundles. */\n  private steps: CommitBundle[] = [];\n  private sourceAddress?: LogAddress;\n  private sourceAddressRetired = false;\n\n  constructor(initialMemory: any) {\n    // Normalised to an object: the base is a STATE, and every fold over it\n    // (`materialise`, `stateAt`) applies path writes to it. `undefined` —\n    // what a run with no `initialContext` used to store here — made every\n    // one of those folds throw on the first `set`.\n    this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);\n  }\n\n  /**\n   * The fold BASE — the state as it stood before the first commit.\n   *\n   * This is the other half of the commit log: bundles are DIFFS, so a log\n   * alone cannot reconstruct state that was seeded before the run (an\n   * executor `initialContext`, `defaultValuesForContext`, a resume's\n   * `checkpoint.sharedState`, a subflow's `inputMapper` seed). Travelling\n   * with the log — `RuntimeSnapshot.initialState` — is what lets an OFFLINE\n   * consumer fold; without it the honest answer is a partial one\n   * (`stateAt`'s `basis: 'log-only'`).\n   *\n   * Returns a fresh detached clone on every call — the caller owns it.\n   */\n  getInitialState(): any {\n    return structuredClone(this.base);\n  }\n\n  /**\n   * Reconstructs the full state at any given step.\n   * Replays commits from the beginning — O(n) but low memory footprint.\n   *\n   * INDEX CONVENTION — `stepIdx` is EXCLUSIVE: `materialise(3)` folds commits\n   * 0, 1 and 2. `stateAt(source, commitIdx)` (footprintjs/trace) folds the\n   * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks\n   * \"the state AT this stop\", which must include that stop's own commit. Two\n   * folds over one log with opposite conventions: check which one you hold.\n   *\n   * One clone of the base per call, then every bundle replayed INTO that\n   * private copy (`applySmartMergeInto` — the live commit's copy-on-write law\n   * below the root, 9.29.0, so the fold and the live state agree at every\n   * path). The result is the caller's: it shares nothing with the base or\n   * the log.\n   *\n   * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log\n   * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).\n   * Nothing in the library calls this; it stays for one minor and is then removed. Mind the\n   * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.\n   */\n  materialise(stepIdx = this.steps.length): any {\n    const out = structuredClone(this.base);\n    for (let i = 0; i < stepIdx; i++) {\n      const { overwrite, updates, trace } = this.steps[i];\n      applySmartMergeInto(out, updates as MemoryPatch, overwrite as MemoryPatch, trace);\n    }\n    return out;\n  }\n\n  /**\n   * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle\n   * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle\n   * built for the log alone; a caller of this class (`footprintjs/advanced`) hands over a bundle it\n   * will no longer edit — its own object is the one frozen.\n   */\n  record(bundle: CommitBundle): void {\n    bundle.idx = this.steps.length;\n    freezeRecord(bundle, 'indices');\n    this.steps.push(bundle);\n  }\n\n  /**\n   * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed\n   * whole is the log's own (frozen) object, one holding a Date, Map, buffer … is a copy of its open\n   * paths (`capture/freeze.ts · serveRecord`) — the reader's own, so no edit reaches the log.\n   */\n  list(): CommitBundle[] {\n    return this.steps.map(serveRecord);\n  }\n\n  /**\n   * @internal The bundles as the log holds them — each frozen, NOT served — in a new array, so a holder's\n   * `splice` reaches only its own. For the engine's own snapshot (`ExecutionRuntime · getSnapshot`, which\n   * a subflow mount takes once per mount), so the run serves nothing; a reader is served by `list()` and\n   * `getSnapshot().commitLog`. A known open door (CHANGELOG 9.44.2): a holder of these bundles can still\n   * edit a Date, Map or buffer inside them.\n   */\n  recorded(): CommitBundle[] {\n    return this.steps.slice();\n  }\n\n  /** Number of recorded commits. */\n  get length(): number {\n    return this.steps.length;\n  }\n\n  /** Immutable identity of this log, absent until the engine binds it. */\n  get address(): LogAddress | undefined {\n    return this.sourceAddress;\n  }\n\n  /** @internal Bind once; resuming the same log must not rename its earlier positions. */\n  bindAddress(logRunId: string, drillPath: readonly string[]): void {\n    if (this.sourceAddressRetired) return;\n    this.sourceAddress ??= Object.freeze({ logRunId, drillPath: Object.freeze([...drillPath]) });\n  }\n\n  /** O(1) source-time capture. No counter, observer bookkeeping, or future commit prediction. */\n  capturePosition(runId: string): EmitSourcePosition | undefined {\n    if (!this.sourceAddress) return undefined;\n    return Object.freeze({ runId, ...this.sourceAddress, committedThroughIdx: this.steps.length - 1 });\n  }\n\n  /** Wipes history (useful for test resets). */\n  clear(): void {\n    this.steps = [];\n    // A reset prefix cannot reuse old coordinates, even if another stage of\n    // the SAME leg binds it again. Keep clear's data behavior, but retire\n    // addressing for this log; known coordinates require a fresh EventLog.\n    this.sourceAddress = undefined;\n    this.sourceAddressRetired = true;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../../src/lib/memory/EventLog.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EventLog — Time-travel snapshot storage for flowchart execution\n *\n * Like git history: stores commit bundles (diffs), not full snapshots.\n *\n * THE RECORD IS IMMUTABLE FROM `record` (F3, ruling R3). Every bundle is deep-frozen as it is\n * recorded — the bundle, `overwrite` and `updates` at every depth, the trace and each row, the\n * row's `readKeys`, `redactedPaths`, `tags`, `untrackedSources` — so a holder of a snapshot can no\n * longer rewrite the history every later answer is folded from: an assignment into a bundle throws\n * a `TypeError` in strict code. Safe because nothing outside the log holds a bundle's containers:\n * the log's payload is the commit's own copy (`recordCommit` hands it the output of\n * `scrubPatch`), and live state, the redacted mirror and write retention each take their own copy\n * (`verbs.ts · foldRows` detaches, `StageContext · retainedForm` clones) — pinned by\n * test/lib/memory/property/record-reachability.property.test.ts.\n *\n * What `Object.freeze` cannot seal — a Date's time, a Map's or Set's entries, a buffer's bytes, a\n * RegExp, an Error's stack — is never handed out to a reader (9.44.2): `record` remembers that a\n * bundle holds such a value (`capture/freeze.ts · freezeRecord`), and `list()` — like the public\n * snapshot, `runner/snapshot.ts · servedSnapshot` — serves that bundle as a copy of its open paths\n * (`serveRecord`, mapped at its first serve): fresh frozen containers down to each such value, a\n * fresh copy of it, every other part the log's own. A reader edits only its own copy; every later\n * serve reads the record as recorded. `recorded()` is the engine's own, unserved read. Named holes: an object hung on an array EXPANDO (arrays are walked\n * by index — the `'indices'` walk, which keeps the freeze inside its budget; an expando is out of\n * contract for state) and a `SharedArrayBuffer` (every copy shares its memory). A frozen RegExp's\n * `lastIndex` is read-only, so a `/g` or `/y` regex read from a bundle throws when `exec` or\n * `replace` advance it.\n */\n\nimport { freezeRecord, serveRecord } from '../capture/freeze.js';\nimport type { EmitSourcePosition, LogAddress } from './eventPosition.js';\nimport type { CommitBundle, MemoryPatch } from './types.js';\nimport { applySmartMergeInto } from './utils.js';\n\nexport class EventLog {\n  /** Base snapshot BEFORE the first stage mutates anything. */\n  private base: any;\n  /** Ordered list of commit bundles. */\n  private steps: CommitBundle[] = [];\n  private sourceAddress?: LogAddress;\n  private sourceAddressRetired = false;\n\n  constructor(initialMemory: any) {\n    // Normalised to an object: the base is a STATE, and every fold over it\n    // (`materialise`, `stateAt`) applies path writes to it. `undefined` —\n    // what a run with no `initialContext` used to store here — made every\n    // one of those folds throw on the first `set`.\n    this.base = initialMemory === undefined ? {} : structuredClone(initialMemory);\n  }\n\n  /**\n   * The fold BASE — the state as it stood before the first commit.\n   *\n   * This is the other half of the commit log: bundles are DIFFS, so a log\n   * alone cannot reconstruct state that was seeded before the run (an\n   * executor `initialContext`, `defaultValuesForContext`, a resume's\n   * `checkpoint.sharedState`, a subflow's `inputMapper` seed). Travelling\n   * with the log — `RuntimeSnapshot.initialState` — is what lets an OFFLINE\n   * consumer fold; without it the honest answer is a partial one\n   * (`stateAt`'s `basis: 'log-only'`).\n   *\n   * Returns a fresh detached clone on every call — the caller owns it.\n   */\n  getInitialState(): any {\n    return structuredClone(this.base);\n  }\n\n  /**\n   * Reconstructs the full state at any given step.\n   * Replays commits from the beginning — O(n) but low memory footprint.\n   *\n   * INDEX CONVENTION — `stepIdx` is EXCLUSIVE: `materialise(3)` folds commits\n   * 0, 1 and 2. `stateAt(source, commitIdx)` (footprintjs/trace) folds the\n   * same log but its `commitIdx` is INCLUSIVE, because a reader's cursor asks\n   * \"the state AT this stop\", which must include that stop's own commit. Two\n   * folds over one log with opposite conventions: check which one you hold.\n   *\n   * One clone of the base per call, then every bundle replayed INTO that\n   * private copy (`applySmartMergeInto` — the live commit's copy-on-write law\n   * below the root, 9.29.0, so the fold and the live state agree at every\n   * path). The result is the caller's: it shares nothing with the base or\n   * the log.\n   *\n   * @deprecated Since 9.33.0 — use `stateAt` from `footprintjs/trace`, which folds the same log\n   * from the same base (`RuntimeSnapshot.initialState`) and says how it was derived (`basis`).\n   * Nothing in the library calls this; it stays for one minor and is then removed. Mind the\n   * index: `materialise(n)` folds commits `0..n-1`, `stateAt(source, n - 1)` the same commits.\n   */\n  materialise(stepIdx = this.steps.length): any {\n    const out = structuredClone(this.base);\n    for (let i = 0; i < stepIdx; i++) {\n      const { overwrite, updates, trace } = this.steps[i];\n      applySmartMergeInto(out, updates as MemoryPatch, overwrite as MemoryPatch, trace);\n    }\n    return out;\n  }\n\n  /**\n   * Persists a commit bundle for a finished stage, and FREEZES it (see the module doc): the bundle\n   * is stamped with its position, then deep-frozen, then appended. The engine hands it a bundle\n   * built for the log alone; a caller of this class (`footprintjs/write`) hands over a bundle it\n   * will no longer edit — its own object is the one frozen.\n   */\n  record(bundle: CommitBundle): void {\n    bundle.idx = this.steps.length;\n    freezeRecord(bundle, 'indices');\n    this.steps.push(bundle);\n  }\n\n  /**\n   * Every recorded commit bundle, AS SERVED (9.44.2): a new array each call; a bundle freezing sealed\n   * whole is the log's own (frozen) object, one holding a Date, Map, buffer … is a copy of its open\n   * paths (`capture/freeze.ts · serveRecord`) — the reader's own, so no edit reaches the log.\n   */\n  list(): CommitBundle[] {\n    return this.steps.map(serveRecord);\n  }\n\n  /**\n   * @internal The bundles as the log holds them — each frozen, NOT served — in a new array, so a holder's\n   * `splice` reaches only its own. For the engine's own snapshot (`ExecutionRuntime · getSnapshot`, which\n   * a subflow mount takes once per mount), so the run serves nothing; a reader is served by `list()` and\n   * `getSnapshot().commitLog`. A known open door (CHANGELOG 9.44.2): a holder of these bundles can still\n   * edit a Date, Map or buffer inside them.\n   */\n  recorded(): CommitBundle[] {\n    return this.steps.slice();\n  }\n\n  /** Number of recorded commits. */\n  get length(): number {\n    return this.steps.length;\n  }\n\n  /** Immutable identity of this log, absent until the engine binds it. */\n  get address(): LogAddress | undefined {\n    return this.sourceAddress;\n  }\n\n  /** @internal Bind once; resuming the same log must not rename its earlier positions. */\n  bindAddress(logRunId: string, drillPath: readonly string[]): void {\n    if (this.sourceAddressRetired) return;\n    this.sourceAddress ??= Object.freeze({ logRunId, drillPath: Object.freeze([...drillPath]) });\n  }\n\n  /** O(1) source-time capture. No counter, observer bookkeeping, or future commit prediction. */\n  capturePosition(runId: string): EmitSourcePosition | undefined {\n    if (!this.sourceAddress) return undefined;\n    return Object.freeze({ runId, ...this.sourceAddress, committedThroughIdx: this.steps.length - 1 });\n  }\n\n  /** Wipes history (useful for test resets). */\n  clear(): void {\n    this.steps = [];\n    // A reset prefix cannot reuse old coordinates, even if another stage of\n    // the SAME leg binds it again. Keep clear's data behavior, but retire\n    // addressing for this log; known coordinates require a fresh EventLog.\n    this.sourceAddress = undefined;\n    this.sourceAddressRetired = true;\n  }\n}\n"]}