footprintjs 9.14.0 → 9.15.0

package/CLAUDE.md

@@ -18,7 +18,7 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | recorder/ | stores (KeyedStore/SequenceStore/BoundaryStateStore), CombinedRecorder routing, built-ins (Topology/InOut/ControlDep/Quality) |
 | slice/ | variable-first backward slicing (triage query layer): sliceForKey (anchor at last writer → causalChain) + arrayProvenance/elementProvenance (append-fold element births — the agent mega-key fix) + KeysReadSource strategies. Pure post-hoc queries; imports memory/ ONLY (see src/lib/slice/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; branchSegment.ts = the ONE owner of the generated-segment grammar (`<stageId>~<index>`, marker `~` RESERVED) |
+| engine/ | FlowchartTraverser + handlers/; narrative/ = the whole FlowRecorder channel (dispatcher + 9 strategies), not just text; branchSegment.ts = 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 |
 | runner/ | FlowChartExecutor wiring (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) |
@@ -31,6 +31,8 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 - `runtimeStageId` = `[subflowPath/]stageId#executionIndex`; counter shared by reference into subflow traversers → globally unique; NOT reset on resume.
 - Subflows get a fresh isolated ExecutionRuntime (SubflowExecutor.ts:119); inputMapper seeds, outputMapper merges back (arrays CONCAT unless `arrayMerge: Replace`).
 
+**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`.
+
 **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. `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
@@ -42,6 +44,7 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 - **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.
 - **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) → **`FLOW_RECORDER_EVENT_METHODS` (CombinedRecorder.ts:222)** → `NarrativeFlowRecorder` sentence (the 8 strategies extend it, so they inherit free) → `CombinedNarrativeRecorder` + `CombinedNarrativeEntry.type` + `NarrativeFormatter.renderRetry` → `CompositeRecorder` (hand-listed fan-out) → barrels. 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).
 
 ## Change-impact map

package/README.md

@@ -167,6 +167,40 @@ The LLM calls the tool, gets back the decision and causal trace, and explains th
 
 ---
 
+## Human-in-the-Loop
+
+A stage can stop in the middle of its body to ask a person, and pick the run back up later — minutes or days later, in a different process.
+
+```typescript
+import { flowChart, FlowChartExecutor, interrupt } from 'footprintjs';
+
+interface RefundState { amount: number; approved: boolean; [key: string]: unknown }
+
+const refundChart = flowChart<RefundState>('Assess refund', (scope) => {
+  scope.amount = 4200;                              // runs AGAIN on resume — keep it idempotent
+
+  const answer = interrupt<{ approved: boolean }>(scope, {
+    reason: `Approve a $${scope.amount} refund?`,
+    expects: { approved: 'boolean' },               // carried verbatim, so a UI can render the form
+  });
+
+  scope.approved = answer.approved;                 // reached only after resume()
+}, 'assess').build();
+
+const refundExecutor = new FlowChartExecutor(refundChart);
+await refundExecutor.run();
+
+if (refundExecutor.isPaused()) {
+  const checkpoint = refundExecutor.getCheckpoint()!;   // plain JSON — persist it anywhere
+  // ...a human answers; then, possibly on another server:
+  await new FlowChartExecutor(refundChart).resume(checkpoint, { approved: true });
+}
+```
+
+Resume re-enters the stage **from its top** &mdash; stages are atomic, so everything before the `interrupt()` call runs again and the answer comes back out of that call. When you don't want the first half re-run, `addPausableFunction` is the declared alternative: it splits the stage into an `execute` half and a `resume` half.
+
+---
+
 ## Features
 
 | Feature | Description |
@@ -183,6 +217,7 @@ The LLM calls the tool, gets back the decision and causal trace, and explains th
 | **Deferred observers** *(new in 9.6)* | `attach*Recorder(rec, { delivery: 'deferred' })` &mdash; observers run "one beat behind" on a bounded queue instead of inside the engine hot path. Honest backpressure (`drop-oldest`/`sample`/`block`), terminal flush at run resolve/reject/pause, `snapshot.observerStats`. [Guide →](./docs/guides/observers-deferred.md) |
 | **Contracts** | I/O schemas (Zod/JSON Schema) + OpenAPI 3.1 + MCP tool generation |
 | **Cancellation** | AbortSignal, timeout, early termination via `scope.$break(reason?)` with optional reason |
+| **Declarative retry** *(new in 9.15)* | `.retry({ attempts, backoffMs, retryOn })` on a stage &mdash; because a retry hand-rolled inside a stage function is invisible to the trace. Every failed attempt fires `onStageRetry` and appears in the narrative, in order, inside its own stage. A failed attempt's writes are discarded (the next attempt starts from committed state); the final attempt keeps commit-on-error exactly. One `runtimeStageId`, one commit bundle, however many attempts ran. [Guide &rarr;](./docs/guides/error-handling.md#declarative-retry) |
 | **Subflow break propagation** | Mount a subflow with `propagateBreak: true` &mdash; inner `$break` terminates the parent loop, with drill-down preserved |
 | **Emit channel** | `scope.$emit(name, payload)` &mdash; user-authored structured events to `EmitRecorder`, pass-through, zero-allocation when no recorder attached, redactable via `emitPatterns` |
 | **Detach** *(new in 4.17)* | `scope.$detachAndForget(driver, child, input)` and `scope.$detachAndJoinLater(driver, child, input)` &mdash; fire-and-forget child flowcharts via the `footprintjs/detach` subpath. Six built-in drivers (microtask / immediate / setImmediate / setTimeout / sendBeacon / workerThread) + custom-driver protocol. Builder-native composition (`addDetachAndForget` / `addDetachAndJoinLater`) makes detach a labeled chart stage. `flushAllDetached()` for graceful shutdown. [Guide →](https://footprintjs.github.io/footPrint/guides/patterns/detach/) |

package/dist/esm/index.d.ts

@@ -24,7 +24,7 @@ export { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/in
  * decided at run time from the payload. `maxBranches` and `into` are required
  * on purpose (see docs/design/execution-control.md).
  */
-export type { BranchChart, ParallelForEachConfig } from './lib/builder/index.js';
+export type { BranchChart, ParallelForEachConfig, RetryPolicy } from './lib/builder/index.js';
 /** @category Quick Start — build-time observer (twin of FlowRecorder) */
 export type { StructureDeciderCompleteEvent, StructureEdgeAddedEvent, StructureEdgeKind, StructureLoopEdgeAddedEvent, StructureRecorder, StructureStageAddedEvent, StructureSubflowMountedEvent, } from './lib/builder/index.js';
 /** @category Quick Start */
@@ -94,7 +94,7 @@ export { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods, isF
  */
 export type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';
 /** @category Observe — Flow */
-export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, FlowSubflowRegisteredEvent, TraversalContext, } from './lib/engine/index.js';
+export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowStageRetryEvent, FlowSubflowEvent, FlowSubflowRegisteredEvent, TraversalContext, } from './lib/engine/index.js';
 /** @category Observe — Flow */
 export type { CombinedNarrativeEntry } from './lib/engine/index.js';
 /**

package/dist/esm/index.js

@@ -83,4 +83,4 @@ export { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCirc
 // `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in
 // `footprintjs/zod` entry — keeping zod out of the core load path (it is an
 // optional peer). Import them from 'footprintjs/zod'.
-//# 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;AA4BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAmB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAYvD,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;AAgDjC,+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,+BAA+B,CAAC;AAEzF,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","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 } 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  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  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/** @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  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\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 } 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/scope/detectCircular.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"]}
+//# 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;AA4BxF,4BAA4B;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAmB3C,mCAAmC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAYvD,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;AAiDjC,+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,+BAA+B,CAAC;AAEzF,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","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  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  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/** @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  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 } 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/scope/detectCircular.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"]}

package/dist/esm/lib/builder/FlowChartBuilder.d.ts

@@ -11,7 +11,7 @@
  * The execute() convenience method is intentionally omitted —
  * it belongs in the runner layer (Phase 5).
  */
-import type { ParallelForEachConfig, ScopeFactory } from '../engine/types.js';
+import type { ParallelForEachConfig, RetryPolicy, ScopeFactory } from '../engine/types.js';
 import type { PausableHandler } from '../pause/types.js';
 import type { TypedScope } from '../reactive/types.js';
 import { type RunnableFlowChart } from '../runner/RunnableChart.js';
@@ -37,9 +37,11 @@ export declare class DeciderList<TOut = any, TScope = any> {
     constructor(builder: FlowChartBuilder<TOut, TScope>, curNode: StageNode<TOut, TScope>, curSpec: SerializedPipelineStructure, parentDescriptionParts?: string[], parentStageDescriptions?: Map<string, string>, reservedStepNumber?: number, deciderDescription?: string);
     addFunctionBranch(id: string, name: string, fn?: StageFunction<TOut, TScope>, description?: string, 
     /** `{ loopTo }` declares this branch loops back to an already-declared
-     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider). */
+     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).
+     *  `{ retry }` gives THIS BRANCH's stage a declarative retry policy. */
     options?: {
         readonly loopTo?: string;
+        readonly retry?: RetryPolicy;
     }): DeciderList<TOut, TScope>;
     /**
      * Add a pausable stage as a decider branch.
@@ -51,9 +53,13 @@ export declare class DeciderList<TOut = any, TScope = any> {
      */
     addPausableFunctionBranch(id: string, name: string, handler: PausableHandler<TScope>, description?: string, 
     /** `{ loopTo }` declares this branch loops back to an already-declared
-     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider). */
+     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).
+     *  `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the
+     *  `resume` half runs without it — a different function, a different
+     *  contract). */
     options?: {
         readonly loopTo?: string;
+        readonly retry?: RetryPolicy;
     }): DeciderList<TOut, TScope>;
     addSubFlowChartBranch(id: string, subflow: FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): DeciderList<TOut, TScope>;
     addLazySubFlowChartBranch(id: string, resolver: () => FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): DeciderList<TOut, TScope>;
@@ -109,7 +115,11 @@ export declare class SelectorFnList<TOut = any, TScope = any> {
     private readonly selectorDescription?;
     private readonly branchDescInfo;
     constructor(builder: FlowChartBuilder<TOut, TScope>, curNode: StageNode<TOut, TScope>, curSpec: SerializedPipelineStructure, parentDescriptionParts?: string[], parentStageDescriptions?: Map<string, string>, reservedStepNumber?: number, selectorDescription?: string);
-    addFunctionBranch(id: string, name: string, fn?: StageFunction<TOut, TScope>, description?: string): SelectorFnList<TOut, TScope>;
+    addFunctionBranch(id: string, name: string, fn?: StageFunction<TOut, TScope>, description?: string, 
+    /** `{ retry }` gives THIS BRANCH's stage a declarative retry policy. */
+    options?: {
+        readonly retry?: RetryPolicy;
+    }): SelectorFnList<TOut, TScope>;
     /**
      * Add a pausable stage as a selector branch.
      *
@@ -117,7 +127,13 @@ export declare class SelectorFnList<TOut = any, TScope = any> {
      * data, the pipeline pauses. On resume, `handler.resume` runs with the
      * human's input. If `execute` returns void, the stage continues normally.
      */
-    addPausableFunctionBranch(id: string, name: string, handler: PausableHandler<TScope>, description?: string): SelectorFnList<TOut, TScope>;
+    addPausableFunctionBranch(id: string, name: string, handler: PausableHandler<TScope>, description?: string, 
+    /** `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the
+     *  `resume` half runs without it — a different function, a different
+     *  contract). */
+    options?: {
+        readonly retry?: RetryPolicy;
+    }): SelectorFnList<TOut, TScope>;
     addSubFlowChartBranch(id: string, subflow: FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): SelectorFnList<TOut, TScope>;
     addLazySubFlowChartBranch(id: string, resolver: () => FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): SelectorFnList<TOut, TScope>;
     addBranchList(branches: Array<{
@@ -277,7 +293,9 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
         output?: unknown;
         mapper?: (finalScope: Record<string, unknown>) => unknown;
     }): this;
-    start(name: string, fn: StageFunction<TOut, TScope> | PausableHandler<TScope>, id: string, description?: string): this;
+    start(name: string, fn: StageFunction<TOut, TScope> | PausableHandler<TScope>, id: string, description?: string, options?: {
+        retry?: RetryPolicy;
+    }): this;
     /**
      * Start a chart whose ROOT stage IS a selector — it runs first (reading
      * args, seeding state, returning the chosen branch ids via `select()`),
@@ -292,6 +310,7 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
      */
     startSelector(name: string, fn: StageFunction<any, TScope>, id: string, description?: string, options?: {
         failFast?: boolean;
+        retry?: RetryPolicy;
     }): SelectorFnList<TOut, TScope>;
     addFunction(name: string, fn: StageFunction<TOut, TScope>, id: string, description?: string): this;
     addStreamingFunction(name: string, fn: StageFunction<TOut, TScope>, id: string, streamId?: string, description?: string): this;
@@ -398,9 +417,20 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
         mountName?: string;
         description?: string;
     }): this;
-    addDeciderFunction(name: string, fn: StageFunction<any, TScope>, id: string, description?: string): DeciderList<TOut, TScope>;
-    addSelectorFunction(name: string, fn: StageFunction<any, TScope>, id: string, description?: string, options?: {
+    addDeciderFunction(name: string, fn: StageFunction<any, TScope>, id: string, description?: string, 
+    /** `{ retry }` gives the DECIDER STAGE a retry policy. Declared here rather
+     *  than via `.retry()` because this method returns a `DeciderList`, where a
+     *  chained modifier could mean the decider OR the branch just added. */
+    options?: {
+        retry?: RetryPolicy;
+    }): DeciderList<TOut, TScope>;
+    addSelectorFunction(name: string, fn: StageFunction<any, TScope>, id: string, description?: string, 
+    /** `{ retry }` gives the SELECTOR STAGE a retry policy — same reasoning as
+     *  `addDeciderFunction`: this method returns a sub-builder, so a chained
+     *  `.retry()` would be ambiguous. */
+    options?: {
         failFast?: boolean;
+        retry?: RetryPolicy;
     }): SelectorFnList<TOut, TScope>;
     addListOfFunction(children: SimplifiedParallelSpec<TOut, TScope>[], options?: {
         failFast?: boolean;
@@ -453,6 +483,45 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
     addLazySubFlowChart(id: string, resolver: () => FlowChart<TOut, TScope>, mountName?: string, options?: SubflowMountOptions): this;
     addLazySubFlowChartNext(id: string, resolver: () => FlowChart<TOut, TScope>, mountName?: string, options?: SubflowMountOptions): this;
     addSubFlowChartNext(id: string, subflow: FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): this;
+    /**
+     * Give the stage you JUST added a declarative retry policy.
+     *
+     * ## Why declare it instead of writing a loop inside the stage
+     *
+     * A retry hand-rolled inside a stage function is invisible to the trace. The
+     * narrative shows one stage, the commit log shows one entry, and the two
+     * failed calls that came before the successful one left no mark anywhere —
+     * an unexplained behaviour in a library whose whole point is that nothing
+     * invisible happens. Declared here, every attempt is part of the record: each
+     * failed attempt fires `FlowRecorder.onStageRetry` and appears in the
+     * narrative, in order, between the attempts' own reads and writes.
+     *
+     * ## What an attempt is
+     *
+     * A failed attempt's staged writes are DISCARDED — the next attempt starts
+     * from committed state, never from the wreckage of the last try. The final
+     * attempt behaves exactly as a stage with no policy does: on success it
+     * commits; on failure it commits what it wrote and rethrows (footprint has
+     * never had rollback, and retry does not introduce one).
+     *
+     * A pause is not a failure: neither `addPausableFunction`'s pause nor
+     * `interrupt()` is ever retried. Nor is a cancelled run.
+     *
+     * @example
+     * ```ts
+     * flowChart<State>('Fetch user', fetchFn, 'fetch-user')
+     *   .addFunction('Charge card', chargeFn, 'charge')
+     *   .retry({ attempts: 3, backoffMs: (n) => 100 * 2 ** (n - 1) })
+     *   .addFunction('Confirm', confirmFn, 'confirm')
+     * ```
+     *
+     * Applies to the CURRENT cursor — the stage added by the immediately
+     * preceding `start()` / `addFunction()` / `addStreamingFunction()` /
+     * `addPausableFunction()`. Where the cursor would be ambiguous (a decider,
+     * selector, branch, or fork child), declare the policy in that method's own
+     * `retry` option instead.
+     */
+    retry(policy: RetryPolicy): this;
     loopTo(stageId: string): this;
     onStream(handler: StreamTokenHandler): this;
     onStreamStart(handler: StreamLifecycleHandler): this;
@@ -468,6 +537,20 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
      * Advance the spec cursor. Retained as a method so call sites stay
      * one-liners and future cursor-related side effects have a hook.
      */
+    /**
+     * What was attached to the CURSOR without advancing it — a subflow mount, a
+     * parallel fork's children. Cleared by {@link _advanceCursorSpec}, the single
+     * choke point every cursor-advancing method already goes through, so this
+     * marker cannot drift as new builder methods are added.
+     *
+     * Exists for `.retry()`. Those methods hang children off the current stage
+     * and leave the cursor pointing at that stage, so a chained `.retry()` would
+     * silently attach the policy to the stage BEFORE the thing you just wrote —
+     * exactly the silent mis-attribution this codebase refuses elsewhere (see
+     * the branch-segment marker rules). Naming what was last added lets the
+     * refusal say something useful.
+     */
+    private _cursorTail?;
     private _advanceCursorSpec;
     _stageMapHas(key: string): boolean;
     _addToMap(id: string, fn: StageFunction<TOut, TScope>): void;