footprintjs 5.0.0 → 6.1.0

package/dist/types/lib/engine/narrative/index.d.ts

@@ -5,7 +5,7 @@ export { NullControlFlowNarrativeGenerator } from './NullControlFlowNarrativeGen
 export type { IControlFlowNarrative } from './types.js';
 export { FlowRecorderDispatcher } from './FlowRecorderDispatcher.js';
 export { NarrativeFlowRecorder } from './NarrativeFlowRecorder.js';
-export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './types.js';
+export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './types.js';
 export { AdaptiveNarrativeFlowRecorder } from './recorders/AdaptiveNarrativeFlowRecorder.js';
 export { MilestoneNarrativeFlowRecorder } from './recorders/MilestoneNarrativeFlowRecorder.js';
 export { ProgressiveNarrativeFlowRecorder } from './recorders/ProgressiveNarrativeFlowRecorder.js';

package/dist/types/lib/engine/narrative/types.d.ts

@@ -13,9 +13,25 @@ import type { StructuredErrorInfo } from '../errors/errorInfo.js';
  * Uses Null Object pattern: NullControlFlowNarrativeGenerator satisfies this
  * interface with empty methods for zero-cost disabled path.
  */
+/**
+ * The kind of stage that completed. Lets consumers route uniform
+ * "did this stage execute" handling without a side-table lookup into
+ * the chart spec. Required on every `onStageExecuted` event since
+ * proposal #003 unified the event to fire for ALL stage kinds.
+ */
+export type StageType = 'linear' | 'decider' | 'fork' | 'selector' | 'subflow-mount';
 export interface IControlFlowNarrative {
-    /** Called when a stage executes. First stage uses distinct opening pattern. */
-    onStageExecuted(stageName: string, description?: string, traversalContext?: TraversalContext): void;
+    /**
+     * Called when a stage completes its main work. Fires for ALL stage
+     * kinds (`'linear'`, `'decider'`, `'fork'`, `'selector'`, `'subflow-mount'`)
+     * AFTER the corresponding specialized event (`onDecision`, `onFork`,
+     * `onSelected`, `onSubflowEntry`). For linear stages, fires after
+     * the stage function returns.
+     *
+     * Consumers tracking "did this stage run?" use this event uniformly
+     * and switch on `stageType` for kind-specific work.
+     */
+    onStageExecuted(stageName: string, description: string | undefined, traversalContext: TraversalContext | undefined, stageType: StageType): void;
     /** Called on linear continuation from one stage to the next. */
     onNext(fromStage: string, toStage: string, description?: string, traversalContext?: TraversalContext): void;
     /** Called when a decider selects a branch. Most valuable for LLM context. */
@@ -61,6 +77,22 @@ export interface IControlFlowNarrative {
      * NOT fire this event — they fire `onSubflowExit`.
      */
     onRunEnd(output: unknown, traversalContext?: TraversalContext): void;
+    /**
+     * Called once per top-level `executor.run()` when traversal throws a
+     * NON-pause error, BEFORE the exception propagates to `run()`'s caller.
+     *
+     * This is the TERMINAL counterpart to `onRunEnd` — it closes the run
+     * boundary symmetrically so every `onRunStart` is followed by exactly
+     * one of `onRunEnd` (clean) or `onRunFailed` (error). Without it, a
+     * live monitor sees `onRunStart` then silence on a failed run and can't
+     * tell "still running" from "crashed."
+     *
+     * Errors STILL throw — this is the observable terminal signal, not a
+     * recovery mechanism (no routing, no error-subflow). Pause is NOT an
+     * error, so it does not fire this. Subflow-traversers do NOT fire it;
+     * their errors propagate to the parent and surface at the top level.
+     */
+    onRunFailed(error: StructuredErrorInfo, traversalContext?: TraversalContext): void;
     /** Returns accumulated narrative sentences in execution order. */
     getSentences(): string[];
 }
@@ -115,6 +147,12 @@ export interface FlowStageEvent {
     description?: string;
     /** Traversal context from the engine — read-only, set by traverser. */
     traversalContext?: TraversalContext;
+    /**
+     * Which kind of stage completed. The engine fires `onStageExecuted`
+     * uniformly for every stage kind (proposal #003); consumers route by
+     * `stageType` without a chart-spec lookup.
+     */
+    stageType: StageType;
 }
 /** Event passed to FlowRecorder.onNext. */
 export interface FlowNextEvent {
@@ -242,6 +280,18 @@ export interface FlowRunEvent {
     payload?: unknown;
     traversalContext?: TraversalContext;
 }
+/**
+ * Event passed to FlowRecorder.onRunFailed — the TERMINAL failure boundary
+ * for a top-level run. Mirror of `onRunEnd` for the error path: it fires
+ * once, during traversal, when the run throws a non-pause error, before
+ * the exception propagates. Carries the structured error (field-level
+ * issues, codes) rather than a flattened string.
+ */
+export interface FlowRunFailedEvent {
+    /** Structured details of the error that terminated the run. */
+    structuredError: StructuredErrorInfo;
+    traversalContext?: TraversalContext;
+}
 /**
  * FlowRecorder — Pluggable observer for control flow events.
  *
@@ -287,6 +337,13 @@ export interface FlowRecorder {
      * pause (the run didn't end) or uncaught error.
      */
     onRunEnd?(event: FlowRunEvent): void;
+    /**
+     * Called once per top-level `executor.run()` when the run throws a
+     * non-pause error, BEFORE the exception propagates. The TERMINAL
+     * counterpart to `onRunEnd` — lets a monitor close the run boundary on
+     * failure instead of waiting forever. NOT fired on pause.
+     */
+    onRunFailed?(event: FlowRunFailedEvent): void;
     /** Called before each run to reset per-run state. Implement for stateful recorders. */
     clear?(): void;
     /** Optional: expose collected data for inclusion in snapshots. */

package/dist/types/lib/engine/runtimeStageId.d.ts

@@ -14,6 +14,15 @@
  *   - Human-readable ('sf-tools/execute-tool-calls#8')
  *   - Parseable (split on '#' for stageId and index, split stageId on '/' for subflow path)
  *
+ * Naming-collision warning
+ * ────────────────────────
+ *   The parsed-output `.stageId` field below is the LOCAL form (segment
+ *   after the last '/'). This is NOT the same as `spec.id` / `node.id`
+ *   for subflow-nested stages, which carry the FULL prefixed form
+ *   (`'sf-tools/execute-tool-calls'`). To compare safely, use
+ *   `splitStageId(spec.id)` to decompose the prefixed form the same
+ *   way `parseRuntimeStageId` decomposes a runtimeStageId.
+ *
  * @example
  * ```
  * buildRuntimeStageId('call-llm', 5)                    // 'call-llm#5'
@@ -29,12 +38,59 @@
  * consumers constructing IDs from parsed components (round-trip via parseRuntimeStageId).
  */
 export declare function buildRuntimeStageId(stageId: string, executionIndex: number, subflowPath?: string): string;
-/** Parse a runtimeStageId into its components. */
+/**
+ * Parse a runtimeStageId into its components.
+ *
+ * IMPORTANT — naming collision: the returned `stageId` is the LOCAL
+ * form (the segment between the last '/' and the '#'). This is NOT
+ * the same as `spec.id` or `node.id` for subflow-nested stages,
+ * which contain the FULL prefixed form.
+ *
+ *   parseRuntimeStageId('sf-tools/execute-tool-calls#8').stageId
+ *   // → 'execute-tool-calls'   (LOCAL)
+ *
+ *   node.id  // (post-mount, in a spec that contains subflows)
+ *   // → 'sf-tools/execute-tool-calls'   (FULL prefixed)
+ *
+ * To compare these two safely, use `splitStageId(node.id)` to get
+ * the local form, OR reconstruct the full form via
+ * `(subflowPath ? subflowPath + '/' : '') + stageId`.
+ */
 export declare function parseRuntimeStageId(runtimeStageId: string): {
     stageId: string;
     executionIndex: number;
     subflowPath: string | undefined;
 };
+/**
+ * Decompose a (possibly prefixed) stage id into its components.
+ *
+ * Use this when you have an id WITHOUT the `#N` execution suffix and
+ * need the local stage name and/or the subflow path. Common sources
+ * of such ids:
+ *   - `spec.id` (post-mount the id includes any subflow prefix)
+ *   - `CommitBundle.stageId` (post-mount id)
+ *   - `node.id` from xyflow nodes built off the spec
+ *   - the segment of `runtimeStageId` BEFORE the `#` (use
+ *     `parseRuntimeStageId` directly for full runtimeStageId strings)
+ *
+ * Mirrors the decomposition `parseRuntimeStageId` performs on the
+ * stageId portion of a runtimeStageId, so the two helpers stay in
+ * lockstep on naming and behavior.
+ *
+ * @example
+ * splitStageId('sf-tools/execute-tool-calls')
+ * // → { localStageId: 'execute-tool-calls', subflowPath: 'sf-tools' }
+ *
+ * splitStageId('execute-tool-calls')
+ * // → { localStageId: 'execute-tool-calls', subflowPath: undefined }
+ *
+ * splitStageId('sf-outer/sf-inner/validate')
+ * // → { localStageId: 'validate', subflowPath: 'sf-outer/sf-inner' }
+ */
+export declare function splitStageId(prefixedStageId: string): {
+    localStageId: string;
+    subflowPath: string | undefined;
+};
 /**
  * Shared mutable counter for execution index.
  * Passed by reference to child traversers (subflows) so they

package/dist/types/lib/engine/traversal/FlowchartTraverser.d.ts

@@ -21,7 +21,7 @@
 import type { ScopeProtectionMode } from '../../scope/protection/types.js';
 import { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';
 import type { FlowRecorder, IControlFlowNarrative } from '../narrative/types.js';
-import type { ExtractorError, IExecutionRuntime, ILogger, ScopeFactory, SerializedPipelineStructure, StageFunction, StageNode, StreamHandlers, SubflowResult, TraversalExtractor, TraversalResult } from '../types.js';
+import type { IExecutionRuntime, ILogger, ScopeFactory, SerializedPipelineStructure, StageFunction, StageNode, StreamHandlers, SubflowResult, TraversalResult } from '../types.js';
 export interface TraverserOptions<TOut = any, TScope = any> {
     root: StageNode<TOut, TScope>;
     stageMap: Map<string, StageFunction<TOut, TScope>>;
@@ -32,12 +32,10 @@ export interface TraverserOptions<TOut = any, TScope = any> {
     executionEnv?: import('../../engine/types').ExecutionEnv;
     throttlingErrorChecker?: (error: unknown) => boolean;
     streamHandlers?: StreamHandlers;
-    extractor?: TraversalExtractor;
     scopeProtectionMode?: ScopeProtectionMode;
     subflows?: Record<string, {
         root: StageNode<TOut, TScope>;
     }>;
-    enrichSnapshots?: boolean;
     narrativeEnabled?: boolean;
     buildTimeStructure?: SerializedPipelineStructure;
     logger: ILogger;
@@ -103,7 +101,6 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     private readonly deciderHandler;
     private readonly selectorHandler;
     private readonly structureManager;
-    private readonly extractorRunner;
     private readonly narrativeGenerator;
     private readonly flowRecorderDispatcher;
     private subflowResults;
@@ -194,8 +191,6 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     getBranchIds(): string[];
     getRuntimeRoot(): StageNode;
     getSubflowResults(): Map<string, SubflowResult>;
-    getExtractedResults<TResult = unknown>(): Map<string, TResult>;
-    getExtractorErrors(): ExtractorError[];
     getNarrative(): string[];
     /** Returns the FlowRecorderDispatcher, or undefined if narrative is disabled. */
     getFlowRecorderDispatcher(): FlowRecorderDispatcher | undefined;

package/dist/types/lib/engine/types.d.ts

@@ -88,6 +88,25 @@ export interface SubflowMountOptions<TParentScope = any, TSubflowInput = any, TS
      * @default ArrayMergeMode.Concat
      */
     arrayMerge?: ArrayMergeMode;
+    /**
+     * STRUCTURE-ONLY: the downstream stage id this branch's convergence edge
+     * points to, overriding the default "converge at the next linear stage."
+     *
+     * When a fork/selector/decider branch carries `convergeAt`, its visualized
+     * `next` edge is fired to the named stage instead of to the shared
+     * convergence node its siblings use. This expresses an unequal-depth merge
+     * — e.g. a `tools` slot that bypasses the `messageAPI` assembly node and
+     * pairs with its output at `call-llm` (so `call-llm` reads as a 2-parent
+     * merge), faithful to the Anthropic wire protocol (system+messages = the
+     * message payload; tools = a separate top-level field).
+     *
+     * **This affects the STRUCTURE/topology graph only** — the runtime is
+     * unchanged (the branch's outputs ride shared scope; the named target reads
+     * them when it runs). It does NOT introduce a join barrier. The target is a
+     * FORWARD stage (added later in the chain), so it is not validated at
+     * branch-declaration time.
+     */
+    convergeAt?: string;
     /**
      * When `true`, an inner `scope.$break(reason)` call inside this subflow
      * propagates up to the parent — i.e., the parent's `breakFlag` is set
@@ -323,32 +342,6 @@ export interface RuntimeStructureMetadata {
     isLoopReference?: boolean;
     streamId?: string;
 }
-export interface StageSnapshot<TOut = any, TScope = any> {
-    node: StageNode<TOut, TScope>;
-    context: StageContext;
-    stepNumber: number;
-    structureMetadata: RuntimeStructureMetadata;
-    scopeState?: Record<string, unknown>;
-    debugInfo?: {
-        logs: Record<string, unknown>;
-        errors: Record<string, unknown>;
-        metrics: Record<string, unknown>;
-        evals: Record<string, unknown>;
-        flowMessages?: FlowMessage[];
-    };
-    stageOutput?: unknown;
-    errorInfo?: {
-        type: string;
-        message: string;
-    };
-    historyIndex?: number;
-}
-export type TraversalExtractor<TResult = unknown> = (snapshot: StageSnapshot) => TResult | undefined | null;
-export interface ExtractorError {
-    stagePath: string;
-    message: string;
-    error: unknown;
-}
 export type NodeResultType = {
     id: string;
     result: unknown;

package/dist/types/lib/engine/walkSubflowSpec.d.ts

@@ -0,0 +1,95 @@
+/**
+ * walkSubflowSpec — yield the structural shape of a subflow spec as a
+ * flat ordered stream of items, with `subflowPath` already composed
+ * for nested subflows.
+ *
+ * This is the public contract for traversing the structure delivered
+ * via `StructureSubflowMountedEvent.subflowSpec`. Item shapes mirror
+ * the corresponding Structure event payloads so consumers can route
+ * walker items through the same handlers they use for live events.
+ *
+ * Walker contract (LOCKED):
+ *   1. AUTO-RECURSE by default into nested subflows, with composed
+ *      paths (`parent/child/...`). Pass `{ recurse: false }` to walk
+ *      only one level.
+ *   2. ENTRY-STAGE MARKER FIRST: for each subflow (top-level and
+ *      nested), yields a `{ kind: 'subflow-start', ... }` item BEFORE
+ *      any stage/edge items from that subflow. Lets consumers draw the
+ *      boundary edge from the mount node to the entry stage.
+ *   3. COMPOSED PATHS: nested subflows get `parentPath + '/' + localId`.
+ *      Top-level mount paths are local-only (`'auth'`, NOT `'__root__/auth'`).
+ *   4. SHAPE MIRRORING: stage/edge/loop items have the same payload
+ *      shape as Structure events, with `subflowPath` added.
+ *   5. SOURCE DISCRIMINATOR: every walker item carries `source: 'walker'`
+ *      (Structure events do NOT). Lets consumers distinguish event vs
+ *      walker in logs/debuggers while still sharing handler code paths.
+ *   6. STAGE-ID PREFIXING: stage IDs in nested subflows are already
+ *      prefixed by the spec (e.g. `'auth/verify/check'`). Walker
+ *      preserves this; `subflowPath` field is redundant-but-explicit.
+ */
+import type { SerializedPipelineStructure } from '../builder/types.js';
+export interface WalkerOptions {
+    /** Auto-recurse into nested subflows (default: true). When false,
+     *  nested subflow items are yielded but their internals are not
+     *  traversed. */
+    recurse?: boolean;
+}
+export type WalkerItem = {
+    kind: 'subflow-start';
+    stageId: string;
+    subflowPath: string;
+    source: 'walker';
+} | {
+    kind: 'stage';
+    stageId: string;
+    name: string;
+    type: NonNullable<SerializedPipelineStructure['type']>;
+    isPausable?: boolean;
+    spec: SerializedPipelineStructure;
+    subflowPath: string;
+    source: 'walker';
+} | {
+    kind: 'edge';
+    from: string;
+    to: string;
+    edgeKind: 'next' | 'fork-branch' | 'decision-branch';
+    label?: string;
+    subflowPath: string;
+    source: 'walker';
+} | {
+    kind: 'loop';
+    from: string;
+    to: string;
+    subflowPath: string;
+    source: 'walker';
+} | {
+    kind: 'subflow';
+    mountStageId: string;
+    subflowId: string;
+    subflowName: string;
+    subflowSpec: SerializedPipelineStructure;
+    subflowPath: string;
+    source: 'walker';
+};
+/**
+ * Walk a subflow spec, yielding its structure as flat ordered items.
+ *
+ * @example
+ * ```ts
+ * import { walkSubflowSpec } from 'footprintjs/trace';
+ *
+ * onSubflowMounted(event) {
+ *   if (!event.subflowSpec) return; // lazy mount — no spec yet
+ *   for (const item of walkSubflowSpec(event.subflowSpec, event.subflowPath)) {
+ *     switch (item.kind) {
+ *       case 'subflow-start': break;        // entry boundary
+ *       case 'stage':         break;        // inner stage
+ *       case 'edge':          break;        // inner edge
+ *       case 'loop':          break;        // inner loop back-edge
+ *       case 'subflow':       break;        // nested mount marker
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function walkSubflowSpec(spec: SerializedPipelineStructure, subflowPath: string, options?: WalkerOptions): Generator<WalkerItem, void, void>;

package/dist/types/lib/runner/FlowChartExecutor.d.ts

@@ -9,7 +9,7 @@
  *   const executor = new FlowChartExecutor(chart);
  *
  *   // Options-object form (preferred when you need to customize behavior):
- *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory, enrichSnapshots: true });
+ *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory });
  *
  *   // 2-param form (accepts a ScopeFactory directly, for backward compatibility):
  *   const executor = new FlowChartExecutor(chart, myFactory);
@@ -21,7 +21,7 @@ import type { CombinedNarrativeRecorderOptions } from '../engine/narrative/Combi
 import type { CombinedNarrativeEntry } from '../engine/narrative/narrativeTypes.js';
 import type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';
 import type { FlowRecorder } from '../engine/narrative/types.js';
-import { type ExecutorResult, type ExtractorError, type RunOptions, type ScopeFactory, type SerializedPipelineStructure, type StageNode, type StreamHandlers, type SubflowResult } from '../engine/types.js';
+import { type ExecutorResult, type RunOptions, type ScopeFactory, type SerializedPipelineStructure, type StageNode, type StreamHandlers, type SubflowResult } from '../engine/types.js';
 import type { FlowchartCheckpoint } from '../pause/types.js';
 import type { CombinedRecorder } from '../recorder/CombinedRecorder.js';
 import type { EmitRecorder } from '../recorder/EmitRecorder.js';
@@ -34,7 +34,7 @@ import { type RuntimeSnapshot } from './ExecutionRuntime.js';
  * ```typescript
  * const ex = new FlowChartExecutor(chart, {
  *   scopeFactory: myFactory,
- *   enrichSnapshots: true,
+ *   defaultValuesForContext: { ... },
  * });
  * ```
  *
@@ -50,14 +50,6 @@ import { type RuntimeSnapshot } from './ExecutionRuntime.js';
 export interface FlowChartExecutorOptions<TScope = any> {
     /** Custom scope factory. Defaults to TypedScope or ScopeFacade auto-detection. */
     scopeFactory?: ScopeFactory<TScope>;
-    /**
-     * Attach a per-stage scope snapshot to each extractor result. When `true`, the
-     * extraction callback receives the full shared state at the point that stage
-     * committed — useful for debugging multi-stage state transitions. Defaults to
-     * `false` (no scope snapshot attached). Can also be set on the chart via
-     * `flowChart(...).enrichSnapshots(true)`.
-     */
-    enrichSnapshots?: boolean;
     /**
      * Default values pre-populated into the shared context before **each** stage
      * (re-applied every stage, acting as baseline defaults).
@@ -121,7 +113,7 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      *
      * **Options object form** (preferred):
      * ```typescript
-     * new FlowChartExecutor(chart, { scopeFactory, enrichSnapshots: true })
+     * new FlowChartExecutor(chart, { scopeFactory, defaultValuesForContext })
      * ```
      *
      * **2-param form** (also supported):
@@ -419,10 +411,6 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
     getRuntimeStructure(): SerializedPipelineStructure | undefined;
     /** @internal */
     getSubflowResults(): Map<string, SubflowResult>;
-    /** @internal */
-    getExtractedResults<TResult = unknown>(): Map<string, TResult>;
-    /** @internal */
-    getExtractorErrors(): ExtractorError[];
     /**
      * Returns the subflow manifest from an attached ManifestFlowRecorder.
      * Returns empty array if no ManifestFlowRecorder is attached.

package/dist/types/trace.d.ts

@@ -21,7 +21,9 @@
  * ```
  */
 export type { ExecutionCounter } from './lib/engine/runtimeStageId.js';
-export { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/engine/runtimeStageId.js';
+export { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId, splitStageId, } from './lib/engine/runtimeStageId.js';
+export type { WalkerItem, WalkerOptions } from './lib/engine/walkSubflowSpec.js';
+export { walkSubflowSpec } from './lib/engine/walkSubflowSpec.js';
 export { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';
 export type { CausalChainOptions, CausalNode, KeysReadLookup } from './lib/memory/backtrack.js';
 export { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/backtrack.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "5.0.0",
+  "version": "6.1.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -55,7 +55,9 @@
     "format": "prettier --config .prettierrc.js --list-different '{src,test}/**/*.ts'",
     "bench": "npx tsx bench/run.ts",
     "docs": "typedoc",
-    "docs:serve": "typedoc && npx serve docs"
+    "docs:serve": "typedoc && npx serve docs",
+    "test:coverage": "vitest run --coverage --coverage.reporter=json-summary --coverage.reporter=text-summary --coverage.reportsDirectory=coverage",
+    "coverage:badge": "npm run test:coverage; node scripts/coverage-badge.mjs"
   },
   "files": [
     "dist/**/*",
@@ -113,6 +115,7 @@
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^5.61.0",
     "@typescript-eslint/parser": "^5.61.0",
+    "@vitest/coverage-v8": "^4.1.8",
     "concurrently": "^8.0.1",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "^6.15.0",
@@ -129,6 +132,5 @@
     "typedoc": "^0.28.17",
     "typescript": "~5.4.5",
     "vitest": "^4.0.18"
-  },
-  "dependencies": {}
+  }
 }

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

@@ -1,122 +0,0 @@
-/**
- * ExtractorRunner — Per-stage snapshot extraction.
- *
- * Coordinates traversal extractor invocations: step counting,
- * snapshot enrichment, error collection, and result storage.
- */
-import { computeNodeType } from './RuntimeStructureManager.js';
-export class ExtractorRunner {
-    extractor;
-    enrichSnapshots;
-    executionRuntime;
-    logger;
-    extractedResults = new Map();
-    extractorErrors = [];
-    stepCounter = 0;
-    /** Current subflow context for metadata propagation. Set/cleared during subflow execution. */
-    currentSubflowId;
-    /** Current fork context for metadata propagation. Set/cleared during parallel children execution. */
-    currentForkId;
-    constructor(extractor, enrichSnapshots, executionRuntime, logger) {
-        this.extractor = extractor;
-        this.enrichSnapshots = enrichSnapshots;
-        this.executionRuntime = executionRuntime;
-        this.logger = logger;
-    }
-    /**
-     * Call the extractor for a stage and store the result.
-     * Increments stepCounter (1-based) before creating snapshot.
-     */
-    callExtractor(node, context, stagePath, stageOutput, errorInfo) {
-        if (!this.extractor)
-            return;
-        this.stepCounter++;
-        try {
-            const snapshot = {
-                node,
-                context,
-                stepNumber: this.stepCounter,
-                structureMetadata: this.buildStructureMetadata(node),
-            };
-            if (this.enrichSnapshots) {
-                try {
-                    snapshot.scopeState = { ...this.executionRuntime.globalStore.getState() };
-                    snapshot.debugInfo = {
-                        logs: { ...context.debug.logContext },
-                        errors: { ...context.debug.errorContext },
-                        metrics: { ...context.debug.metricContext },
-                        evals: { ...context.debug.evalContext },
-                    };
-                    if (context.debug.flowMessages.length > 0) {
-                        snapshot.debugInfo.flowMessages = [...context.debug.flowMessages];
-                    }
-                    snapshot.stageOutput = stageOutput;
-                    if (errorInfo) {
-                        snapshot.errorInfo = errorInfo;
-                    }
-                    snapshot.historyIndex = this.executionRuntime.executionHistory.list().length;
-                }
-                catch (enrichError) {
-                    this.logger.warn(`Enrichment error at stage '${stagePath}':`, { error: enrichError });
-                }
-            }
-            const result = this.extractor(snapshot);
-            if (result !== undefined && result !== null) {
-                this.extractedResults.set(stagePath, result);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Extractor error at stage '${stagePath}':`, { error });
-            this.extractorErrors.push({
-                stagePath,
-                message: error?.message ?? String(error),
-                error,
-            });
-        }
-    }
-    /**
-     * Generate the stage path for extractor results.
-     * Uses node.id combined with branchPath.
-     */
-    getStagePath(node, branchPath, contextStageName) {
-        const baseName = node.id;
-        const nodeId = contextStageName && contextStageName !== node.name ? contextStageName : baseName;
-        if (!branchPath)
-            return nodeId;
-        return `${branchPath}.${nodeId}`;
-    }
-    buildStructureMetadata(node) {
-        const metadata = {
-            type: computeNodeType(node),
-        };
-        if (node.isSubflowRoot) {
-            metadata.isSubflowRoot = true;
-            metadata.subflowId = node.subflowId;
-            metadata.subflowName = node.subflowName;
-        }
-        else if (this.currentSubflowId) {
-            metadata.subflowId = this.currentSubflowId;
-        }
-        if (this.currentForkId) {
-            metadata.isParallelChild = true;
-            metadata.parallelGroupId = this.currentForkId;
-        }
-        if (node.isStreaming) {
-            metadata.streamId = node.streamId;
-        }
-        const hasDynamicChildren = Boolean(node.children?.length && !node.nextNodeSelector && node.fn);
-        if (hasDynamicChildren) {
-            metadata.isDynamic = true;
-        }
-        return metadata;
-    }
-    /** Returns extracted results collected during execution. */
-    getExtractedResults() {
-        return this.extractedResults;
-    }
-    /** Returns errors encountered during extraction. */
-    getExtractorErrors() {
-        return this.extractorErrors;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExtractorRunner.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ExtractorRunner.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ExtractorRunner — Per-stage snapshot extraction.\n *\n * Coordinates traversal extractor invocations: step counting,\n * snapshot enrichment, error collection, and result storage.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type {\n  ExtractorError,\n  IExecutionRuntime,\n  ILogger,\n  RuntimeStructureMetadata,\n  StageSnapshot,\n  TraversalExtractor,\n} from '../types.js';\nimport { computeNodeType } from './RuntimeStructureManager.js';\n\nexport class ExtractorRunner<TOut = any, TScope = any> {\n  private readonly extractor?: TraversalExtractor;\n  private readonly enrichSnapshots: boolean;\n  private readonly executionRuntime: IExecutionRuntime;\n  private readonly logger: ILogger;\n\n  private extractedResults: Map<string, unknown> = new Map();\n  private extractorErrors: ExtractorError[] = [];\n  private stepCounter = 0;\n\n  /** Current subflow context for metadata propagation. Set/cleared during subflow execution. */\n  currentSubflowId?: string;\n\n  /** Current fork context for metadata propagation. Set/cleared during parallel children execution. */\n  currentForkId?: string;\n\n  constructor(\n    extractor: TraversalExtractor | undefined,\n    enrichSnapshots: boolean,\n    executionRuntime: IExecutionRuntime,\n    logger: ILogger,\n  ) {\n    this.extractor = extractor;\n    this.enrichSnapshots = enrichSnapshots;\n    this.executionRuntime = executionRuntime;\n    this.logger = logger;\n  }\n\n  /**\n   * Call the extractor for a stage and store the result.\n   * Increments stepCounter (1-based) before creating snapshot.\n   */\n  callExtractor(\n    node: StageNode,\n    context: StageContext,\n    stagePath: string,\n    stageOutput?: unknown,\n    errorInfo?: { type: string; message: string },\n  ): void {\n    if (!this.extractor) return;\n\n    this.stepCounter++;\n\n    try {\n      const snapshot: StageSnapshot = {\n        node,\n        context,\n        stepNumber: this.stepCounter,\n        structureMetadata: this.buildStructureMetadata(node),\n      };\n\n      if (this.enrichSnapshots) {\n        try {\n          snapshot.scopeState = { ...this.executionRuntime.globalStore.getState() };\n\n          snapshot.debugInfo = {\n            logs: { ...context.debug.logContext },\n            errors: { ...context.debug.errorContext },\n            metrics: { ...context.debug.metricContext },\n            evals: { ...context.debug.evalContext },\n          };\n          if (context.debug.flowMessages.length > 0) {\n            snapshot.debugInfo.flowMessages = [...context.debug.flowMessages];\n          }\n\n          snapshot.stageOutput = stageOutput;\n\n          if (errorInfo) {\n            snapshot.errorInfo = errorInfo;\n          }\n\n          snapshot.historyIndex = this.executionRuntime.executionHistory.list().length;\n        } catch (enrichError: any) {\n          this.logger.warn(`Enrichment error at stage '${stagePath}':`, { error: enrichError });\n        }\n      }\n\n      const result = this.extractor(snapshot);\n\n      if (result !== undefined && result !== null) {\n        this.extractedResults.set(stagePath, result);\n      }\n    } catch (error: any) {\n      this.logger.error(`Extractor error at stage '${stagePath}':`, { error });\n      this.extractorErrors.push({\n        stagePath,\n        message: error?.message ?? String(error),\n        error,\n      });\n    }\n  }\n\n  /**\n   * Generate the stage path for extractor results.\n   * Uses node.id combined with branchPath.\n   */\n  getStagePath(node: StageNode, branchPath?: string, contextStageName?: string): string {\n    const baseName = node.id;\n    const nodeId = contextStageName && contextStageName !== node.name ? contextStageName : baseName;\n    if (!branchPath) return nodeId;\n    return `${branchPath}.${nodeId}`;\n  }\n\n  private buildStructureMetadata(node: StageNode): RuntimeStructureMetadata {\n    const metadata: RuntimeStructureMetadata = {\n      type: computeNodeType(node),\n    };\n\n    if (node.isSubflowRoot) {\n      metadata.isSubflowRoot = true;\n      metadata.subflowId = node.subflowId;\n      metadata.subflowName = node.subflowName;\n    } else if (this.currentSubflowId) {\n      metadata.subflowId = this.currentSubflowId;\n    }\n\n    if (this.currentForkId) {\n      metadata.isParallelChild = true;\n      metadata.parallelGroupId = this.currentForkId;\n    }\n\n    if (node.isStreaming) {\n      metadata.streamId = node.streamId;\n    }\n\n    const hasDynamicChildren = Boolean(node.children?.length && !node.nextNodeSelector && node.fn);\n    if (hasDynamicChildren) {\n      metadata.isDynamic = true;\n    }\n\n    return metadata;\n  }\n\n  /** Returns extracted results collected during execution. */\n  getExtractedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.extractedResults as Map<string, TResult>;\n  }\n\n  /** Returns errors encountered during extraction. */\n  getExtractorErrors(): ExtractorError[] {\n    return this.extractorErrors;\n  }\n}\n"]}