footprintjs 9.41.0 → 9.42.0

package/AGENTS.md

@@ -220,6 +220,8 @@ await facadeRun.run({ input: { requestId: 'req-9' }, env: { traceId: 'trace-9' }
 
 ### Executor
 
+Custom factory objects (including standalone scopes passed to `decide`/`select`) must register their infrastructure port with `registerScopeRuntime(scope, { target, handlesAssignments, setBreak? })` from `footprintjs/advanced`. `ScopeFacade`, TypedScope, `attachScopeMethods` and canonical Zod factories register automatically. The engine asks that port, never probes a strict user proxy for lifecycle names. Prefer one backing `ScopeFacade` as `target`; it owns recording, redaction, input protection and commit sealing. A deliberately data-only `{}` port has none of those scope-level hooks. See `docs/guides/scope.md` for the migration example; do not restore property-name guessing.
+
 ```typescript
 import { flowChart, FlowChartExecutor, MetricRecorder, NarrativeFlowRecorder } from 'footprintjs';
 
@@ -438,7 +440,7 @@ for (const item of walkSubflowSpec(mounted!.subflowSpec!, mounted!.subflowPath ?
 // stage
 ```
 
-**CombinedNarrativeRecorder** implements the Scope + Flow + Emit interfaces. `executor.enableNarrative()` installs it (read it with `executor.getNarrativeEntries()`); `chart.recorder(narrative())` attaches a `narrative()` instance for a one-shot run, and `executor.attachCombinedRecorder(narrative())` works too — read either back from the instance (`recorder.getEntries()`); the executor's own `getNarrativeEntries()` belongs to `enableNarrative()`. It is not exported as a class.
+**CombinedNarrativeRecorder** implements the Scope + Flow + Emit interfaces. `executor.enableNarrative(options)` configures the executor-owned view (read it with `executor.getNarrativeEntries()`). Attaching any flow recorder also enables that view. `chart.recorder(narrative())` attaches a separate instance for a one-shot run, and `executor.attachCombinedRecorder(narrative())` works too — read its configured view from `recorder.getEntries()`, not the executor getter. Each default instance has a distinct generated ID; detach using `recorder.id`. Same-executor resume preserves narrative history; a fresh executor records only its resumed leg. The class is not exported from the public doors.
 
 ## Event Ordering
 
@@ -1035,6 +1037,8 @@ $log(value)           → emits 'log.debug.messages'
 
 So `$metric` / `$debug` are observable by recorders in real time; the side bags still populate for consumers that inspect snapshots directly.
 
+`RedactionPolicy.diagnostics` explicitly selects retained bag values (`logs`, `errors`, `metrics`, `evals` and flow-message text). The collector decides before storage; the facade emits the same retained incoming value, then applies any `emitPatterns` whole-wrapper mask. Do not re-scrub at recorders or snapshot export. Entries and flow metadata remain; independent error hooks/logger output and operational checkpoint state are not covered. State selectors/marks and the state-only redaction report stay separate. See `docs/guides/scope.md` → "Explicit diagnostic redaction".
+
 ### Customizing narrative rendering
 `NarrativeFormatter.renderEmit?(ctx)` hook (passed as `enableNarrative({ renderer })`) renders an emit event into a narrative line. Return `string` to use, `null` to exclude, `undefined` to fall back to the default `[emit] name: payloadSummary` (above: the first line is the custom one, the rest are defaults).
 
@@ -1112,10 +1116,10 @@ for (const arrayMerge of [ArrayMergeMode.Concat, ArrayMergeMode.Replace]) {
 ```bash
 npm run build           # tsc (CJS) + tsc -p tsconfig.esm.json (ESM) + scripts/postbuild-esm.mjs
 npm test                # full suite (vitest)
-npm run test:examples   # type-check examples/
+npm run test:examples   # type-check examples/, build, then run the fork example guard
 npm run lint
 npm run check:layering  # the layering rule, from scripts/layering.config.cjs
-npm run check:doc-snippets
+npm run check:doc-snippets # strict, isolated import-bearing TS fences; see scripts/doc-snippets/README.md
 ```
 
 Dual output: CommonJS (`dist/`) + ESM (`dist/esm/`) + types (`dist/types/`)

package/CLAUDE.md

@@ -20,9 +20,9 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | time-travel/ | the READER'S cursor over a finished trace (9.17.0): `timeTravel()` stops/moves/marks/`drill()`, `stateAt()` fold + honesty basis, `TimeTravelStrategy<TMeta>` seam (one shipped: `commitStops`). 9.18.0 composer's side: axis.ts (`splitAxis` = the ONE guard of the `[start,…stages,end]` contract; `filterStops` = filter + re-partition + `Stop.meta` vocabulary + `Stop.prologue` on an absorbing start — a FLAG, deliberately not a 5th StopKind), bundles.ts (per-bundle narrowing of `unknown[]` rows → index-holding GAPS in `FoldedState.skipped`), chain.ts (`timeTravel([paused, resumed])`: commit indices stay RUN-LOCAL + `Stop.sourceIdx`; refused unless execution indices are monotonic across legs and no id repeats). Read-time only — never a second live cursor. Imports memory/ + `engine/runtimeStageId` (see src/lib/time-travel/README.md) |
 | pause/ | PauseSignal / FlowchartCheckpoint types + `interrupt(scope, payload)` (throws InterruptSignal; converted to PauseSignal at the StageRunner boundary, `pausedBy:'interrupt'`) |
 | engine/ | FlowchartTraverser + handlers/; narrative/ = the whole FlowRecorder channel (dispatcher + 9 strategies), not just text; `lib/ids/branchSegment.ts` (moved to the `ids/` leaf in 9.37.0) = the ONE owner of the generated-segment grammar (`<stageId>~<index>`, marker `~` RESERVED); `executeStage` (:720) = the ONE funnel every stage fn passes through — and therefore the ONE owner of the declarative `retry` loop; `handlers/ResumeEntry.ts` = the ONE owner of a resume's ONE-SHOT re-entry (M2, 9.28.0: start + one hop per subflow on the pause path, each level's dispatcher continuation read from the chart, waiting sibling pauses queued at their fan-out) |
-| runner/ | FlowChartExecutor wiring (runtime, recorders, pause/resume, snapshot, DeferredObserverTier). RunContext.ts is a fluent run builder, NOT the threaded per-run context |
+| runner/ | FlowChartExecutor wiring — composes `attach.ts` (RunObservers) · `resume.ts` · `checkpoint.ts` · `snapshot.ts` · `options.ts` (F9, 9.41.0); (runtime, recorders, pause/resume, snapshot, DeferredObserverTier). RunContext.ts is a fluent run builder, NOT the threaded per-run context |
 | observer-queue/ | pure deferred-delivery pipeline (engine imports IT, never reverse) |
-| contract/, detach/ | I/O schema + OpenAPI; fire-and-forget child charts (drivers passed explicitly) |
+| contract/, detach/ | I/O schema normalization (OpenAPI generation belongs to runner/RunnableChart); fire-and-forget child charts (drivers passed explicitly) |
 
 **The fence (F0):** a file imports only its own layer or BELOW — L0 values/leaves · L1 verbs · L2 staging+commit · L3 the log as a read model · L4 frame+run policy · L5 scope/recorders/hooks · L6 engine · L7 builder+executor · L8 the `src/*.ts` entry barrels. The table is DATA in `scripts/layering.config.cjs` (most specific pattern wins; an unplaced file is an error, and `memory/` has no directory default because it spans L0–L4) and has three readers, none with a copy: `.eslintrc.js` (generated `import/no-restricted-paths` zones + `import/no-cycle`, src only), `npm run check:layering` (value-level cycles at module AND file level + upward RUNTIME edges; type-only imports excluded — the set equals the compiled CJS `require` graph), `test/architecture/layering.test.ts`. Three edges are named on purpose — builder → `runner/RunnableChart.ts` (`makeRunnable`), engine → `reactive/handles.ts`, scope → `detach/spawn.ts` — plus a short `TYPE_ONLY_ALLOWANCES` list (upward imports tsc erases, which the lint rule cannot tell apart); both lists are live-checked and only shrink. A new src file under an unsplit directory inherits its layer; one under `memory/` (or an exact-path entry) must be added to LAYERS — an unplaced file fails lint and the script. Public symbols have ONE canonical door each — `test/architecture/exports.test.ts` fails on any symbol two of the six `package.json` doors both hand out unless it is in `SECOND_DOORS` (28 today, in four reasoned groups; an alias counts as a door).
 
@@ -36,18 +36,18 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 
 **Retry (9.15.0):** `StageNode.retry` is a POLICY on a stage, not a kind — no new node type, no `computeNodeType` edit. The loop lives in `FlowchartTraverser.executeStage` (:720), so linear/streaming/pausable/decider/selector/fork-child/subflow-inner all get it from one implementation. A failed non-final attempt calls `StageContext.discardStaged()` (buffer + stateView + _stageWrites/_stageReads + _provenanceReads + _untrackedSources); the final attempt is today's law untouched. PauseSignal and abort are NEVER retried. One runtimeStageId + one CommitBundle per stage regardless of attempts; retries do not consume `maxIterations`.
 
-**Declared tags (9.21.0):** `StageNode.tags?: readonly string[]` is a NAME on a stage, declared at build time — POLICY-like (the retry precedent): no node type, no `computeNodeType` edit, no type-union site, and the one prefixer (`engine/graph/prefixNodeTree.ts`, 9.37.0) spreads `{ ...node }` so it rides subflow prefixing untouched. ONE landing site `FlowChartBuilder.ts · applyTags` (twin of `applyRetryPolicy`) serves the `.tag(...names)` cursor modifier and every `options.tags` site; refuses empty/non-string/`~`/duplicate/double-declare at build. Stamp: `FlowchartTraverser.executeNodeStep` sets `context.tags = node.tags` beside `runtimeStageId` (unconditionally — a re-used context must not keep a prior node's names); `StageContext.commit` spreads `tagsFragment()` beside `untrackedSourcesFragment()` on BOTH commit paths and RELEASES it, so a double-commit path (fork child fan-out repeat, mount exit) records it once — absent when empty (`CommitBundle.tags?`; pinned byte-identical to 9.20.0 by test/lib/engine/scenario/declared-tags-byte-identity.test.ts). NOT inherited by createNext/createChild; the one synthetic node that could lose it is `FlowChartExecutor.resume`'s stand-in for the paused stage — built by `FlowChartExecutor · standInFor` from the paused node ITSELF (fn swapped), so it keeps the tags on both re-entries; it runs ONCE — a later visit of the paused id runs the chart's real node, which carries its own tags. The spec carries `tags` as-is (Map advertises the vocabulary; `RuntimeStructureManager.stageNodeToStructure` copies it for run-time-resolved nodes). Reader: `time-travel/tagStops.ts` = `filterStops(commitStops(...), any-of over log[stop.commitIdx].tags, meta = the array)`, exported from `/trace`. Never a runtime `$tag()` — a value would ride past every redaction point. Design: docs/design/2026-09-declared-tags.md.
+**Declared tags (9.21.0):** `StageNode.tags?: readonly string[]` is a NAME on a stage, declared at build time — POLICY-like (the retry precedent): no node type, no `computeNodeType` edit, no type-union site, and the one prefixer (`engine/graph/prefixNodeTree.ts`, 9.37.0) spreads `{ ...node }` so it rides subflow prefixing untouched. ONE landing site `FlowChartBuilder.ts · applyTags` (twin of `applyRetryPolicy`) serves the `.tag(...names)` cursor modifier and every `options.tags` site; refuses empty/non-string/`~`/duplicate/double-declare at build. Stamp: `FlowchartTraverser.executeNodeStep` sets `context.tags = node.tags` beside `runtimeStageId` (unconditionally — a re-used context must not keep a prior node's names); `StageContext · bundleFor` (both commit paths, F10) spreads `tagsFragment()` beside `untrackedSourcesFragment()` on BOTH commit paths and RELEASES it, so a double-commit path (fork child fan-out repeat, mount exit) records it once — absent when empty (`CommitBundle.tags?`; pinned byte-identical to 9.20.0 by test/lib/engine/scenario/declared-tags-byte-identity.test.ts). NOT inherited by createNext/createChild; the one synthetic node that could lose it is `FlowChartExecutor.resume`'s stand-in for the paused stage — built by `runner/resume.ts · standInFor` from the paused node ITSELF (fn swapped), so it keeps the tags on both re-entries; it runs ONCE — a later visit of the paused id runs the chart's real node, which carries its own tags. The spec carries `tags` as-is (Map advertises the vocabulary; `RuntimeStructureManager.stageNodeToStructure` copies it for run-time-resolved nodes). Reader: `time-travel/tagStops.ts` = `filterStops(commitStops(...), any-of over log[stop.commitIdx].tags, meta = the array)`, exported from `/trace`. Never a runtime `$tag()` — a value would ride past every redaction point. Design: docs/design/2026-09-declared-tags.md.
 
 **Event order (code-verified; older docs had 3/4 swapped):** onStageStart → onRead/onWrite (live, PRE-commit) → **onStageEnd (StageRunner.ts:81) → onCommit (StageContext.ts:587)** → FlowRecorder onDecision/onFork/onSelected/onSubflowEntry → onStageExecuted (uniform, with stageType). Error path: commit STILL happens (FlowchartTraverser.ts:1088) before onError+rethrow — a failing stage's writes land. For ANY thrown value (null, null-prototype, hostile Proxy) catch blocks describe it with `errors/errorInfo · thrownText` (never throws), onError fires, and run() rejects with the ORIGINAL value; a failed commit (e.g. an uncloneable write) also fires onError (`handlers/commitStage.ts`, 9.40.0). `interrupt()` rides the ERROR path's shape, not the pausable one: the stage function threw, so onStageEnd does NOT fire (the `addPausableFunction` pause DOES fire it — there the function returned normally).
 
 ## Extension points
 - **New stage kind**: boolean flag on `StageNode` (engine/graph/StageNode.ts:39 — kinds are flags, not an enum) + builder method on FlowChartBuilder (pattern: addPausableFunction :1264; fire structure events endpoint-before-edge) + phase in the hard-coded chain `executeNodeStep` (FlowchartTraverser.ts:801 — no handler registry; new handler class takes HandlerDeps, engine/types.ts:344, instantiated in traverser ctor :402-413). Must also edit 5 type-union sites: engine/types.ts:477, builder/types.ts:50, builder/types.ts:104, engine/types.ts:427, and computeNodeType's flag→type mapping (RuntimeStructureManager.ts:19-21 — the only one the compiler won't flag; miss it and the new kind silently serializes as 'stage'). Zero-engine alternative: pure sugar over addFunction (pattern: addDetachAndForget :1343). WORKED EXAMPLE (9.14.0 addParallelForEach): flag `isDynamicParallel` + ParallelForEachHandler + Phase 0b (BEFORE Phase 1 VALIDATE — the node has no fn/children/decider by design); it added NO new node type — the spec carries a BOOLEAN and computeNodeType returns 'fork' (precedent: isPausable/isLazy/isStreaming are flags on a 'stage'), which is the cheaper choice whenever the new kind is a variant of an existing shape.
 - **Decider/selector**: addDeciderFunction :1433 → DeciderList (:53); addSelectorFunction :1478 → SelectorFnList (:428); runtime match on `child.branchId ?? child.id` (DeciderHandler.ts:133). Evidence via decide()/select() (decide/decide.ts:169/218). `decide()`'s 3rd param is `DefaultBranch = string | { branch, label? }` (9.16.0) — the default is chosen by NO rule, so `rules[].label` can never name it; the object form puts that label on `DecisionEvidence.defaultLabel`, spread into BOTH evidence exits (matched AND fallthrough) so a harvest doesn't gain/lose the meaning with the data. Bare string ⇒ key absent, byte-identical to pre-9.16. `select()` has no default and is deliberately untouched.
-- **Recorder**: channels = ScopeRecorder (scope/types.ts:137), FlowRecorder (engine/narrative/types.ts:425), EmitRecorder (recorder/EmitRecorder.ts:121 — attachEmitRecorder just delegates to the scope channel), CombinedRecorder (recorder/CombinedRecorder.ts:98, routed by method-shape), StructureRecorder (builder/structure/StructureRecorder.ts:347, build-time; its hooks are NOT in `HOOKS` (build-time, not a run channel) — the `StructureRecorderDispatcher` fires each by name, so a new structure hook = interface + `fire*` + the builder's `_fire*` helper; 9.24.0 `onStageTagged` is the worked example: names that land AFTER `onStageAdded` through the `.tag()` door go out as their own event, `StructureStageAddedEvent.tags` carries the ones that landed before). Attach via executor.attach*Recorder — idempotent by id. **One registry since 9.36.0 (F6): `recorder/hooks.ts · HOOKS`** — every hook declared once (channels, payload, executor-made); `hooksOn(channel)` drives channel routing and the deferred tier's taps, `CompositeRecorder`'s fan-out is generated from `HOOK_NAMES`, and one `fire` isolates every recorder error (scope → `onError`, flow → dev warning; R10: a throwing `onResume` no longer rejects `resume()`). A hook on an interface but not in `HOOKS` does not compile (`test/architecture/hook-registry-compile.test.ts`). Detection accepts class-prototype methods (blocks only Object.prototype — CombinedRecorder.ts:266). New built-in = compose a store as a field (no base classes) + factory in src/recorders.ts. `toSnapshot()` bundles are REBUILT field by field into `RecorderSnapshot` (FlowChartExecutor.ts:1698 — so a recorder can't spoof its own `id`); anything not on that copy list is dropped silently — the free-form slot is `meta` (facts about the bundle: which projection, what it omits — what a consumer BRANCHES on; prose goes in `description`). A new bundle field means editing the copy list AND the three `toSnapshot?()` signature sites (scope/types.ts:159, engine/narrative/types.ts:462, recorder/CombinedRecorder.ts:121).
+- **Recorder**: channels = ScopeRecorder (scope/types.ts:137), FlowRecorder (engine/narrative/types.ts:425), EmitRecorder (recorder/EmitRecorder.ts:121 — attachEmitRecorder just delegates to the scope channel), CombinedRecorder (recorder/CombinedRecorder.ts:98, routed by method-shape), StructureRecorder (builder/structure/StructureRecorder.ts:347, build-time; its hooks are NOT in `HOOKS` (build-time, not a run channel) — the `StructureRecorderDispatcher` fires each by name, so a new structure hook = interface + `fire*` + the builder's `_fire*` helper; 9.24.0 `onStageTagged` is the worked example: names that land AFTER `onStageAdded` through the `.tag()` door go out as their own event, `StructureStageAddedEvent.tags` carries the ones that landed before). Attach via executor.attach*Recorder — idempotent by id. **One registry since 9.36.0 (F6): `recorder/hooks.ts · HOOKS`** — every hook declared once (channels, payload, executor-made); `hooksOn(channel)` drives channel routing and the deferred tier's taps, `CompositeRecorder`'s fan-out is generated from `HOOK_NAMES`, and one `fire` isolates every recorder error (scope → `onError`, flow → dev warning; R10: a throwing `onResume` no longer rejects `resume()`). A hook on an interface but not in `HOOKS` does not compile (`test/architecture/hook-registry-compile.test.ts`). Detection accepts class-prototype methods (blocks only Object.prototype — CombinedRecorder.ts:266). New built-in = compose a store as a field (no base classes) + factory in src/recorders.ts. `toSnapshot()` bundles are REBUILT field by field into `RecorderSnapshot` (`recorder/snapshot.ts · copyBundle`, called by `runner/snapshot.ts · collectRecorderSnapshots` — so a recorder can't spoof its own `id`); anything not on that copy list is dropped silently — the free-form slot is `meta` (facts about the bundle: which projection, what it omits — what a consumer BRANCHES on; prose goes in `description`). A new bundle field means editing the copy list AND the three `toSnapshot?()` signature sites (scope/types.ts:159, engine/narrative/types.ts:462, recorder/CombinedRecorder.ts:121).
 - **Scope $-method (4-file checklist)**: ScopeFacade capability + ReactiveTarget (reactive/types.ts:20); ScopeMethods type (:74); METHOD_ROUTES (createTypedScope.ts:46); SCOPE_METHOD_NAMES (reactive/types.ts:262) — miss #4 and the name becomes a state key.
 - **Contract**: builder.contract() (:1056) → makeRunnable toOpenAPI/toMCPTool (runner/RunnableChart.ts:83/153). BYO schema is duck-typed (schema/detect.ts:24).
-- **Scope provider**: ProviderResolver (scope/providers/types.ts:35) via registerScopeResolver (registry.ts:15; exported from /advanced). Simpler: custom scopeFactory (engine/types.ts:73).
-- **Detach driver**: DetachDriver (detach/types.ts:186); no registry — passed explicitly.
+- **Scope provider**: ProviderResolver via registerScopeResolver (exported from /advanced), or a custom scopeFactory. Runtime ownership is explicit in `scope/runtime.ts`: `registerScopeRuntime(scope, { target, handlesAssignments, setBreak? })` maps the user object to its engine port without probing its fields. ScopeFacade, TypedScope, attachScopeMethods and canonical Zod factories auto-register. Other executor/decide/select scopes must register; no duck-typed fallback. One facade per stage owns recording, redaction, argument ownership and commit sealing; adapters use its path-aware accessors instead of writing directly to StageContext.
+- **Detach driver**: `detach/types.ts · DetachDriver`; no driver registry — passed explicitly. The three batching adapters delegate to `detach/drivers/batch.ts · createBatchSchedule`, the one owner of queued work, dispatch, settlement and handle-registry cleanup. A scheduling failure returns a failed handle, never a stuck queue or a parent exception. `validate()` is explicit caller preflight, not an automatic entry-point hook; do not use it instead of containing failures in the driver. No implicit fallback or retry.
 - **Observability dial** (pattern): capture/ primitive + FlowChartExecutorOptions option + snapshot discriminant — FOUR dials now: readTracking/writeTracking/commitValues/writeProvenance (#P1: `'reads-prefix'` stamps `TraceEntry.readKeys` = keys tracked-read before each write; consumed by causalChain `edgeAttribution: 'per-write'` and sliceForKey's default). Propagation is the same 6-site pattern for all four.
 - **Worked example of a new FLOW hook (9.15.0 `onStageRetry`)**: `FlowStageRetryEvent` + `FlowRecorder.onStageRetry?` + `IControlFlowNarrative.onStageRetry` (engine/narrative/types.ts) → `FlowRecorderDispatcher` impl → `NullControlFlowNarrativeGenerator` no-op (interface is REQUIRED there) → **its `HOOKS` entry (recorder/hooks.ts)** → `NarrativeFlowRecorder` sentence (the 8 strategies extend it, so they inherit free) → `CombinedNarrativeRecorder` + `CombinedNarrativeEntry.type` + `NarrativeFormatter.renderRetry` → barrels (the composite fan-out is generated). Retry is the only flow event that fires DURING a stage, so the narrative BUFFERS it via `bufferOp` (the `onEmit` precedent) — pushing it straight to the store would place the line before its own stage header.
 - **Closed seams that look open**: ExecutionEnv (fixed type); decide() operators (evaluator.ts:19 module-private); METHOD_ROUTES; the executeNodeStep phase chain; emit dispatcher (rides scope channel).
@@ -56,15 +56,16 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 - **Trace verbs** (`set|merge|append|delete`, memory/types.ts:42) → ONE law, `memory/verbs.ts` (L1) — F2 deleted the three replicas. `applyVerb` is the ONLY function with an arm per verb (a fifth verb in the union stops compiling there; `TRAITS` — `isTotal` / `recordsTail` — says what a verb IS, pinned against the step), `placeVerb` puts its value or removes the key (`ABSENT`), and two loops fold it: `foldRows` folds ONE bundle's rows into a state with the clone DISCIPLINE as a parameter (`'private'` = the PUBLIC `applySmartMerge`, which keeps its 9.28.0 contract: base deep-cloned, fully detached result — 9.29.0; `'pathCopy'` = the engine's `nextGeneration` — live commit + redacted mirror — and the folds' `applySmartMergeInto` — `stateAt`, `EventLog.materialise`; `'byReference'` = `dryFold`, the admitted record's comparison fold — 9.30.0), and `foldKey` folds ONE path's rows across a log — `commitLogUtils · commitValueAt` (anchored at the last total row) and `slice/elementProvenance · arrayProvenance` (an OBSERVER of that fold: it keeps the births and has no verb switch); causalChain/findLastWriter only match paths. A bundle's merge delta is detached ONCE per bundle (`RecordedPayload`): `deepSmartMerge` dedups an array union BY REFERENCE, so the merge rows of one bundle must see the same objects (a per-row clone made `commitValueAt` double the elements — the 9.29.0 reader bug, fixed here); `foldKey` narrows that copy to its one path. **An unknown verb is REFUSED** (`UnknownVerbError`, public on `/trace`; R2) by `foldRows` (so `applySmartMerge`), `commitValueAt`, `arrayProvenance` — they used to fold it as a `merge`; `time-travel/bundles · bundleRefusal` asks the same `isVerb` and makes it a GAP instead. Pinned: the three old replicas live on as the CONTROL in test/lib/memory/property/verb-law-differential.property.test.ts (kept for the packet's lifetime). The delta encoder keeps VOCABULARY only since 9.30.0 (it picks a verb; its values come from `dryFold` of the stage's 'full' rows — `TransactionBuffer · fullRowsValue`; `replayPathVerbs`/`replayFamilyVerbs` deleted). NOT a second loop (9.22.1): `verbs.ts · supersededByNextSet` — the ONE repeated-path skip (CONSECUTIVE same-path `set` rows: only the last is applied), asked by `foldRows` before its step; its commit-side twin is the last-materialised-path memo in `toChangeOnlyPayload`. Rows are never dropped from the log; a non-consecutive skip is WRONG (a descendant op in between coerces/shells the container) — pinned by test/lib/memory/scenario/repeated-path-byte-identity.test.ts. Since 9.23.0 the clone in that memo loop (and every `structuredClone` in `toDeltaPayload`) is THE clone — the patch trees hold references until commit; no verb switch was touched.
 - **StageContext.commit / dials** → ONE owner since 9.35.0 (F5): `memory/runPolicy.ts` — a frozen `RunPolicy` (the four dials + the `RedactionRule` + the mirror flag) built ONCE by `FlowChartExecutor · createTraverser` (run AND resume), handed to `ExecutionRuntime`, held BY REFERENCE by every `StageContext` (`inheritRun` in createNext/createChild) and passed by `SubflowExecutor · executeSubflow` to the nested runtime BEFORE the seed. A fifth dial = the policy type + its consumer. The old per-dial `use*`/`get*` and `enableRedactedMirror` were removed in 9.36.0 (no compat shims — owner ruling). `commit()`'s FIRST act (9.23.0) is `materialiseWrites` — the `writeTracking` retained form is taken there, once per key, from `_pendingWrites` (bare references + the write-time verdict); anything that reads `_stageWrites` goes through `retainedWrites()` (a non-consuming fold, so a mid-run snapshot is honest), and `discardStaged` drops the pending map with the rest.
 - **runtimeStageId format** (`#`/`/` delimiters) → ONE grammar owner since 9.37.0 (F7): `src/lib/ids/` (L0 leaf: `runtimeStageId.ts` — `parseRuntimeStageId`, `isExecutionKey`, `stageIdOf`, `subflowPathOf`, `refuseReservedId`; `branchSegment.ts` — the `~` grammar). Every parser (ScopeFacade subflow path, subflowResults dual-keying, checkpoint lean-filter, narrative buffering, store keys) calls it; none re-derives the grammar. R5: every id door (22 at build, plus the run-time dynamic-StageNode door) refuses `#` and `/`; stage ids may contain `~`. `TraversalContext` has ONE constructor (`engine/traversalContext.ts`); `depth` = subflow nesting read off the runtimeStageId on every stamp. Brands `RuntimeStageId`/`ExecutionIndex`/`CommitIdx` on `/trace` (types only).
-- **Subflow id prefixing** → ONE prefixer since 9.37.0: `engine/graph/prefixNodeTree.ts`, used by the builder AND the traverser (eager, lazy and `parallelForEach` mounts — lazy/branch roots were unprefixed before 9.37.0, so branch ids collided); change it + stageMap key composition + resume drilling. test/lib/engine/branch-segment-prefixer-equivalence.test.ts stays as a guard.
-- **Checkpoint shape** → `FlowChartExecutor · buildPauseCheckpoint` ↔ `FlowChartExecutor · resume` (validation) ↔ `checkpointSanitize.ts` ↔ `ResumeEntry.plan` (the path's mounts + captures + dispatcher continuations, the `pendingPauses` queue; refused up front when unwalkable, ambiguous, or a pending record is not a sibling) ↔ `SubflowExecutor · executeSubflow` resume hop (seed from the capture in place of the mapper's values — the mapper still runs, for the args — FIRST entry only) ↔ `ChildrenExecutor · raisePauses` (fills `pendingPauses`). 9.28.0 adds ONE optional field, `pendingPauses` (present only when parallel siblings wait); every stored checkpoint enters through `pause/record.ts · decodeCheckpoint` (`checkpointVersion: 1`, one upcaster from unversioned v0 which drops the legacy `continuationStageId`, one validator, one message set; 9.39.0). Pinned: a 9.27.0 checkpoint resumes, test/lib/pause/resume-real-chart-9.27.0-checkpoints.test.ts.
+- **Subflow id prefixing** → ONE prefixer since 9.37.0: `engine/graph/prefixNodeTree.ts`, used by the builder AND the traverser (eager, lazy and `parallelForEach` mounts — lazy/branch roots were unprefixed before 9.37.0, so branch ids collided); change it + stageMap key composition + resume drilling; the builder's eager mounts all go through `FlowChartBuilder · _mountSubflow` (F10). test/lib/engine/branch-segment-prefixer-equivalence.test.ts stays as a guard.
+- **Checkpoint shape** → `runner/checkpoint.ts · buildPauseCheckpoint` (sanitize inside) ↔ `runner/resume.ts · planResume` (validation via `pause/record.ts · decodeCheckpoint`) ↔ `ResumeEntry.plan` (the path's mounts + captures + dispatcher continuations, the `pendingPauses` queue; refused up front when unwalkable, ambiguous, or a pending record is not a sibling) ↔ `SubflowExecutor · executeSubflow` resume hop (seed from the capture in place of the mapper's values — the mapper still runs, for the args — FIRST entry only) ↔ `ChildrenExecutor · raisePauses` (fills `pendingPauses`). 9.28.0 adds ONE optional field, `pendingPauses` (present only when parallel siblings wait); every stored checkpoint enters through `pause/record.ts · decodeCheckpoint` (`checkpointVersion: 1`, one upcaster from unversioned v0 which drops the legacy `continuationStageId`, one validator, one message set; 9.39.0). Pinned: a 9.27.0 checkpoint resumes, test/lib/pause/resume-real-chart-9.27.0-checkpoints.test.ts.
 - **Committed-state writers** (copy-on-write, 9.29.0) → anything that writes into `SharedMemory`'s state, a fold's working copy or the buffer's working copy must copy before it writes: `pathOps · ownSpine` for the containers on the path, `ownedRootOf` for the root, `own`/`adopt` for what it created. An in-place edit of a container it did not create edits every generation sharing it — the counted guard stays green while the generations property fails. A new READ path through `TransactionBuffer` goes through `get` (private after the first write) unless it only compares (`peek`); a read the working copy cannot answer is served from LIVE state (`StageContext · readState`, as on 9.28.0) after `TransactionBuffer · detachBase` gives the diff base a private copy at that path — a private copy of the value handed out instead would change live state wherever 9.28.0 let an in-place edit in (a fork child's read of a parent key). `TransactionBuffer · merge` privatises its base first: `deepSmartMerge` dedups arrays BY REFERENCE, so the identity of the base is part of the bytes.
-- **Redaction** (9.19.0) has ONE owner: `memory/redaction.ts` `RedactionRule` (verdict per user-level path: `clear | whole | fields`), installed on the root StageContext by `ExecutionRuntime.useRedaction` and carried on the run's `RunPolicy` with the four dials (F5). `StageContext.stageWrite` is the ONE write funnel (facade writes, subflow seed, outputMapper merge-back, resume re-seed) and `getValue` retention asks the same rule; the facade asks it for recorder payloads; `SubflowExecutor` for the narrated seed (`retainRecord`). The LAW: a policy covers everything retained or served (log both encodings, mirror, stageReads/stageWrites, narrative, subflow seed + merge-back) and NEVER the live heap or the resume checkpoint. `emitPatterns` is the one separate scrub (emit channel). Two placeholders, historical: log/mirror `'REDACTED'`, scope-tier `'[REDACTED]'`.
+- **Redaction** (9.19.0) has ONE owner: `memory/redaction.ts` `RedactionRule` (verdict per user-level path: `clear | whole | fields`), carried on the run's `RunPolicy` with the four dials (F5). `StageContext.stageWrite` is the ONE write funnel (facade writes, subflow seed, outputMapper merge-back, resume re-seed) and `getValue` retention asks the same rule; the facade asks it for read/write recorder payloads; `SubflowExecutor` for the narrated seed. `FlowchartTraverser.execute` now calls `retainRecord` at root entry/exit BEFORE dispatch/deferred capture (exit inside the failure bracket), so every observer gets the same retained view. An inert rule never enumerates the payload. The contract is named state values and record-root boundary keys/explicit `fields` paths, NOT content scanning: scalar/array root payloads are unchanged; fork output child-ID envelopes require explicit paths. Live inputs/results/state and checkpoints stay real. Diagnostic text/bags, pause payloads and custom recorder data/metadata are outside key redaction; `getSnapshot({ redact: true })` is not a whole-snapshot safe export. `emitPatterns` scrubs matching emitted payloads, not diagnostic retention. Two placeholders, historical: log/mirror `'REDACTED'`, scope-tier `'[REDACTED]'`. See `docs/guides/scope.md` for the bounded contract. Capture the retained boundary at runtime; no second tree walk or recorder-local policy.
+- **Diagnostic retention** → opt-in `RedactionPolicy.diagnostics` uses the same path algorithm in a separate namespace. `DiagnosticCollector` asks the current run rule before merging/storing; its internal retained-write bridge supplies legacy facade emits. Existing writers stay void. Only flow-message description/rationale are payloads; keys/topology/timing stay present. Dynamic capture uses a per-visit engine flag, not a diagnostic bag. A redacted `logs.deciderRationale` also reaches decision explanations. Checkpoints keep retained diagnostic bags but preserve operational state; no retroactive scrub, report expansion or safe-export guarantee. See the scope guide's diagnostic contract.
 - **Traverser phases** → node-shape reads must use eff* overlay accessors (:646-703) or dynamic StageNode returns break; tail continuations must return ContinuationHops or stacks regrow; decider flat-dispatch must keep InvokerStamp or pause loses its invoker.
 
 ## End-to-end trace (seed → decider → loop branch → finish)
 build: flowChart() → FlowChartBuilder.start → addDeciderFunction → branch {loopTo} plants stub `next={id,isLoopRef:true}` (:346) → build() → makeRunnable.
-run: executor.run (FlowChartExecutor.ts:1455): re-entrancy guard → fresh runId → createTraverser (:336; composes scopeFactory: TypedScope + recorders + redaction :379-444) → new ExecutionRuntime (SharedMemory+EventLog+root StageContext) → traverser.execute (:501) fires onRunStart → trampoline executeNode (:738; flat hops, recursion only for forks/subflows/decider-with-next, depth cap 500 counts NESTING per call path — `FlowchartTraverser · nestingDepthOf`, siblings share a level; a reached cap fires onError and rejects run() with `TraversalDepthError`, ChildrenExecutor rethrows it in either mode, 9.40.0).
+run: executor.run (FlowChartExecutor.ts:1455): re-entrancy guard → fresh runId → createTraverser (scope factory composed by `runner/attach.ts · RunObservers · composeScopeFactory`: TypedScope + recorders + redaction) → new ExecutionRuntime (SharedMemory+EventLog+root StageContext) → traverser.execute (:501) fires onRunStart → trampoline executeNode (:738; flat hops, recursion only for forks/subflows/decider-with-next, depth cap 500 counts NESTING per call path — `FlowchartTraverser · nestingDepthOf`, siblings share a level; a reached cap fires onError and rejects run() with `TraversalDepthError`, ChildrenExecutor rethrows it in either mode, 9.40.0).
 per stage: executeNodeStep stamps runtimeStageId (:818) → StageRunner.run: scopeFactory → onStageStart → stage fn (writes stage into TransactionBuffer via StageContext.setObject; onWrite fires live) → onStageEnd → traverser calls context.commit() (:1094) → onCommit → onStageExecuted (narrative flushes buffered ops here).
 decider: DeciderHandler.prepareDispatch (:89) — runs stage, **commits BEFORE branch resolution** (:124), matches branchId, fires onDecision(+evidence) → onStageExecuted('decider') → flat hop with InvokerStamp.
 loop: Phase 6 sees isLoopRef → ContinuationResolver.resolveTarget (:107): id-map lookup, iteration guard (max 1000), onLoop → hop; zero stack, state carries forward (never rewound). A decider WITH its own next runs its branch as a BRANCH FRAME (9.40.0): a `loop`-flagged hop leaves the frame only when an ENCLOSING driver already ran the target — the decider follows it flat and skips its next, which runs once after the non-looping pass; any other jump stays in the frame. A selector's own loopTo resolves the same way and fires onLoop.
@@ -85,7 +86,7 @@ Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging +
 - runId regenerates per run() AND per resume(); recorders detect new runs via traversalContext.runId (engine never resets them).
 - Recorder errors never abort traversal (isolated by `recorder/hooks.ts · fire`; every recorder `ErrorEvent.error` is a `StructuredErrorInfo` built once by `recorderFailureEvent`, inline and deferred alike; `errorInfo` lives in the L0 leaf `src/lib/errors/`).
 - Deferred-observer capture default at the executor tier is **'clone'** (DeferredObserverTier.ts:167), not 'summary'.
-- `getSnapshot().recorders` = ONE row per recorder **id**, across both channels and both delivery tiers (collectRecorderSnapshots, FlowChartExecutor.ts) — a shared-name hook (onError/onPause/onResume) puts one recorder on two lists by design, and rows must survive structuredClone (the narrative row drops `rawValue`, a live reference).
+- `getSnapshot().recorders` = ONE row per recorder **id**, across both channels and both delivery tiers (`runner/snapshot.ts · collectRecorderSnapshots`) — a shared-name hook (onError/onPause/onResume) puts one recorder on two lists by design, and rows must survive structuredClone (the narrative row drops `rawValue`, a live reference).
 
 ## Landmines
 1. **NOT a landmine any more (9.24.0), recorded because it was one for eight releases:** TypedScope's set trap used to JSON-round-trip the ASSIGNED VALUE of every object write (Date→string, Map→{}, own undefined dropped) while `$setValue` did not — two write paths, two byte shapes. The round-trip existed only to keep the scope's own Proxies out of the buffer; `reactive/handles.ts` recognises them now (O(1)), so `writeTraps.ts · sinkSetTrap`, `arrayTraps.ts` (index set, `MUTATING_METHODS` arguments, element-proxy leaf) and `createTypedScope · assignStateKey` hand the value to the sink AS ASSIGNED and the buffer's `structuredClone` at commit is the one detaching step — both doors store the same bytes (pinned: test/lib/reactive/scenario/assigned-value-only.test.ts, a fast-check property over `fc.jsonValue()`). Consequences to keep in mind: (a) a value nothing can clone — a function, a foreign Proxy such as a framework's reactive object — now fails the stage at COMMIT through the trap too (it always did through `$setValue`; the trap used to JSON-copy it silently, dropping the function); (b) `s.k = o; o.x = 1` commits `x: 1` — what the stage reads back — the same law 9.23.0 gave `$setValue`, and since 9.30.0 (owner ruling R1, the admitted record) so does `$update`: an in-place edit of a merged value within its stage is recorded; (c) the shape work the round-trip did for free stays explicit: `delete arr[i]`, a write past the end and `length` growth spell holes as `null` (`arrayTraps` · `fillHoles`). The surrounding state reaches the buffer by reference and is detached with `structuredClone` at commit (9.22.0 / 9.23.0).

package/README.md

@@ -32,6 +32,8 @@
 npm install footprintjs
 ```
 
+Requires **Node.js 22 or newer**. CI tests Node 22 and 24; Node 24 LTS is the default for development, documentation builds and publishing. See [Contributing](CONTRIBUTING.md#development-setup) for setup instructions.
+
 ---
 
 ## The Problem
@@ -244,13 +246,15 @@ import { flowChart } from 'footprintjs';
 
 ## Dev Mode
 
-footprintjs ships with developer-only diagnostics that are OFF in production (zero overhead). Turn them on during development to catch mistakes early:
+footprintjs ships with developer-only diagnostics that are OFF by default. Turn them on during development to catch mistakes early. Pass your application's environment setting to this helper (for example, `process.env.NODE_ENV` in Node.js):
 
 ```ts
 import { enableDevMode } from 'footprintjs';
 
-if (process.env.NODE_ENV !== 'production') {
-  enableDevMode();
+function configureDiagnostics(environment: string | undefined) {
+  if (environment !== 'production') {
+    enableDevMode();
+  }
 }
 ```
 

package/dist/advanced.js

@@ -21,7 +21,7 @@
  * Import via: import { ... } from 'footprint/advanced'
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChildrenExecutor = exports.applyOutputMapping = exports.NullControlFlowNarrativeGenerator = exports.isStageNodeReturn = exports.FlowchartTraverser = exports.valueBehind = exports.unwrapHandles = exports.shouldWrapWithProxy = exports.SCOPE_METHOD_NAMES = exports.joinPath = exports.isHandle = exports.createArrayProxy = exports.buildNestedPatch = exports.BREAK_SETTER = exports.runPolicy = exports.DEFAULT_RUN_POLICY = exports.ExecutionRuntime = exports.toScopeFactory = exports.resolveScopeProvider = exports.registerScopeResolver = exports.makeFactoryProvider = exports.makeClassProvider = exports.looksLikeFactory = exports.looksLikeClassCtor = exports.isSubclassOfScopeFacade = exports.attachScopeMethods = exports.ScopeFacade = exports.createProtectedScope = exports.createErrorMessage = exports.createTypedScopeFactory = exports.specToStageNode = exports.SelectorFnList = exports.DeciderList = exports.ArrayMergeMode = exports.updateValue = exports.updateNestedValue = exports.setNestedValue = exports.redactPatch = exports.pathSegments = exports.normalisePath = exports.getRunAndGlobalPaths = exports.getNestedValue = exports.deepSmartMerge = exports.applySmartMerge = exports.RedactionRule = exports.DiagnosticCollector = exports.TransactionBuffer = exports.EventLog = exports.StageContext = exports.SharedMemory = void 0;
+exports.ChildrenExecutor = exports.applyOutputMapping = exports.NullControlFlowNarrativeGenerator = exports.isStageNodeReturn = exports.FlowchartTraverser = exports.valueBehind = exports.unwrapHandles = exports.shouldWrapWithProxy = exports.SCOPE_METHOD_NAMES = exports.joinPath = exports.isHandle = exports.createArrayProxy = exports.buildNestedPatch = exports.runPolicy = exports.DEFAULT_RUN_POLICY = exports.ExecutionRuntime = exports.registerScopeRuntime = exports.toScopeFactory = exports.resolveScopeProvider = exports.registerScopeResolver = exports.makeFactoryProvider = exports.makeClassProvider = exports.looksLikeFactory = exports.looksLikeClassCtor = exports.isSubclassOfScopeFacade = exports.attachScopeMethods = exports.ScopeFacade = exports.createProtectedScope = exports.createErrorMessage = exports.createTypedScopeFactory = exports.specToStageNode = exports.SelectorFnList = exports.DeciderList = exports.ArrayMergeMode = exports.updateValue = exports.updateNestedValue = exports.setNestedValue = exports.redactPatch = exports.pathSegments = exports.normalisePath = exports.getRunAndGlobalPaths = exports.getNestedValue = exports.deepSmartMerge = exports.applySmartMerge = exports.RedactionRule = exports.DiagnosticCollector = exports.TransactionBuffer = exports.EventLog = exports.StageContext = exports.SharedMemory = void 0;
 exports.zodToJsonSchema = exports.normalizeSchema = exports.evaluateFilter = exports.findLastWriter = exports.findCommits = exports.findCommit = exports.parseRuntimeStageId = exports.createExecutionCounter = exports.buildRuntimeStageId = exports.SubflowExecutor = exports.StageRunner = exports.SelectorHandler = exports.seedSubflowGlobalStore = exports.RuntimeStructureManager = exports.ResumeEntry = exports.NodeResolver = exports.getInitialScopeValues = exports.extractParentScopeValues = exports.DEFAULT_MAX_ITERATIONS = exports.DeciderHandler = exports.createSubflowHandlerDeps = exports.ContinuationResolver = exports.computeNodeType = void 0;
 var index_js_1 = require("./lib/memory/index.js");
 Object.defineProperty(exports, "SharedMemory", { enumerable: true, get: function () { return index_js_1.SharedMemory; } });
@@ -67,13 +67,14 @@ Object.defineProperty(exports, "makeFactoryProvider", { enumerable: true, get: f
 Object.defineProperty(exports, "registerScopeResolver", { enumerable: true, get: function () { return index_js_10.registerScopeResolver; } });
 Object.defineProperty(exports, "resolveScopeProvider", { enumerable: true, get: function () { return index_js_10.resolveScopeProvider; } });
 Object.defineProperty(exports, "toScopeFactory", { enumerable: true, get: function () { return index_js_10.toScopeFactory; } });
+var runtime_js_1 = require("./lib/scope/runtime.js");
+Object.defineProperty(exports, "registerScopeRuntime", { enumerable: true, get: function () { return runtime_js_1.registerScopeRuntime; } });
 var index_js_11 = require("./lib/runner/index.js");
 Object.defineProperty(exports, "ExecutionRuntime", { enumerable: true, get: function () { return index_js_11.ExecutionRuntime; } });
 var index_js_12 = require("./lib/memory/index.js");
 Object.defineProperty(exports, "DEFAULT_RUN_POLICY", { enumerable: true, get: function () { return index_js_12.DEFAULT_RUN_POLICY; } });
 Object.defineProperty(exports, "runPolicy", { enumerable: true, get: function () { return index_js_12.runPolicy; } });
 var index_js_13 = require("./lib/reactive/index.js");
-Object.defineProperty(exports, "BREAK_SETTER", { enumerable: true, get: function () { return index_js_13.BREAK_SETTER; } });
 Object.defineProperty(exports, "buildNestedPatch", { enumerable: true, get: function () { return index_js_13.buildNestedPatch; } });
 Object.defineProperty(exports, "createArrayProxy", { enumerable: true, get: function () { return index_js_13.createArrayProxy; } });
 Object.defineProperty(exports, "isHandle", { enumerable: true, get: function () { return index_js_13.isHandle; } });
@@ -125,4 +126,4 @@ Object.defineProperty(exports, "evaluateFilter", { enumerable: true, get: functi
 var index_js_19 = require("./lib/contract/index.js");
 Object.defineProperty(exports, "normalizeSchema", { enumerable: true, get: function () { return index_js_19.normalizeSchema; } });
 Object.defineProperty(exports, "zodToJsonSchema", { enumerable: true, get: function () { return index_js_19.zodToJsonSchema; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced.js","sourceRoot":"","sources":["../src/advanced.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;AACH;;;;;;;GAOG;;;;AAqBH,kDAAqD;AAA5C,wGAAA,YAAY,OAAA;AACrB,kDAAqD;AAA5C,wGAAA,YAAY,OAAA;AACrB,kDAAiD;AAAxC,oGAAA,QAAQ,OAAA;AACjB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAC1B,kDAA4D;AAAnD,+GAAA,mBAAmB,OAAA;AAC5B,kDAAsD;AAA7C,yGAAA,aAAa,OAAA;AACtB,kDAW+B;AAV7B,2GAAA,eAAe,OAAA;AACf,0GAAA,cAAc,OAAA;AACd,0GAAA,cAAc,OAAA;AACd,gHAAA,oBAAoB,OAAA;AACpB,yGAAA,aAAa,OAAA;AACb,wGAAA,YAAY,OAAA;AACZ,uGAAA,WAAW,OAAA;AACX,0GAAA,cAAc,OAAA;AACd,6GAAA,iBAAiB,OAAA;AACjB,uGAAA,WAAW,OAAA;AAuBb,mDAAsG;AAA7F,0GAAA,cAAc,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,2GAAA,eAAe,OAAA;AACrE,qEAA0E;AAAjE,4HAAA,uBAAuB,OAAA;AAahC,iDAA6F;AAApF,8GAAA,kBAAkB,OAAA;AAAE,gHAAA,oBAAoB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAC9D,kDAU8B;AAT5B,+GAAA,kBAAkB,OAAA;AAClB,oHAAA,uBAAuB,OAAA;AACvB,+GAAA,kBAAkB,OAAA;AAClB,6GAAA,gBAAgB,OAAA;AAChB,8GAAA,iBAAiB,OAAA;AACjB,gHAAA,mBAAmB,OAAA;AACnB,kHAAA,qBAAqB,OAAA;AACrB,iHAAA,oBAAoB,OAAA;AACpB,2GAAA,cAAc,OAAA;AAyBhB,mDAAyD;AAAhD,6GAAA,gBAAgB,OAAA;AAGzB,mDAAsE;AAA7D,+GAAA,kBAAkB,OAAA;AAAE,sGAAA,SAAS,OAAA;AAOtC,qDAUiC;AAT/B,yGAAA,YAAY,OAAA;AACZ,6GAAA,gBAAgB,OAAA;AAChB,6GAAA,gBAAgB,OAAA;AAChB,qGAAA,QAAQ,OAAA;AACR,qGAAA,QAAQ,OAAA;AACR,+GAAA,kBAAkB,OAAA;AAClB,gHAAA,mBAAmB,OAAA;AACnB,0GAAA,aAAa,OAAA;AACb,wGAAA,WAAW,OAAA;AASb,mDAA2D;AAAlD,+GAAA,kBAAkB,OAAA;AAC3B,mDAA0D;AAAjD,8GAAA,iBAAiB,OAAA;AAmB1B,mDAA0E;AAAjE,8HAAA,iCAAiC,OAAA;AAI1C,mDAiB+B;AAhB7B,+GAAA,kBAAkB,OAAA;AAClB,6GAAA,gBAAgB,OAAA;AAChB,4GAAA,eAAe,OAAA;AACf,iHAAA,oBAAoB,OAAA;AACpB,qHAAA,wBAAwB,OAAA;AACxB,2GAAA,cAAc,OAAA;AACd,mHAAA,sBAAsB,OAAA;AACtB,qHAAA,wBAAwB,OAAA;AACxB,kHAAA,qBAAqB,OAAA;AACrB,yGAAA,YAAY,OAAA;AACZ,wGAAA,WAAW,OAAA;AACX,oHAAA,uBAAuB,OAAA;AACvB,mHAAA,sBAAsB,OAAA;AACtB,4GAAA,eAAe,OAAA;AACf,wGAAA,WAAW,OAAA;AACX,4GAAA,eAAe,OAAA;AAKjB,iEAA+G;AAAtG,wHAAA,mBAAmB,OAAA;AAAE,2HAAA,sBAAsB,OAAA;AAAE,wHAAA,mBAAmB,OAAA;AACzE,oEAAyF;AAAhF,+GAAA,UAAU,OAAA;AAAE,gHAAA,WAAW,OAAA;AAAE,mHAAA,cAAc,OAAA;AAUhD,mDAAuD;AAA9C,2GAAA,cAAc,OAAA;AAEvB,+EAA+E;AAC/E,6DAA6D;AAC7D,+EAA+E;AAC/E,0EAA0E;AAC1E,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,qDAA2E;AAAlE,4GAAA,eAAe,OAAA;AAAE,4GAAA,eAAe,OAAA","sourcesContent":["/**\n * footprintjs/advanced — Low-level internals for custom execution engines and testing.\n *\n * Most users never need this. Use `footprintjs` (main) instead.\n * This entry point exposes `SharedMemory`, `StageContext`, `FlowchartTraverser`,\n * and other primitives that power the engine.\n *\n * ```ts\n * import { SharedMemory, StageContext } from 'footprintjs/advanced';\n * ```\n *\n * @module advanced\n */\n/**\n * FootPrint — Advanced / Internal API\n *\n * These exports are for advanced use cases, testing, and building\n * custom execution engines. Most users should use the main 'footprint' entry point.\n *\n * Import via: import { ... } from 'footprint/advanced'\n */\n\n// ============================================================================\n// Memory — Low-level transactional state primitives\n// ============================================================================\n\nexport type {\n  CommitBundle,\n  FlowControlType,\n  FlowMessage,\n  MemoryPatch,\n  ReadSummaryMarker,\n  ReadTrackingMode,\n  RetentionPolicy,\n  StageSnapshot,\n  TraceEntry,\n  UntrackedSource,\n  WriteSummaryMarker,\n  WriteTrackingMode,\n} from './lib/memory/index.js';\nexport type { RedactionVerdict } from './lib/memory/index.js';\nexport { SharedMemory } from './lib/memory/index.js';\nexport { StageContext } from './lib/memory/index.js';\nexport { EventLog } from './lib/memory/index.js';\nexport { TransactionBuffer } from './lib/memory/index.js';\nexport { DiagnosticCollector } from './lib/memory/index.js';\nexport { RedactionRule } from './lib/memory/index.js';\nexport {\n  applySmartMerge,\n  deepSmartMerge,\n  getNestedValue,\n  getRunAndGlobalPaths,\n  normalisePath,\n  pathSegments,\n  redactPatch,\n  setNestedValue,\n  updateNestedValue,\n  updateValue,\n} from './lib/memory/index.js';\n\n// ============================================================================\n// Builder — Types and internals\n// ============================================================================\n\nexport type {\n  ExecOptions,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  ScopeProtectionMode,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFn,\n  StageNode,\n  StreamCallback,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n  SubflowRef,\n} from './lib/builder/index.js';\nexport { ArrayMergeMode, DeciderList, SelectorFnList, specToStageNode } from './lib/builder/index.js';\nexport { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';\n\n// ============================================================================\n// Scope — Providers, protection, recorder options, and event types\n// ============================================================================\n\nexport type {\n  ProviderResolver,\n  ResolveOptions,\n  ScopeProvider,\n  StageContextLike,\n  StrictMode,\n} from './lib/scope/index.js';\nexport { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';\nexport {\n  attachScopeMethods,\n  isSubclassOfScopeFacade,\n  looksLikeClassCtor,\n  looksLikeFactory,\n  makeClassProvider,\n  makeFactoryProvider,\n  registerScopeResolver,\n  resolveScopeProvider,\n  toScopeFactory,\n} from './lib/scope/index.js';\n\n// ScopeRecorder config/option types\nexport type {\n  AggregatedMetrics,\n  DebugEntry,\n  DebugRecorderOptions,\n  DebugVerbosity,\n  RecorderContext,\n  StageEvent,\n  StageMetrics,\n} from './lib/scope/index.js';\n// `DefineScopeOptions` (zod scope options) moved to 'footprintjs/zod'.\n\n// Zod internals moved to the opt-in `footprintjs/zod` entry (keeps zod — an\n// optional peer — out of the `footprintjs/advanced` load path). Import\n// createScopeProxyFromZod / defineScopeSchema / isScopeSchema / ZodScopeResolver\n// from 'footprintjs/zod'.\n\n// ============================================================================\n// Runner — Internals\n// ============================================================================\n\nexport type { RuntimeSnapshot } from './lib/runner/index.js';\nexport { ExecutionRuntime } from './lib/runner/index.js';\n/** The run's policy an `ExecutionRuntime` is constructed with (F5). */\nexport type { RunPolicy } from './lib/memory/index.js';\nexport { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';\n\n// ============================================================================\n// Reactive — TypedScope internals (for custom proxy implementations)\n// ============================================================================\n\nexport type { ReactiveOptions, ReactiveTarget } from './lib/reactive/index.js';\nexport {\n  BREAK_SETTER,\n  buildNestedPatch,\n  createArrayProxy,\n  isHandle,\n  joinPath,\n  SCOPE_METHOD_NAMES,\n  shouldWrapWithProxy,\n  unwrapHandles,\n  valueBehind,\n} from './lib/reactive/index.js';\n\n// ============================================================================\n// Engine — DFS graph traversal internals\n// ============================================================================\n\nexport type { TraverserOptions } from './lib/engine/index.js';\nexport type { Decider } from './lib/engine/index.js';\nexport { FlowchartTraverser } from './lib/engine/index.js';\nexport { isStageNodeReturn } from './lib/engine/index.js';\n\n// Narrative internals\nexport type { IControlFlowNarrative } from './lib/engine/index.js';\nexport type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './lib/engine/index.js';\nexport type {\n  BranchResult,\n  BranchResults,\n  SerializedPipelineStructure as EngineSerializedPipelineStructure,\n  HandlerDeps,\n  IExecutionRuntime,\n  NodeResultType,\n  RuntimeStructureMetadata,\n  ScopeFactory,\n  SerializedPipelineNode,\n  StageFunction,\n  SubflowResult,\n  TraversalResult,\n} from './lib/engine/index.js';\nexport { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';\n\n// Handlers (testing / custom engines)\nexport type { ExecuteNodeFn, QueuedPause, ResumeHop, RunStageFn } from './lib/engine/index.js';\nexport {\n  applyOutputMapping,\n  ChildrenExecutor,\n  computeNodeType,\n  ContinuationResolver,\n  createSubflowHandlerDeps,\n  DeciderHandler,\n  DEFAULT_MAX_ITERATIONS,\n  extractParentScopeValues,\n  getInitialScopeValues,\n  NodeResolver,\n  ResumeEntry,\n  RuntimeStructureManager,\n  seedSubflowGlobalStore,\n  SelectorHandler,\n  StageRunner,\n  SubflowExecutor,\n} from './lib/engine/index.js';\n\n// Trace utilities — re-exported here for convenience. Canonical path: 'footprintjs/trace'\nexport type { ExecutionCounter } from './lib/ids/runtimeStageId.js';\nexport { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';\n\n// ============================================================================\n// Decide — pure guard evaluation (for custom availability/decision engines)\n// ============================================================================\n// evaluateFilter is engine-free: a pure function over (getValue, isRedacted)\n// callbacks that evaluates a WhereFilter and returns per-condition evidence.\n// External drivers (e.g. hcifootprint's available()) evaluate edge guards with\n// it outside any run — no scope, no commit, worker-safe.\nexport type { FilterCondition } from './lib/decide/index.js';\nexport { evaluateFilter } from './lib/decide/index.js';\n\n// ============================================================================\n// Contract — schema normalization (for custom tool emitters)\n// ============================================================================\n// Pure chart-metadata helpers behind toMCPTool/toOpenAPI. Custom emitters\n// (per-edge MCP descriptors) reuse the Zod→JSON-Schema conversion without\n// importing the runner. Gate inputs with detectSchema (main barrel): a\n// non-Zod 'parseable' schema (yup/superstruct) passes through unconverted.\nexport { normalizeSchema, zodToJsonSchema } from './lib/contract/index.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced.js","sourceRoot":"","sources":["../src/advanced.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;AACH;;;;;;;GAOG;;;;AAqBH,kDAAqD;AAA5C,wGAAA,YAAY,OAAA;AACrB,kDAAqD;AAA5C,wGAAA,YAAY,OAAA;AACrB,kDAAiD;AAAxC,oGAAA,QAAQ,OAAA;AACjB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAC1B,kDAA4D;AAAnD,+GAAA,mBAAmB,OAAA;AAC5B,kDAAsD;AAA7C,yGAAA,aAAa,OAAA;AACtB,kDAW+B;AAV7B,2GAAA,eAAe,OAAA;AACf,0GAAA,cAAc,OAAA;AACd,0GAAA,cAAc,OAAA;AACd,gHAAA,oBAAoB,OAAA;AACpB,yGAAA,aAAa,OAAA;AACb,wGAAA,YAAY,OAAA;AACZ,uGAAA,WAAW,OAAA;AACX,0GAAA,cAAc,OAAA;AACd,6GAAA,iBAAiB,OAAA;AACjB,uGAAA,WAAW,OAAA;AAuBb,mDAAsG;AAA7F,0GAAA,cAAc,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,2GAAA,eAAe,OAAA;AACrE,qEAA0E;AAAjE,4HAAA,uBAAuB,OAAA;AAahC,iDAA6F;AAApF,8GAAA,kBAAkB,OAAA;AAAE,gHAAA,oBAAoB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAC9D,kDAU8B;AAT5B,+GAAA,kBAAkB,OAAA;AAClB,oHAAA,uBAAuB,OAAA;AACvB,+GAAA,kBAAkB,OAAA;AAClB,6GAAA,gBAAgB,OAAA;AAChB,8GAAA,iBAAiB,OAAA;AACjB,gHAAA,mBAAmB,OAAA;AACnB,kHAAA,qBAAqB,OAAA;AACrB,iHAAA,oBAAoB,OAAA;AACpB,2GAAA,cAAc,OAAA;AAGhB,qDAA8D;AAArD,kHAAA,oBAAoB,OAAA;AAwB7B,mDAAyD;AAAhD,6GAAA,gBAAgB,OAAA;AAGzB,mDAAsE;AAA7D,+GAAA,kBAAkB,OAAA;AAAE,sGAAA,SAAS,OAAA;AAOtC,qDASiC;AAR/B,6GAAA,gBAAgB,OAAA;AAChB,6GAAA,gBAAgB,OAAA;AAChB,qGAAA,QAAQ,OAAA;AACR,qGAAA,QAAQ,OAAA;AACR,+GAAA,kBAAkB,OAAA;AAClB,gHAAA,mBAAmB,OAAA;AACnB,0GAAA,aAAa,OAAA;AACb,wGAAA,WAAW,OAAA;AASb,mDAA2D;AAAlD,+GAAA,kBAAkB,OAAA;AAC3B,mDAA0D;AAAjD,8GAAA,iBAAiB,OAAA;AAmB1B,mDAA0E;AAAjE,8HAAA,iCAAiC,OAAA;AAI1C,mDAiB+B;AAhB7B,+GAAA,kBAAkB,OAAA;AAClB,6GAAA,gBAAgB,OAAA;AAChB,4GAAA,eAAe,OAAA;AACf,iHAAA,oBAAoB,OAAA;AACpB,qHAAA,wBAAwB,OAAA;AACxB,2GAAA,cAAc,OAAA;AACd,mHAAA,sBAAsB,OAAA;AACtB,qHAAA,wBAAwB,OAAA;AACxB,kHAAA,qBAAqB,OAAA;AACrB,yGAAA,YAAY,OAAA;AACZ,wGAAA,WAAW,OAAA;AACX,oHAAA,uBAAuB,OAAA;AACvB,mHAAA,sBAAsB,OAAA;AACtB,4GAAA,eAAe,OAAA;AACf,wGAAA,WAAW,OAAA;AACX,4GAAA,eAAe,OAAA;AAKjB,iEAA+G;AAAtG,wHAAA,mBAAmB,OAAA;AAAE,2HAAA,sBAAsB,OAAA;AAAE,wHAAA,mBAAmB,OAAA;AACzE,oEAAyF;AAAhF,+GAAA,UAAU,OAAA;AAAE,gHAAA,WAAW,OAAA;AAAE,mHAAA,cAAc,OAAA;AAUhD,mDAAuD;AAA9C,2GAAA,cAAc,OAAA;AAEvB,+EAA+E;AAC/E,6DAA6D;AAC7D,+EAA+E;AAC/E,0EAA0E;AAC1E,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,qDAA2E;AAAlE,4GAAA,eAAe,OAAA;AAAE,4GAAA,eAAe,OAAA","sourcesContent":["/**\n * footprintjs/advanced — Low-level internals for custom execution engines and testing.\n *\n * Most users never need this. Use `footprintjs` (main) instead.\n * This entry point exposes `SharedMemory`, `StageContext`, `FlowchartTraverser`,\n * and other primitives that power the engine.\n *\n * ```ts\n * import { SharedMemory, StageContext } from 'footprintjs/advanced';\n * ```\n *\n * @module advanced\n */\n/**\n * FootPrint — Advanced / Internal API\n *\n * These exports are for advanced use cases, testing, and building\n * custom execution engines. Most users should use the main 'footprint' entry point.\n *\n * Import via: import { ... } from 'footprint/advanced'\n */\n\n// ============================================================================\n// Memory — Low-level transactional state primitives\n// ============================================================================\n\nexport type {\n  CommitBundle,\n  FlowControlType,\n  FlowMessage,\n  MemoryPatch,\n  ReadSummaryMarker,\n  ReadTrackingMode,\n  RetentionPolicy,\n  StageSnapshot,\n  TraceEntry,\n  UntrackedSource,\n  WriteSummaryMarker,\n  WriteTrackingMode,\n} from './lib/memory/index.js';\nexport type { RedactionVerdict } from './lib/memory/index.js';\nexport { SharedMemory } from './lib/memory/index.js';\nexport { StageContext } from './lib/memory/index.js';\nexport { EventLog } from './lib/memory/index.js';\nexport { TransactionBuffer } from './lib/memory/index.js';\nexport { DiagnosticCollector } from './lib/memory/index.js';\nexport { RedactionRule } from './lib/memory/index.js';\nexport {\n  applySmartMerge,\n  deepSmartMerge,\n  getNestedValue,\n  getRunAndGlobalPaths,\n  normalisePath,\n  pathSegments,\n  redactPatch,\n  setNestedValue,\n  updateNestedValue,\n  updateValue,\n} from './lib/memory/index.js';\n\n// ============================================================================\n// Builder — Types and internals\n// ============================================================================\n\nexport type {\n  ExecOptions,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  ScopeProtectionMode,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFn,\n  StageNode,\n  StreamCallback,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n  SubflowRef,\n} from './lib/builder/index.js';\nexport { ArrayMergeMode, DeciderList, SelectorFnList, specToStageNode } from './lib/builder/index.js';\nexport { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';\n\n// ============================================================================\n// Scope — Providers, protection, recorder options, and event types\n// ============================================================================\n\nexport type {\n  ProviderResolver,\n  ResolveOptions,\n  ScopeProvider,\n  StageContextLike,\n  StrictMode,\n} from './lib/scope/index.js';\nexport { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';\nexport {\n  attachScopeMethods,\n  isSubclassOfScopeFacade,\n  looksLikeClassCtor,\n  looksLikeFactory,\n  makeClassProvider,\n  makeFactoryProvider,\n  registerScopeResolver,\n  resolveScopeProvider,\n  toScopeFactory,\n} from './lib/scope/index.js';\nexport type { ScopeRuntime, ScopeRuntimeTarget } from './lib/scope/runtime.js';\nexport { registerScopeRuntime } from './lib/scope/runtime.js';\n\n// ScopeRecorder config/option types\nexport type {\n  AggregatedMetrics,\n  DebugEntry,\n  DebugRecorderOptions,\n  DebugVerbosity,\n  RecorderContext,\n  StageEvent,\n  StageMetrics,\n} from './lib/scope/index.js';\n// `DefineScopeOptions` (zod scope options) moved to 'footprintjs/zod'.\n\n// Zod internals moved to the opt-in `footprintjs/zod` entry (keeps zod — an\n// optional peer — out of the `footprintjs/advanced` load path). Import\n// createScopeProxyFromZod / defineScopeSchema / isScopeSchema / ZodScopeResolver\n// from 'footprintjs/zod'.\n\n// ============================================================================\n// Runner — Internals\n// ============================================================================\n\nexport type { RuntimeSnapshot } from './lib/runner/index.js';\nexport { ExecutionRuntime } from './lib/runner/index.js';\n/** The run's policy an `ExecutionRuntime` is constructed with (F5). */\nexport type { RunPolicy } from './lib/memory/index.js';\nexport { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';\n\n// ============================================================================\n// Reactive — TypedScope internals (for custom proxy implementations)\n// ============================================================================\n\nexport type { ReactiveOptions, ReactiveTarget } from './lib/reactive/index.js';\nexport {\n  buildNestedPatch,\n  createArrayProxy,\n  isHandle,\n  joinPath,\n  SCOPE_METHOD_NAMES,\n  shouldWrapWithProxy,\n  unwrapHandles,\n  valueBehind,\n} from './lib/reactive/index.js';\n\n// ============================================================================\n// Engine — DFS graph traversal internals\n// ============================================================================\n\nexport type { TraverserOptions } from './lib/engine/index.js';\nexport type { Decider } from './lib/engine/index.js';\nexport { FlowchartTraverser } from './lib/engine/index.js';\nexport { isStageNodeReturn } from './lib/engine/index.js';\n\n// Narrative internals\nexport type { IControlFlowNarrative } from './lib/engine/index.js';\nexport type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './lib/engine/index.js';\nexport type {\n  BranchResult,\n  BranchResults,\n  SerializedPipelineStructure as EngineSerializedPipelineStructure,\n  HandlerDeps,\n  IExecutionRuntime,\n  NodeResultType,\n  RuntimeStructureMetadata,\n  ScopeFactory,\n  SerializedPipelineNode,\n  StageFunction,\n  SubflowResult,\n  TraversalResult,\n} from './lib/engine/index.js';\nexport { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';\n\n// Handlers (testing / custom engines)\nexport type { ExecuteNodeFn, QueuedPause, ResumeHop, RunStageFn } from './lib/engine/index.js';\nexport {\n  applyOutputMapping,\n  ChildrenExecutor,\n  computeNodeType,\n  ContinuationResolver,\n  createSubflowHandlerDeps,\n  DeciderHandler,\n  DEFAULT_MAX_ITERATIONS,\n  extractParentScopeValues,\n  getInitialScopeValues,\n  NodeResolver,\n  ResumeEntry,\n  RuntimeStructureManager,\n  seedSubflowGlobalStore,\n  SelectorHandler,\n  StageRunner,\n  SubflowExecutor,\n} from './lib/engine/index.js';\n\n// Trace utilities — re-exported here for convenience. Canonical path: 'footprintjs/trace'\nexport type { ExecutionCounter } from './lib/ids/runtimeStageId.js';\nexport { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';\n\n// ============================================================================\n// Decide — pure guard evaluation (for custom availability/decision engines)\n// ============================================================================\n// evaluateFilter is engine-free: a pure function over (getValue, isRedacted)\n// callbacks that evaluates a WhereFilter and returns per-condition evidence.\n// External drivers (e.g. hcifootprint's available()) evaluate edge guards with\n// it outside any run — no scope, no commit, worker-safe.\nexport type { FilterCondition } from './lib/decide/index.js';\nexport { evaluateFilter } from './lib/decide/index.js';\n\n// ============================================================================\n// Contract — schema normalization (for custom tool emitters)\n// ============================================================================\n// Pure chart-metadata helpers behind toMCPTool/toOpenAPI. Custom emitters\n// (per-edge MCP descriptors) reuse the Zod→JSON-Schema conversion without\n// importing the runner. Gate inputs with detectSchema (main barrel): a\n// non-Zod 'parseable' schema (yup/superstruct) passes through unconverted.\nexport { normalizeSchema, zodToJsonSchema } from './lib/contract/index.js';\n"]}

package/dist/esm/advanced.d.ts

@@ -34,6 +34,8 @@ export { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';
 export type { ProviderResolver, ResolveOptions, ScopeProvider, StageContextLike, StrictMode, } from './lib/scope/index.js';
 export { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';
 export { attachScopeMethods, isSubclassOfScopeFacade, looksLikeClassCtor, looksLikeFactory, makeClassProvider, makeFactoryProvider, registerScopeResolver, resolveScopeProvider, toScopeFactory, } from './lib/scope/index.js';
+export type { ScopeRuntime, ScopeRuntimeTarget } from './lib/scope/runtime.js';
+export { registerScopeRuntime } from './lib/scope/runtime.js';
 export type { AggregatedMetrics, DebugEntry, DebugRecorderOptions, DebugVerbosity, RecorderContext, StageEvent, StageMetrics, } from './lib/scope/index.js';
 export type { RuntimeSnapshot } from './lib/runner/index.js';
 export { ExecutionRuntime } from './lib/runner/index.js';
@@ -41,7 +43,7 @@ export { ExecutionRuntime } from './lib/runner/index.js';
 export type { RunPolicy } from './lib/memory/index.js';
 export { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';
 export type { ReactiveOptions, ReactiveTarget } from './lib/reactive/index.js';
-export { BREAK_SETTER, buildNestedPatch, createArrayProxy, isHandle, joinPath, SCOPE_METHOD_NAMES, shouldWrapWithProxy, unwrapHandles, valueBehind, } from './lib/reactive/index.js';
+export { buildNestedPatch, createArrayProxy, isHandle, joinPath, SCOPE_METHOD_NAMES, shouldWrapWithProxy, unwrapHandles, valueBehind, } from './lib/reactive/index.js';
 export type { TraverserOptions } from './lib/engine/index.js';
 export type { Decider } from './lib/engine/index.js';
 export { FlowchartTraverser } from './lib/engine/index.js';

package/dist/esm/advanced.js

@@ -30,9 +30,10 @@ export { ArrayMergeMode, DeciderList, SelectorFnList, specToStageNode } from './
 export { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';
 export { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';
 export { attachScopeMethods, isSubclassOfScopeFacade, looksLikeClassCtor, looksLikeFactory, makeClassProvider, makeFactoryProvider, registerScopeResolver, resolveScopeProvider, toScopeFactory, } from './lib/scope/index.js';
+export { registerScopeRuntime } from './lib/scope/runtime.js';
 export { ExecutionRuntime } from './lib/runner/index.js';
 export { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';
-export { BREAK_SETTER, buildNestedPatch, createArrayProxy, isHandle, joinPath, SCOPE_METHOD_NAMES, shouldWrapWithProxy, unwrapHandles, valueBehind, } from './lib/reactive/index.js';
+export { buildNestedPatch, createArrayProxy, isHandle, joinPath, SCOPE_METHOD_NAMES, shouldWrapWithProxy, unwrapHandles, valueBehind, } from './lib/reactive/index.js';
 export { FlowchartTraverser } from './lib/engine/index.js';
 export { isStageNodeReturn } from './lib/engine/index.js';
 export { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';
@@ -48,4 +49,4 @@ export { evaluateFilter } from './lib/decide/index.js';
 // importing the runner. Gate inputs with detectSchema (main barrel): a
 // non-Zod 'parseable' schema (yup/superstruct) passes through unconverted.
 export { normalizeSchema, zodToJsonSchema } from './lib/contract/index.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced.js","sourceRoot":"","sources":["../../src/advanced.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH;;;;;;;GAOG;AAqBH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,WAAW,GACZ,MAAM,uBAAuB,CAAC;AAsB/B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACtG,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAa1E,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAwB9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAOtE,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAmB1D,OAAO,EAAE,iCAAiC,EAAE,MAAM,uBAAuB,CAAC;AAI1E,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,wBAAwB,EACxB,cAAc,EACd,sBAAsB,EACtB,wBAAwB,EACxB,qBAAqB,EACrB,YAAY,EACZ,WAAW,EACX,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EACf,WAAW,EACX,eAAe,GAChB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAUzF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,+EAA+E;AAC/E,6DAA6D;AAC7D,+EAA+E;AAC/E,0EAA0E;AAC1E,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * footprintjs/advanced — Low-level internals for custom execution engines and testing.\n *\n * Most users never need this. Use `footprintjs` (main) instead.\n * This entry point exposes `SharedMemory`, `StageContext`, `FlowchartTraverser`,\n * and other primitives that power the engine.\n *\n * ```ts\n * import { SharedMemory, StageContext } from 'footprintjs/advanced';\n * ```\n *\n * @module advanced\n */\n/**\n * FootPrint — Advanced / Internal API\n *\n * These exports are for advanced use cases, testing, and building\n * custom execution engines. Most users should use the main 'footprint' entry point.\n *\n * Import via: import { ... } from 'footprint/advanced'\n */\n\n// ============================================================================\n// Memory — Low-level transactional state primitives\n// ============================================================================\n\nexport type {\n  CommitBundle,\n  FlowControlType,\n  FlowMessage,\n  MemoryPatch,\n  ReadSummaryMarker,\n  ReadTrackingMode,\n  RetentionPolicy,\n  StageSnapshot,\n  TraceEntry,\n  UntrackedSource,\n  WriteSummaryMarker,\n  WriteTrackingMode,\n} from './lib/memory/index.js';\nexport type { RedactionVerdict } from './lib/memory/index.js';\nexport { SharedMemory } from './lib/memory/index.js';\nexport { StageContext } from './lib/memory/index.js';\nexport { EventLog } from './lib/memory/index.js';\nexport { TransactionBuffer } from './lib/memory/index.js';\nexport { DiagnosticCollector } from './lib/memory/index.js';\nexport { RedactionRule } from './lib/memory/index.js';\nexport {\n  applySmartMerge,\n  deepSmartMerge,\n  getNestedValue,\n  getRunAndGlobalPaths,\n  normalisePath,\n  pathSegments,\n  redactPatch,\n  setNestedValue,\n  updateNestedValue,\n  updateValue,\n} from './lib/memory/index.js';\n\n// ============================================================================\n// Builder — Types and internals\n// ============================================================================\n\nexport type {\n  ExecOptions,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  ScopeProtectionMode,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFn,\n  StageNode,\n  StreamCallback,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n  SubflowRef,\n} from './lib/builder/index.js';\nexport { ArrayMergeMode, DeciderList, SelectorFnList, specToStageNode } from './lib/builder/index.js';\nexport { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';\n\n// ============================================================================\n// Scope — Providers, protection, recorder options, and event types\n// ============================================================================\n\nexport type {\n  ProviderResolver,\n  ResolveOptions,\n  ScopeProvider,\n  StageContextLike,\n  StrictMode,\n} from './lib/scope/index.js';\nexport { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';\nexport {\n  attachScopeMethods,\n  isSubclassOfScopeFacade,\n  looksLikeClassCtor,\n  looksLikeFactory,\n  makeClassProvider,\n  makeFactoryProvider,\n  registerScopeResolver,\n  resolveScopeProvider,\n  toScopeFactory,\n} from './lib/scope/index.js';\n\n// ScopeRecorder config/option types\nexport type {\n  AggregatedMetrics,\n  DebugEntry,\n  DebugRecorderOptions,\n  DebugVerbosity,\n  RecorderContext,\n  StageEvent,\n  StageMetrics,\n} from './lib/scope/index.js';\n// `DefineScopeOptions` (zod scope options) moved to 'footprintjs/zod'.\n\n// Zod internals moved to the opt-in `footprintjs/zod` entry (keeps zod — an\n// optional peer — out of the `footprintjs/advanced` load path). Import\n// createScopeProxyFromZod / defineScopeSchema / isScopeSchema / ZodScopeResolver\n// from 'footprintjs/zod'.\n\n// ============================================================================\n// Runner — Internals\n// ============================================================================\n\nexport type { RuntimeSnapshot } from './lib/runner/index.js';\nexport { ExecutionRuntime } from './lib/runner/index.js';\n/** The run's policy an `ExecutionRuntime` is constructed with (F5). */\nexport type { RunPolicy } from './lib/memory/index.js';\nexport { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';\n\n// ============================================================================\n// Reactive — TypedScope internals (for custom proxy implementations)\n// ============================================================================\n\nexport type { ReactiveOptions, ReactiveTarget } from './lib/reactive/index.js';\nexport {\n  BREAK_SETTER,\n  buildNestedPatch,\n  createArrayProxy,\n  isHandle,\n  joinPath,\n  SCOPE_METHOD_NAMES,\n  shouldWrapWithProxy,\n  unwrapHandles,\n  valueBehind,\n} from './lib/reactive/index.js';\n\n// ============================================================================\n// Engine — DFS graph traversal internals\n// ============================================================================\n\nexport type { TraverserOptions } from './lib/engine/index.js';\nexport type { Decider } from './lib/engine/index.js';\nexport { FlowchartTraverser } from './lib/engine/index.js';\nexport { isStageNodeReturn } from './lib/engine/index.js';\n\n// Narrative internals\nexport type { IControlFlowNarrative } from './lib/engine/index.js';\nexport type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './lib/engine/index.js';\nexport type {\n  BranchResult,\n  BranchResults,\n  SerializedPipelineStructure as EngineSerializedPipelineStructure,\n  HandlerDeps,\n  IExecutionRuntime,\n  NodeResultType,\n  RuntimeStructureMetadata,\n  ScopeFactory,\n  SerializedPipelineNode,\n  StageFunction,\n  SubflowResult,\n  TraversalResult,\n} from './lib/engine/index.js';\nexport { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';\n\n// Handlers (testing / custom engines)\nexport type { ExecuteNodeFn, QueuedPause, ResumeHop, RunStageFn } from './lib/engine/index.js';\nexport {\n  applyOutputMapping,\n  ChildrenExecutor,\n  computeNodeType,\n  ContinuationResolver,\n  createSubflowHandlerDeps,\n  DeciderHandler,\n  DEFAULT_MAX_ITERATIONS,\n  extractParentScopeValues,\n  getInitialScopeValues,\n  NodeResolver,\n  ResumeEntry,\n  RuntimeStructureManager,\n  seedSubflowGlobalStore,\n  SelectorHandler,\n  StageRunner,\n  SubflowExecutor,\n} from './lib/engine/index.js';\n\n// Trace utilities — re-exported here for convenience. Canonical path: 'footprintjs/trace'\nexport type { ExecutionCounter } from './lib/ids/runtimeStageId.js';\nexport { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';\n\n// ============================================================================\n// Decide — pure guard evaluation (for custom availability/decision engines)\n// ============================================================================\n// evaluateFilter is engine-free: a pure function over (getValue, isRedacted)\n// callbacks that evaluates a WhereFilter and returns per-condition evidence.\n// External drivers (e.g. hcifootprint's available()) evaluate edge guards with\n// it outside any run — no scope, no commit, worker-safe.\nexport type { FilterCondition } from './lib/decide/index.js';\nexport { evaluateFilter } from './lib/decide/index.js';\n\n// ============================================================================\n// Contract — schema normalization (for custom tool emitters)\n// ============================================================================\n// Pure chart-metadata helpers behind toMCPTool/toOpenAPI. Custom emitters\n// (per-edge MCP descriptors) reuse the Zod→JSON-Schema conversion without\n// importing the runner. Gate inputs with detectSchema (main barrel): a\n// non-Zod 'parseable' schema (yup/superstruct) passes through unconverted.\nexport { normalizeSchema, zodToJsonSchema } from './lib/contract/index.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced.js","sourceRoot":"","sources":["../../src/advanced.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH;;;;;;;GAOG;AAqBH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,WAAW,GACZ,MAAM,uBAAuB,CAAC;AAsB/B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACtG,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAa1E,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAwB9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAOtE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EACR,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAmB1D,OAAO,EAAE,iCAAiC,EAAE,MAAM,uBAAuB,CAAC;AAI1E,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,wBAAwB,EACxB,cAAc,EACd,sBAAsB,EACtB,wBAAwB,EACxB,qBAAqB,EACrB,YAAY,EACZ,WAAW,EACX,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EACf,WAAW,EACX,eAAe,GAChB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAUzF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,+EAA+E;AAC/E,6DAA6D;AAC7D,+EAA+E;AAC/E,0EAA0E;AAC1E,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * footprintjs/advanced — Low-level internals for custom execution engines and testing.\n *\n * Most users never need this. Use `footprintjs` (main) instead.\n * This entry point exposes `SharedMemory`, `StageContext`, `FlowchartTraverser`,\n * and other primitives that power the engine.\n *\n * ```ts\n * import { SharedMemory, StageContext } from 'footprintjs/advanced';\n * ```\n *\n * @module advanced\n */\n/**\n * FootPrint — Advanced / Internal API\n *\n * These exports are for advanced use cases, testing, and building\n * custom execution engines. Most users should use the main 'footprint' entry point.\n *\n * Import via: import { ... } from 'footprint/advanced'\n */\n\n// ============================================================================\n// Memory — Low-level transactional state primitives\n// ============================================================================\n\nexport type {\n  CommitBundle,\n  FlowControlType,\n  FlowMessage,\n  MemoryPatch,\n  ReadSummaryMarker,\n  ReadTrackingMode,\n  RetentionPolicy,\n  StageSnapshot,\n  TraceEntry,\n  UntrackedSource,\n  WriteSummaryMarker,\n  WriteTrackingMode,\n} from './lib/memory/index.js';\nexport type { RedactionVerdict } from './lib/memory/index.js';\nexport { SharedMemory } from './lib/memory/index.js';\nexport { StageContext } from './lib/memory/index.js';\nexport { EventLog } from './lib/memory/index.js';\nexport { TransactionBuffer } from './lib/memory/index.js';\nexport { DiagnosticCollector } from './lib/memory/index.js';\nexport { RedactionRule } from './lib/memory/index.js';\nexport {\n  applySmartMerge,\n  deepSmartMerge,\n  getNestedValue,\n  getRunAndGlobalPaths,\n  normalisePath,\n  pathSegments,\n  redactPatch,\n  setNestedValue,\n  updateNestedValue,\n  updateValue,\n} from './lib/memory/index.js';\n\n// ============================================================================\n// Builder — Types and internals\n// ============================================================================\n\nexport type {\n  ExecOptions,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  ScopeProtectionMode,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFn,\n  StageNode,\n  StreamCallback,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n  SubflowRef,\n} from './lib/builder/index.js';\nexport { ArrayMergeMode, DeciderList, SelectorFnList, specToStageNode } from './lib/builder/index.js';\nexport { createTypedScopeFactory } from './lib/builder/typedFlowChart.js';\n\n// ============================================================================\n// Scope — Providers, protection, recorder options, and event types\n// ============================================================================\n\nexport type {\n  ProviderResolver,\n  ResolveOptions,\n  ScopeProvider,\n  StageContextLike,\n  StrictMode,\n} from './lib/scope/index.js';\nexport { createErrorMessage, createProtectedScope, ScopeFacade } from './lib/scope/index.js';\nexport {\n  attachScopeMethods,\n  isSubclassOfScopeFacade,\n  looksLikeClassCtor,\n  looksLikeFactory,\n  makeClassProvider,\n  makeFactoryProvider,\n  registerScopeResolver,\n  resolveScopeProvider,\n  toScopeFactory,\n} from './lib/scope/index.js';\nexport type { ScopeRuntime, ScopeRuntimeTarget } from './lib/scope/runtime.js';\nexport { registerScopeRuntime } from './lib/scope/runtime.js';\n\n// ScopeRecorder config/option types\nexport type {\n  AggregatedMetrics,\n  DebugEntry,\n  DebugRecorderOptions,\n  DebugVerbosity,\n  RecorderContext,\n  StageEvent,\n  StageMetrics,\n} from './lib/scope/index.js';\n// `DefineScopeOptions` (zod scope options) moved to 'footprintjs/zod'.\n\n// Zod internals moved to the opt-in `footprintjs/zod` entry (keeps zod — an\n// optional peer — out of the `footprintjs/advanced` load path). Import\n// createScopeProxyFromZod / defineScopeSchema / isScopeSchema / ZodScopeResolver\n// from 'footprintjs/zod'.\n\n// ============================================================================\n// Runner — Internals\n// ============================================================================\n\nexport type { RuntimeSnapshot } from './lib/runner/index.js';\nexport { ExecutionRuntime } from './lib/runner/index.js';\n/** The run's policy an `ExecutionRuntime` is constructed with (F5). */\nexport type { RunPolicy } from './lib/memory/index.js';\nexport { DEFAULT_RUN_POLICY, runPolicy } from './lib/memory/index.js';\n\n// ============================================================================\n// Reactive — TypedScope internals (for custom proxy implementations)\n// ============================================================================\n\nexport type { ReactiveOptions, ReactiveTarget } from './lib/reactive/index.js';\nexport {\n  buildNestedPatch,\n  createArrayProxy,\n  isHandle,\n  joinPath,\n  SCOPE_METHOD_NAMES,\n  shouldWrapWithProxy,\n  unwrapHandles,\n  valueBehind,\n} from './lib/reactive/index.js';\n\n// ============================================================================\n// Engine — DFS graph traversal internals\n// ============================================================================\n\nexport type { TraverserOptions } from './lib/engine/index.js';\nexport type { Decider } from './lib/engine/index.js';\nexport { FlowchartTraverser } from './lib/engine/index.js';\nexport { isStageNodeReturn } from './lib/engine/index.js';\n\n// Narrative internals\nexport type { IControlFlowNarrative } from './lib/engine/index.js';\nexport type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './lib/engine/index.js';\nexport type {\n  BranchResult,\n  BranchResults,\n  SerializedPipelineStructure as EngineSerializedPipelineStructure,\n  HandlerDeps,\n  IExecutionRuntime,\n  NodeResultType,\n  RuntimeStructureMetadata,\n  ScopeFactory,\n  SerializedPipelineNode,\n  StageFunction,\n  SubflowResult,\n  TraversalResult,\n} from './lib/engine/index.js';\nexport { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';\n\n// Handlers (testing / custom engines)\nexport type { ExecuteNodeFn, QueuedPause, ResumeHop, RunStageFn } from './lib/engine/index.js';\nexport {\n  applyOutputMapping,\n  ChildrenExecutor,\n  computeNodeType,\n  ContinuationResolver,\n  createSubflowHandlerDeps,\n  DeciderHandler,\n  DEFAULT_MAX_ITERATIONS,\n  extractParentScopeValues,\n  getInitialScopeValues,\n  NodeResolver,\n  ResumeEntry,\n  RuntimeStructureManager,\n  seedSubflowGlobalStore,\n  SelectorHandler,\n  StageRunner,\n  SubflowExecutor,\n} from './lib/engine/index.js';\n\n// Trace utilities — re-exported here for convenience. Canonical path: 'footprintjs/trace'\nexport type { ExecutionCounter } from './lib/ids/runtimeStageId.js';\nexport { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/ids/runtimeStageId.js';\nexport { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';\n\n// ============================================================================\n// Decide — pure guard evaluation (for custom availability/decision engines)\n// ============================================================================\n// evaluateFilter is engine-free: a pure function over (getValue, isRedacted)\n// callbacks that evaluates a WhereFilter and returns per-condition evidence.\n// External drivers (e.g. hcifootprint's available()) evaluate edge guards with\n// it outside any run — no scope, no commit, worker-safe.\nexport type { FilterCondition } from './lib/decide/index.js';\nexport { evaluateFilter } from './lib/decide/index.js';\n\n// ============================================================================\n// Contract — schema normalization (for custom tool emitters)\n// ============================================================================\n// Pure chart-metadata helpers behind toMCPTool/toOpenAPI. Custom emitters\n// (per-edge MCP descriptors) reuse the Zod→JSON-Schema conversion without\n// importing the runner. Gate inputs with detectSchema (main barrel): a\n// non-Zod 'parseable' schema (yup/superstruct) passes through unconverted.\nexport { normalizeSchema, zodToJsonSchema } from './lib/contract/index.js';\n"]}

package/dist/esm/index.d.ts

@@ -77,7 +77,7 @@ export type { AttachRecorderOptions, ObserverDelivery, ObserverDrainResult, Obse
  * @category Observe — Delivery tier (RFC-001 deferred observers)
  *
  * `CapturePolicy` — how a deferred event's payload is materialized at
- * capture time (`'summary'` default / `'clone'` / `'ref'`). `OverflowPolicy`
+ * capture time (`'clone'` by default for attach options / `'summary'` / `'ref'`). `OverflowPolicy`
  * — what a saturated queue does (`'drop-oldest'` default / `'sample'` /
  * `'block'`). `DispatcherStats` / `ListenerStats` — the accounting shapes
  * embedded in `ObserverStats`. Types only — the observer-queue module
@@ -132,7 +132,7 @@ export { SilentNarrativeFlowRecorder } from './lib/engine/index.js';
 /** @category Observe — Flow */
 export { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';
 /** @category Self-Describing */
-export type { FlowChartContract, FlowChartContractOptions, JsonSchema, OpenAPIOptions, OpenAPISpec, } from './lib/contract/index.js';
+export type { JsonSchema } from './lib/contract/index.js';
 /** @category Snapshot & Composition */
 export type { ComposableRunner } from './lib/runner/index.js';
 /** @category Snapshot & Composition */

package/dist/esm/index.js

@@ -86,4 +86,4 @@ export { disableDevMode, enableDevMode, isDevMode } from './lib/devMode.js';
 // A run's record as JSON without the engine's recursion limit (9.26.0): the
 // same bytes JSON.stringify emits, for a deep `next` chain it cannot encode.
 export { stringifySnapshot } from './lib/runner/stringifySnapshot.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA6BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAkBvD,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAqBnD,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oCAAoC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAmDjC,+BAA+B;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,+BAA+B;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAEvE,+BAA+B;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,+BAA+B;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAyBtE,uCAAuC;AACvC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoB5D,6BAA6B;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAiEjD,sCAAsC;AACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE3E,sCAAsC;AACtC,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASrG,gCAAgC;AAChC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE1E,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE5E,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC","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 (`'summary'` default / `'clone'` / `'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 {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} 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 { FlowchartCheckpoint, PausableHandler, PausedExecution, PendingPause } 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;;;;;;;;;;;;;;GAcG;AASH,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA6BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAkBvD,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAqBnD,+BAA+B;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,+BAA+B;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oCAAoC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AAmDjC,+BAA+B;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,+BAA+B;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAEvE,+BAA+B;AAC/B,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,+BAA+B;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAEtE,+BAA+B;AAC/B,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAEpE,+BAA+B;AAC/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAmBtE,uCAAuC;AACvC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoB5D,6BAA6B;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAiEjD,sCAAsC;AACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE3E,sCAAsC;AACtC,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AASrG,gCAAgC;AAChC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE1E,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE5E,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD;AACtD,4EAA4E;AAC5E,6EAA6E;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC","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 { FlowchartCheckpoint, PausableHandler, PausedExecution, PendingPause } 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/esm/lib/builder/FlowChartBuilder.d.ts

@@ -606,24 +606,27 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
      * `addFunction(...).addListOfFunction(...)` already builds, which every
      * reader (engine, resume, structure, spec) handles. A second fan-out call
      * reuses that node, as it would any cursor. The id is reserved both ways:
-     * refused here when a stage already has it, and by `_addToMap` /
+     * refused here when a stage already has it, and by stage admission /
      * `_registerSubflowDef` when a later stage or mount asks for it.
      */
     private _needForkParent;
     /** Ids `_needForkParent` generated — no later stage or mount may take one. */
     private _forkNodeIds;
-    /** Asked by `_addToMap` / `_registerSubflowDef`: an id a generated fork node or a claiming door holds is refused. */
+    /** Shared by stage admission and subflow registration: reserved structural ids cannot be reused. */
     private _refuseForkNodeId;
     /** Ids the lazy-mount and parallelForEach doors claimed (they register in no map). */
     private _claimedIds;
+    /** Structural declarations without an embedded function; not function entries or loop targets. */
+    private _functionlessStageIds;
     /** True when an earlier stage, branch, fork child, mount or generated fork node holds `id`. */
     private _idTaken;
     /**
      * @internal The lazy-mount doors and `addParallelForEach` register their id
      * in no map, so through 9.37.0 they accepted an id another stage or mount
      * already had (and a later stage could take theirs). They claim it here:
-     * refused when taken, recorded when fresh. Loop-ref stubs never pass
-     * through a door, so they stay the one deliberate duplicate.
+     * refused when taken, recorded when fresh. Loop-ref stubs reference an
+     * existing stage rather than claiming a new id. Reusable function stages
+     * retain their separate `_addToMap` rule.
      */
     _claimFreshId(id: string, door: string): void;
     /**
@@ -656,6 +659,13 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
      * here, at build time, where the id can still be changed.
      */
     _registerSubflowDef(id: string, root: StageNode<TOut, TScope>): void;
+    /**
+     * @internal One admission path for optional-function children and branches.
+     * A missing function does not erase the graph identity: check reservations
+     * and record it for future fresh-id claims, without adding a function or a
+     * loop target. Existing function references by id/name remain legal.
+     */
+    _registerStage(id: string, fn: StageFunction<TOut, TScope> | undefined): void;
     _addToMap(id: string, fn: StageFunction<TOut, TScope>): void;
     _mergeStageMap(other: Map<string, StageFunction<TOut, TScope>>, prefix?: string): void;
     /**