footprintjs 4.12.2 → 4.14.0

package/CLAUDE.md

@@ -311,6 +311,117 @@ recorder.getEntryRanges();                                      // Range index:
 
 **How runtimeStageId is generated:** A counter starts at 0 and increments by 1 for each stage execution across the entire run, including subflow stages. Subflow child traversers share the parent counter so indices are globally unique. Stages inside subflows have stageIds already prefixed by the builder (e.g., `sf-tools/execute-tool-calls`), so `buildRuntimeStageId` just appends `#index`.
 
+## Dev Mode
+
+One global flag (`enableDevMode()` / `disableDevMode()` / `isDevMode()`) controls every developer-only diagnostic across the library. OFF by default — production pays zero overhead.
+
+```ts
+import { enableDevMode } from 'footprintjs';
+if (process.env.NODE_ENV !== 'production') enableDevMode();
+```
+
+Gated diagnostics:
+- **Circular-ref detection** in `ScopeFacade.setValue()` — O(n) WeakSet traversal per write
+- **Empty-recorder warning** in `attachCombinedRecorder(r)` — catches `r` with no `on*` handler
+- **Suspicious predicates** in `decide()` / `select()`
+- **Snapshot integrity** in `getSubtreeSnapshot()`
+
+Convention: when adding a new dev-only check, gate on `isDevMode()` (from `scope/detectCircular.ts`). Do NOT use `process.env.NODE_ENV` inline — consumers control dev tooling centrally via `enableDevMode()`/`disableDevMode()`, and inline env checks break that contract.
+
+## Break + Propagation
+
+`scope.$break(reason?)` takes an optional free-form reason string that surfaces on `FlowBreakEvent.reason`. Recorders and narrative consumers see it.
+
+By default, an inner subflow's `$break` stops ONLY the subflow; the parent continues. Opt into propagation via `SubflowMountOptions.propagateBreak: true`:
+
+```ts
+builder.addSubFlowChartNext('sf-escalate', escalateChart, 'Escalate', {
+  inputMapper: ..., outputMapper: ...,
+  propagateBreak: true,  // ← inner $break → parent $break, with reason
+});
+```
+
+Semantics:
+- **Linear chain:** inner `$break(reason)` → parent's `breakFlag` flips → next parent stage does NOT run → `FlowBreakEvent` fires at parent-mount level with `propagatedFromSubflow` + reason.
+- **Nested chain:** propagates through every hop that opted in. Reason survives.
+- **outputMapper still runs** before propagation — subflow's partial state lands in parent before the break. Escape hatch: early-return `{}` from outputMapper when the break state is set.
+- **Parallel/fan-out:** existing ChildrenExecutor rule applies — parent breaks only when ALL fork children broke. `propagateBreak: true` on a single child contributes to that count; doesn't terminate the fork alone.
+
+Example: [examples/runtime-features/break/04-subflow-propagate.ts](examples/runtime-features/break/04-subflow-propagate.ts).
+
+## Emit Channel (Phase 3)
+
+Third observer channel alongside `Recorder` (data-flow) and `FlowRecorder` (control-flow). Consumer stage code emits structured events; `EmitRecorder.onEmit(event)` fires synchronously with auto-enriched context.
+
+```ts
+import type { EmitRecorder, EmitEvent } from 'footprintjs';
+
+// Inside a stage:
+scope.$emit('myapp.llm.tokens', { input: 100, output: 50 });
+
+// Recorder observes:
+const rec: EmitRecorder = {
+  id: 'token-meter',
+  onEmit: (e) => { if (e.name === 'myapp.llm.tokens') tally(e.payload); },
+};
+executor.attachEmitRecorder(rec);
+```
+
+### Semantics
+- **Pass-through.** Delivered synchronously, in call order. Zero allocation when no recorder attached (fast-path in `ScopeFacade.emitEvent`).
+- **Auto-enriched.** Events carry `stageName`, `runtimeStageId`, `subflowPath`, `pipelineId`, `timestamp` — parsed from `runtimeStageId` for subflow context.
+- **Error-isolated.** A throwing `onEmit` doesn't propagate; errors route to `onError` on other recorders.
+- **Redactable.** `RedactionPolicy.emitPatterns: RegExp[]` matches `event.name`; matched payloads become `'[REDACTED]'` before dispatch.
+- **Buffered in narrative.** `CombinedNarrativeRecorder.onEmit` buffers alongside reads/writes; flushed in `flushOps` so emit entries appear AFTER the stage header in ordered narrative.
+
+### Naming convention
+Hierarchical dotted names — `<namespace>.<category>.<event>`. Examples:
+- `'agentfootprint.llm.tokens'`, `'agentfootprint.llm.request'`
+- `'myapp.billing.spend'`, `'myapp.auth.check'`
+
+### Legacy primitives route through this channel
+`$debug`, `$metric`, `$error`, `$eval`, `$log` also dispatch on the emit channel (in addition to their existing `DiagnosticCollector` side-bag writes for snapshot inclusion):
+
+```
+$debug(key, value)    → emits 'log.debug.${key}'
+$error(key, value)    → emits 'log.error.${key}'
+$metric(name, value)  → emits 'metric.${name}'
+$eval (name, value)   → emits 'eval.${name}'
+```
+
+This closes the long-standing gap where `$metric` / `$debug` went to side bags no recorder observed. Backward-compat: the side bags still populate for consumers that inspect snapshots directly.
+
+### Customizing narrative rendering
+`NarrativeFormatter.renderEmit?(ctx)` hook 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`.
+
+Example: [examples/runtime-features/emit/01-custom-events.ts](examples/runtime-features/emit/01-custom-events.ts).
+
+## Combined Recorder
+
+A `CombinedRecorder` is an observer that hooks into multiple event streams (scope data-flow, control-flow, AND emit — all three channels). One object, one `id`, one `attachCombinedRecorder()` call — the library routes to the right channels via runtime method-shape detection.
+
+```ts
+import type { CombinedRecorder } from 'footprintjs';
+import { isFlowEvent } from 'footprintjs';
+
+const audit: CombinedRecorder = {
+  id: 'audit',
+  onWrite: (e) => log('scope write', e.key),       // Recorder stream
+  onDecision: (e) => log('routed to', e.chosen),   // FlowRecorder stream
+  onError: (e) => {
+    // Shared method — union payload. Discriminate with isFlowEvent():
+    if (isFlowEvent(e)) log('flow error in', e.stageName);
+    else log('scope error during', e.operation);
+  },
+};
+
+executor.attachCombinedRecorder(audit);
+```
+
+Built on `CombinedRecorder`: `CombinedNarrativeRecorder` (the `executor.enableNarrative()` default). Consumers implement ONLY the events they care about — `Partial<Recorder> & Partial<FlowRecorder>` under the hood.
+
+**Detection rule:** only OWN event-method properties count (prototype methods are ignored for security — prevents accidental `Object.prototype` pollution from attaching handlers).
+
 ## Anti-Patterns
 
 - Never post-process the tree — use recorders

package/README.md

@@ -159,8 +159,36 @@ The LLM calls the tool, gets back the decision and causal trace, and explains th
 | **Transactional State** | Atomic commits, safe merges, time-travel replay |
 | **PII Redaction** | Per-key or declarative `RedactionPolicy` with audit trail |
 | **Flow Recorders** | 8 narrative strategies for loop compression |
+| **Combined Recorders** | Single-hook observers that span data-flow + control-flow — `executor.attachCombinedRecorder(r)` |
 | **Contracts** | I/O schemas (Zod/JSON Schema) + OpenAPI 3.1 + MCP tool generation |
-| **Cancellation** | AbortSignal, timeout, early termination via `scope.$break()` |
+| **Cancellation** | AbortSignal, timeout, early termination via `scope.$break(reason?)` with optional reason |
+| **Subflow break propagation** | Mount a subflow with `propagateBreak: true` — inner `$break` terminates the parent loop, with drill-down preserved |
+| **Emit channel** | `scope.$emit(name, payload)` — user-authored structured events to `EmitRecorder`, pass-through, zero-allocation when no recorder attached, redactable via `emitPatterns` |
+
+---
+
+## Dev Mode
+
+footprintjs ships with developer-only diagnostics that are OFF in production (zero overhead). Turn them on during development to catch mistakes early:
+
+```ts
+import { enableDevMode } from 'footprintjs';
+
+if (process.env.NODE_ENV !== 'production') {
+  enableDevMode();
+}
+```
+
+One flag gates every library dev-only check:
+
+| Check | What it warns about |
+|---|---|
+| Circular refs | `scope.setValue(...)` called with an object that references itself |
+| Empty recorders | `attachCombinedRecorder(r)` with `r` that has no `on*` handler (likely mistake) |
+| Suspicious predicates | `decide()` / `select()` rules with shapes that probably won't match |
+| Snapshot integrity | `getSubtreeSnapshot()` asked for a path that doesn't exist |
+
+All dev warnings are `console.warn`. Use `disableDevMode()` to silence them at runtime.
 
 ---
 

package/dist/esm/index.js

@@ -29,6 +29,8 @@ export { MetricRecorder } from './lib/scope/index.js';
 export { DebugRecorder } from './lib/scope/index.js';
 /** @category Observe — Operation */
 export { RecorderOperation } from './lib/recorder/index.js';
+/** @category Observe — Combined (both data-flow and control-flow) */
+export { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods, isFlowEvent, } from './lib/recorder/index.js';
 /** @category Observe — Flow */
 export { NarrativeFlowRecorder } from './lib/engine/index.js';
 /** @category Observe — Flow */
@@ -63,8 +65,19 @@ export { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';
 // ============================================================================
 // Dev Tools — Mode flags and Zod scope utilities
 // ============================================================================
-/** @category Dev Tools */
-export { disableDevMode, enableDevMode } from './lib/scope/detectCircular.js';
+/**
+ * @category Dev Tools
+ *
+ * Global dev-mode flag. Call `enableDevMode()` at application startup to
+ * turn on developer-only diagnostics across the library — circular-reference
+ * detection in scope writes, warnings when a recorder has no observer
+ * methods, suspicious-predicate warnings in decide/select, structural
+ * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.
+ *
+ * Production leaves it OFF by default (zero overhead). See the JSDoc on
+ * `enableDevMode` for the full list and usage example.
+ */
+export { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';
 /** @category Dev Tools */
 export { defineScopeFromZod } from './lib/scope/index.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,MAAM,wBAAwB,CAAC;AAQrE,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;AAyB5D,+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,uEAAuE;AACvE,+EAA+E;AAE/E,yBAAyB;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AA8B5D,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,0BAA0B;AAC1B,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9E,0BAA0B;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,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 } 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  Recorder,\n  RedactionPolicy,\n  RedactionReport,\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// 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  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/** @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// Recorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category Recorder */\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/** @category Recorder */\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// 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/** @category Dev Tools */\nexport { disableDevMode, enableDevMode } from './lib/scope/detectCircular.js';\n\n/** @category Dev Tools */\nexport { defineScopeFromZod } from './lib/scope/index.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,MAAM,wBAAwB,CAAC;AAQrE,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;AAI5D,qEAAqE;AACrE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,GACZ,MAAM,yBAAyB,CAAC;AA8CjC,+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,uEAAuE;AACvE,+EAA+E;AAE/E,yBAAyB;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AA8B5D,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,0BAA0B;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,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 } 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  Recorder,\n  RedactionPolicy,\n  RedactionReport,\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/** @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 `Recorder` 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  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// Recorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category Recorder */\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/** @category Recorder */\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// 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/** @category Dev Tools */\nexport { defineScopeFromZod } from './lib/scope/index.js';\n"]}

package/dist/esm/lib/engine/graph/StageNode.js

@@ -17,8 +17,7 @@
  * Uses duck-typing: must have `name` (string) AND at least one continuation
  * property (non-empty children, next, nextNodeSelector, or isSubflowRoot).
  *
- * `isSubflowRoot` counts as continuation because subflow execution (or
- * structural annotation for pre-executed subflows) is a form of continuation.
+ * `isSubflowRoot` counts as continuation because subflow execution is a form of continuation.
  *
  * Safely handles proxy objects (e.g., Zod scope) that may throw on property access.
  */
@@ -39,4 +38,4 @@ export function isStageNodeReturn(output) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StageNode.js","sourceRoot":"","sources":["../../../../../src/lib/engine/graph/StageNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA0HH,8EAA8E;AAC9E,qEAAqE;AACrE,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAe;IAC/C,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAExD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAiC,CAAC;QAC9C,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAE/C,MAAM,eAAe,GACnB,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;YACxD,GAAG,CAAC,IAAI,KAAK,SAAS;YACtB,OAAO,GAAG,CAAC,gBAAgB,KAAK,UAAU;YAC1C,GAAG,CAAC,aAAa,KAAK,IAAI,CAAC;QAE7B,OAAO,eAAe,CAAC;IACzB,CAAC;IAAC,WAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/**\n * StageNode — The graph node type for flowchart traversal.\n *\n * Defines the shape of each node in the flowchart DAG:\n * - Linear continuation via `next` (linked list traversal)\n * - Parallel fan-out via `children` (fork)\n * - Conditional branching via `deciderFn` (single-choice) or `selectorFn` (multi-choice)\n * - Back-edges via dynamic next (loop)\n * - Isolated sub-traversals via `isSubflowRoot` (subflow)\n */\n\nimport type { StageFunction, SubflowMountOptions } from '../types.js';\n\n/**\n * Resume function for pausable stages.\n * Unlike StageFunction, the 2nd argument is the resume input (not breakFn).\n */\nexport type ResumeFn<TScope = any, TInput = unknown> = (scope: TScope, input: TInput) => Promise<void> | void;\n\n// ---------------------------------------------------------------------------\n// Decider + Selector\n// ---------------------------------------------------------------------------\n\n/** Picks exactly ONE child by ID. Conditional branch (if/switch). */\nexport type Decider = (nodeArgs: any) => string | Promise<string>;\n\n/**\n * Picks ONE OR MORE children by ID. Filtered fan-out.\n * - Single string: behaves like Decider\n * - Array: selected children execute in parallel\n * - Empty array: skip all children\n */\nexport type Selector = (nodeArgs: any) => string | string[] | Promise<string | string[]>;\n\n// ---------------------------------------------------------------------------\n// StageNode\n// ---------------------------------------------------------------------------\n\nexport type StageNode<TOut = any, TScope = any> = {\n  /** Human-readable stage name; also used as the stageMap key */\n  name: string;\n  /** Stable identifier for visualization matching and branch aggregation. */\n  id: string;\n  /** Original branch identifier as supplied to addFunctionBranch() / addSubFlowChartBranch().\n   *  When a subflow prefix is applied to the node tree, this field preserves the\n   *  unprefixed ID so handlers can match against the value returned by user decider/selector functions. */\n  branchId?: string;\n  /** Description of what this stage does. Used for narrative and tool descriptions. */\n  description?: string;\n\n  // ── Continuation pointers ──\n\n  /** Linear continuation (linked list next pointer) */\n  next?: StageNode<TOut, TScope>;\n  /** Parallel children (fork fan-out) */\n  children?: StageNode<TOut, TScope>[];\n\n  // ── Branching ──\n\n  /** Output-based selector: picks subset of children */\n  nextNodeSelector?: Selector;\n  /** When true, fn IS a scope-based decider that returns a branch ID string */\n  deciderFn?: boolean;\n  /** When true, fn IS a scope-based selector that returns branch ID(s) */\n  selectorFn?: boolean;\n\n  // ── Stage function ──\n\n  /** Embedded function; otherwise resolved from stageMap by `name` */\n  fn?: StageFunction<TOut, TScope>;\n\n  // ── Streaming ──\n\n  /** When true, Pipeline injects a streamCallback as 3rd parameter */\n  isStreaming?: boolean;\n  /** Unique stream identifier for routing tokens */\n  streamId?: string;\n\n  // ── Subflow ──\n\n  /** True if this is the root node of a mounted subflow */\n  isSubflowRoot?: boolean;\n  /** Mount id of the subflow (e.g., \"llm-core\") */\n  subflowId?: string;\n  /** Display name of the subflow */\n  subflowName?: string;\n  /** Reference key into the subflows dictionary */\n  $ref?: string;\n  /** Unique identifier for this mount instance */\n  mountId?: string;\n  /** Input/output mapping options for subflows */\n  subflowMountOptions?: SubflowMountOptions;\n  /** When true, parallel children use fail-fast semantics (reject on first error) */\n  failFast?: boolean;\n\n  // ── Pause/Resume ──\n\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n  /** Resume function — called instead of fn when resuming a paused stage. */\n  resumeFn?: ResumeFn<TScope>;\n\n  /**\n   * True if this node is a back-edge reference created by loopTo() — not an executable stage.\n   * Serialization equivalent: `SerializedPipelineStructure.isLoopReference` (different name\n   * to distinguish runtime graph field from the JSON-safe spec field).\n   */\n  isLoopRef?: boolean;\n\n  /** Inline subflow definition for dynamic subflow attachment.\n   *  When `root` is omitted, the subflow is structural-only:\n   *  the engine attaches `buildTimeStructure` for visualization\n   *  without executing any subflow stages (pre-executed subflow pattern). */\n  subflowDef?: {\n    root?: StageNode;\n    stageMap?: Map<string, StageFunction<TOut, TScope>>;\n    buildTimeStructure?: unknown;\n    subflows?: Record<string, { root: StageNode }>;\n  };\n\n  /** Lazy subflow resolver — called on first execution to obtain the FlowChart.\n   *  Used by `addLazySubFlowChartBranch()` to defer tree cloning until needed.\n   *  The resolver is called at most once per execution; the result replaces this field. */\n  subflowResolver?: () => {\n    root: StageNode;\n    stageMap: Map<string, StageFunction>;\n    buildTimeStructure?: unknown;\n    subflows?: Record<string, { root: StageNode }>;\n  };\n};\n\n// ---------------------------------------------------------------------------\n// isStageNodeReturn — duck-typing detection for dynamic continuation\n// ---------------------------------------------------------------------------\n\n/**\n * Detects if a stage output is a StageNode for dynamic continuation.\n *\n * Uses duck-typing: must have `name` (string) AND at least one continuation\n * property (non-empty children, next, nextNodeSelector, or isSubflowRoot).\n *\n * `isSubflowRoot` counts as continuation because subflow execution (or\n * structural annotation for pre-executed subflows) is a form of continuation.\n *\n * Safely handles proxy objects (e.g., Zod scope) that may throw on property access.\n */\nexport function isStageNodeReturn(output: unknown): output is StageNode {\n  if (!output || typeof output !== 'object') return false;\n\n  try {\n    const obj = output as Record<string, unknown>;\n    if (typeof obj.name !== 'string') return false;\n\n    const hasContinuation =\n      (Array.isArray(obj.children) && obj.children.length > 0) ||\n      obj.next !== undefined ||\n      typeof obj.nextNodeSelector === 'function' ||\n      obj.isSubflowRoot === true;\n\n    return hasContinuation;\n  } catch {\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StageNode.js","sourceRoot":"","sources":["../../../../../src/lib/engine/graph/StageNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAuHH,8EAA8E;AAC9E,qEAAqE;AACrE,8EAA8E;AAE9E;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAe;IAC/C,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAExD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAiC,CAAC;QAC9C,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAE/C,MAAM,eAAe,GACnB,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;YACxD,GAAG,CAAC,IAAI,KAAK,SAAS;YACtB,OAAO,GAAG,CAAC,gBAAgB,KAAK,UAAU;YAC1C,GAAG,CAAC,aAAa,KAAK,IAAI,CAAC;QAE7B,OAAO,eAAe,CAAC;IACzB,CAAC;IAAC,WAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["/**\n * StageNode — The graph node type for flowchart traversal.\n *\n * Defines the shape of each node in the flowchart DAG:\n * - Linear continuation via `next` (linked list traversal)\n * - Parallel fan-out via `children` (fork)\n * - Conditional branching via `deciderFn` (single-choice) or `selectorFn` (multi-choice)\n * - Back-edges via dynamic next (loop)\n * - Isolated sub-traversals via `isSubflowRoot` (subflow)\n */\n\nimport type { StageFunction, SubflowMountOptions } from '../types.js';\n\n/**\n * Resume function for pausable stages.\n * Unlike StageFunction, the 2nd argument is the resume input (not breakFn).\n */\nexport type ResumeFn<TScope = any, TInput = unknown> = (scope: TScope, input: TInput) => Promise<void> | void;\n\n// ---------------------------------------------------------------------------\n// Decider + Selector\n// ---------------------------------------------------------------------------\n\n/** Picks exactly ONE child by ID. Conditional branch (if/switch). */\nexport type Decider = (nodeArgs: any) => string | Promise<string>;\n\n/**\n * Picks ONE OR MORE children by ID. Filtered fan-out.\n * - Single string: behaves like Decider\n * - Array: selected children execute in parallel\n * - Empty array: skip all children\n */\nexport type Selector = (nodeArgs: any) => string | string[] | Promise<string | string[]>;\n\n// ---------------------------------------------------------------------------\n// StageNode\n// ---------------------------------------------------------------------------\n\nexport type StageNode<TOut = any, TScope = any> = {\n  /** Human-readable stage name; also used as the stageMap key */\n  name: string;\n  /** Stable identifier for visualization matching and branch aggregation. */\n  id: string;\n  /** Original branch identifier as supplied to addFunctionBranch() / addSubFlowChartBranch().\n   *  When a subflow prefix is applied to the node tree, this field preserves the\n   *  unprefixed ID so handlers can match against the value returned by user decider/selector functions. */\n  branchId?: string;\n  /** Description of what this stage does. Used for narrative and tool descriptions. */\n  description?: string;\n\n  // ── Continuation pointers ──\n\n  /** Linear continuation (linked list next pointer) */\n  next?: StageNode<TOut, TScope>;\n  /** Parallel children (fork fan-out) */\n  children?: StageNode<TOut, TScope>[];\n\n  // ── Branching ──\n\n  /** Output-based selector: picks subset of children */\n  nextNodeSelector?: Selector;\n  /** When true, fn IS a scope-based decider that returns a branch ID string */\n  deciderFn?: boolean;\n  /** When true, fn IS a scope-based selector that returns branch ID(s) */\n  selectorFn?: boolean;\n\n  // ── Stage function ──\n\n  /** Embedded function; otherwise resolved from stageMap by `name` */\n  fn?: StageFunction<TOut, TScope>;\n\n  // ── Streaming ──\n\n  /** When true, Pipeline injects a streamCallback as 3rd parameter */\n  isStreaming?: boolean;\n  /** Unique stream identifier for routing tokens */\n  streamId?: string;\n\n  // ── Subflow ──\n\n  /** True if this is the root node of a mounted subflow */\n  isSubflowRoot?: boolean;\n  /** Mount id of the subflow (e.g., \"llm-core\") */\n  subflowId?: string;\n  /** Display name of the subflow */\n  subflowName?: string;\n  /** Reference key into the subflows dictionary */\n  $ref?: string;\n  /** Unique identifier for this mount instance */\n  mountId?: string;\n  /** Input/output mapping options for subflows */\n  subflowMountOptions?: SubflowMountOptions;\n  /** When true, parallel children use fail-fast semantics (reject on first error) */\n  failFast?: boolean;\n\n  // ── Pause/Resume ──\n\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n  /** Resume function — called instead of fn when resuming a paused stage. */\n  resumeFn?: ResumeFn<TScope>;\n\n  /**\n   * True if this node is a back-edge reference created by loopTo() — not an executable stage.\n   * Serialization equivalent: `SerializedPipelineStructure.isLoopReference` (different name\n   * to distinguish runtime graph field from the JSON-safe spec field).\n   */\n  isLoopRef?: boolean;\n\n  /** Inline subflow definition for dynamic subflow attachment. */\n  subflowDef?: {\n    root: StageNode;\n    stageMap?: Map<string, StageFunction<TOut, TScope>>;\n    buildTimeStructure?: unknown;\n    subflows?: Record<string, { root: StageNode }>;\n  };\n\n  /** Lazy subflow resolver — called on first execution to obtain the FlowChart.\n   *  Used by `addLazySubFlowChartBranch()` to defer tree cloning until needed.\n   *  The resolver is called at most once per execution; the result replaces this field. */\n  subflowResolver?: () => {\n    root: StageNode;\n    stageMap: Map<string, StageFunction>;\n    buildTimeStructure?: unknown;\n    subflows?: Record<string, { root: StageNode }>;\n  };\n};\n\n// ---------------------------------------------------------------------------\n// isStageNodeReturn — duck-typing detection for dynamic continuation\n// ---------------------------------------------------------------------------\n\n/**\n * Detects if a stage output is a StageNode for dynamic continuation.\n *\n * Uses duck-typing: must have `name` (string) AND at least one continuation\n * property (non-empty children, next, nextNodeSelector, or isSubflowRoot).\n *\n * `isSubflowRoot` counts as continuation because subflow execution is a form of continuation.\n *\n * Safely handles proxy objects (e.g., Zod scope) that may throw on property access.\n */\nexport function isStageNodeReturn(output: unknown): output is StageNode {\n  if (!output || typeof output !== 'object') return false;\n\n  try {\n    const obj = output as Record<string, unknown>;\n    if (typeof obj.name !== 'string') return false;\n\n    const hasContinuation =\n      (Array.isArray(obj.children) && obj.children.length > 0) ||\n      obj.next !== undefined ||\n      typeof obj.nextNodeSelector === 'function' ||\n      obj.isSubflowRoot === true;\n\n    return hasContinuation;\n  } catch {\n    return false;\n  }\n}\n"]}

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

@@ -107,6 +107,34 @@ export class SubflowExecutor {
                 subflowResultsMap.set(key, value);
             }
         }
+        // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──
+        //
+        // If the subflow's inner traversal broke (because a stage called
+        // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,
+        // forward the break state to the PARENT's breakFlag. The parent
+        // traverser will see `shouldBreak` on its next step and stop.
+        //
+        // Without this, inner breaks are locally scoped to the subflow — the
+        // parent continues as if the subflow returned normally.
+        //
+        // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The
+        // outputMapper still executes, so the subflow's partial result still
+        // lands in the parent scope. Consumers who need to suppress output on
+        // break check the break state inside their outputMapper and early-return.
+        // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.
+        if (traverserHandle && (mountOptions === null || mountOptions === void 0 ? void 0 : mountOptions.propagateBreak) === true) {
+            const innerBreak = traverserHandle.getBreakState();
+            if (innerBreak.shouldBreak) {
+                breakFlag.shouldBreak = true;
+                if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {
+                    breakFlag.reason = innerBreak.reason;
+                }
+                // Raise a parent-level onBreak event so recorders can distinguish
+                // the inner originating break (fired inside the subflow) from this
+                // propagated one (fired at the mount level on the parent).
+                this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);
+            }
+        }
         const subflowTreeContext = nestedRuntime.getSnapshot();
         // ─── Output Mapping ───
         if (!subflowError && (mountOptions === null || mountOptions === void 0 ? void 0 : mountOptions.outputMapper)) {
@@ -160,4 +188,4 @@ export class SubflowExecutor {
         return subflowOutput;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {}\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Input Mapping ───\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // Narrative receives mapped input. inputMapper is a consumer function that may inject\n    // values not from the scope (bypassing redaction). The recorder renders per includeValues.\n    const narrativeInput = mappedInput;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import)\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const nestedRuntime = new ExecutionRuntimeClass(node.name, node.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with input\n    if (Object.keys(mappedInput).length > 0) {\n      seedSubflowGlobalStore(nestedRuntime, mappedInput);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation\n    const hasChildren = Boolean(node.children && node.children.length > 0);\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n      next: hasChildren ? undefined : node.next,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        root: subflowNode,\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw immediately.\n      // No error logging, no subflowResult recording — the pause is control flow.\n      if (isPauseSignal(error)) {\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: the subflow shares the parent's _redactedKeys Set (via the same ScopeFactory),\n        // so any key marked redacted in the subflow is already visible in the parent's scope.\n        // ScopeFacade.setValue checks _redactedKeys.has(key), so writes via outputMapper\n        // automatically inherit the subflow's dynamic redaction state.\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    subflowResultsMap.set(subflowId, subflowResult);\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(\n      subflowName,\n      subflowId,\n      parentTraversalContext,\n      subflowResult.treeContext?.globalContext,\n    );\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\nimport type { BreakFlag } from './types.js';\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {}\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: BreakFlag,\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Input Mapping ───\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // Narrative receives mapped input. inputMapper is a consumer function that may inject\n    // values not from the scope (bypassing redaction). The recorder renders per includeValues.\n    const narrativeInput = mappedInput;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import)\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const nestedRuntime = new ExecutionRuntimeClass(node.name, node.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with input\n    if (Object.keys(mappedInput).length > 0) {\n      seedSubflowGlobalStore(nestedRuntime, mappedInput);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation\n    const hasChildren = Boolean(node.children && node.children.length > 0);\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n      next: hasChildren ? undefined : node.next,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        root: subflowNode,\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw immediately.\n      // No error logging, no subflowResult recording — the pause is control flow.\n      if (isPauseSignal(error)) {\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──\n    //\n    // If the subflow's inner traversal broke (because a stage called\n    // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,\n    // forward the break state to the PARENT's breakFlag. The parent\n    // traverser will see `shouldBreak` on its next step and stop.\n    //\n    // Without this, inner breaks are locally scoped to the subflow — the\n    // parent continues as if the subflow returned normally.\n    //\n    // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The\n    // outputMapper still executes, so the subflow's partial result still\n    // lands in the parent scope. Consumers who need to suppress output on\n    // break check the break state inside their outputMapper and early-return.\n    // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.\n    if (traverserHandle && mountOptions?.propagateBreak === true) {\n      const innerBreak = traverserHandle.getBreakState();\n      if (innerBreak.shouldBreak) {\n        breakFlag.shouldBreak = true;\n        if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = innerBreak.reason;\n        }\n        // Raise a parent-level onBreak event so recorders can distinguish\n        // the inner originating break (fired inside the subflow) from this\n        // propagated one (fired at the mount level on the parent).\n        this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: the subflow shares the parent's _redactedKeys Set (via the same ScopeFactory),\n        // so any key marked redacted in the subflow is already visible in the parent's scope.\n        // ScopeFacade.setValue checks _redactedKeys.has(key), so writes via outputMapper\n        // automatically inherit the subflow's dynamic redaction state.\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    subflowResultsMap.set(subflowId, subflowResult);\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(\n      subflowName,\n      subflowId,\n      parentTraversalContext,\n      subflowResult.treeContext?.globalContext,\n    );\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n}\n"]}

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

@@ -6,4 +6,4 @@
  * All types are callbacks that break circular dependencies with FlowchartTraverser.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/engine/index.js

@@ -26,4 +26,4 @@ export { RLENarrativeFlowRecorder } from './narrative/recorders/RLENarrativeFlow
 export { SeparateNarrativeFlowRecorder } from './narrative/recorders/SeparateNarrativeFlowRecorder.js';
 export { SilentNarrativeFlowRecorder } from './narrative/recorders/SilentNarrativeFlowRecorder.js';
 export { WindowedNarrativeFlowRecorder } from './narrative/recorders/WindowedNarrativeFlowRecorder.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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