footprintjs 9.46.1 → 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,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

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/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":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAEH,oDAAiE;AAGjE,yCAAiD;AAEjD,MAAa,QAAQ;IACnB,6DAA6D;IACrD,IAAI,CAAM;IAClB,sCAAsC;IAC9B,KAAK,GAAmB,EAAE,CAAC;IAC3B,aAAa,CAAc;IAC3B,oBAAoB,GAAG,KAAK,CAAC;IAErC,YAAY,aAAkB;QAC5B,uEAAuE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,IAAI,GAAG,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,eAAe;QACb,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;QACrC,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,IAAA,8BAAmB,EAAC,GAAG,EAAE,OAAsB,EAAE,SAAwB,EAAE,KAAK,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAoB;QACzB,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,IAAA,wBAAY,EAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,uBAAW,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,kCAAkC;IAClC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,wEAAwE;IACxE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,wFAAwF;IACxF,WAAW,CAAC,QAAgB,EAAE,SAA4B;QACxD,IAAI,IAAI,CAAC,oBAAoB;YAAE,OAAO;QACtC,IAAI,CAAC,aAAa,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,+FAA+F;IAC/F,eAAe,CAAC,KAAa;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,SAAS,CAAC;QAC1C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,mBAAmB,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC;IACrG,CAAC;IAED,8CAA8C;IAC9C,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,wEAAwE;QACxE,sEAAsE;QACtE,uEAAuE;QACvE,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IACnC,CAAC;CACF;AA9HD,4BA8HC","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":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAEH,oDAAiE;AAGjE,yCAAiD;AAEjD,MAAa,QAAQ;IACnB,6DAA6D;IACrD,IAAI,CAAM;IAClB,sCAAsC;IAC9B,KAAK,GAAmB,EAAE,CAAC;IAC3B,aAAa,CAAc;IAC3B,oBAAoB,GAAG,KAAK,CAAC;IAErC,YAAY,aAAkB;QAC5B,uEAAuE;QACvE,sEAAsE;QACtE,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,IAAI,GAAG,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAChF,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,eAAe;QACb,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;QACrC,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,IAAA,8BAAmB,EAAC,GAAG,EAAE,OAAsB,EAAE,SAAwB,EAAE,KAAK,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAoB;QACzB,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;QAC/B,IAAA,wBAAY,EAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,uBAAW,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,kCAAkC;IAClC,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,wEAAwE;IACxE,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,wFAAwF;IACxF,WAAW,CAAC,QAAgB,EAAE,SAA4B;QACxD,IAAI,IAAI,CAAC,oBAAoB;YAAE,OAAO;QACtC,IAAI,CAAC,aAAa,KAAK,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,+FAA+F;IAC/F,eAAe,CAAC,KAAa;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,SAAS,CAAC;QAC1C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,mBAAmB,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC;IACrG,CAAC;IAED,8CAA8C;IAC9C,KAAK;QACH,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,wEAAwE;QACxE,sEAAsE;QACtE,uEAAuE;QACvE,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;IACnC,CAAC;CACF;AA9HD,4BA8HC","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"]}

package/dist/lib/memory/scrub.js

@@ -68,10 +68,12 @@ exports.scrubPatch = scrubPatch;
  * its contract unchanged since 4.x: a fresh deep copy of `patch` (`structuredClone`) with
  * {@link LOG_PLACEHOLDER} at every listed path that holds a defined value. Shares nothing with `patch`
  * and never edits it. (It lived in `memory/utils.ts` until 9.33.0 and in `memory/redaction.ts` until
- * C4; the engine's own commit path uses the clone-free {@link scrubPatch}.)
+ * C4; the engine's own commit path uses the clone-free {@link scrubPatch}.) No caller inside the
+ * library: it stays on `footprintjs/advanced` for the consumers that import it until 10.0.0 (the trace
+ * extraction, E6), which takes it off every door.
  */
 function redactPatch(patch, redactedSet) {
     return scrubPatch(structuredClone(patch), redactedSet);
 }
 exports.redactPatch = redactPatch;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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