footprintjs 3.0.21 → 4.0.0

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

@@ -13,7 +13,7 @@ import type { SerializedPipelineStructure } from '../types.js';
  * Compute the node type from node properties.
  * Shared by RuntimeStructureManager (serialization) and ExtractorRunner (metadata).
  */
-export declare function computeNodeType(node: StageNode): 'stage' | 'decider' | 'fork' | 'streaming';
+export declare function computeNodeType(node: StageNode): 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow';
 export declare class RuntimeStructureManager {
     private runtimePipelineStructure?;
     private structureNodeMap;
@@ -21,6 +21,7 @@ export declare class RuntimeStructureManager {
     init(buildTimeStructure?: SerializedPipelineStructure): void;
     /** Returns the current runtime structure (mutated during execution). */
     getStructure(): SerializedPipelineStructure | undefined;
+    private static readonly MAX_NODE_MAP_DEPTH;
     /** Recursively registers all nodes in the O(1) lookup map. */
     private buildNodeMap;
     /** Convert a runtime StageNode into a SerializedPipelineStructure node. */

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

@@ -10,7 +10,6 @@ export { isStageNodeReturn } from './graph/StageNode.js';
 export * from './types.js';
 export * from './handlers/index.js';
 export type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './narrative/CombinedNarrativeBuilder.js';
-export { ControlFlowNarrativeGenerator } from './narrative/ControlFlowNarrativeGenerator.js';
 export { NullControlFlowNarrativeGenerator } from './narrative/NullControlFlowNarrativeGenerator.js';
 export type { IControlFlowNarrative } from './narrative/types.js';
 export { FlowRecorderDispatcher } from './narrative/FlowRecorderDispatcher.js';

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

@@ -5,7 +5,7 @@
  * Use CombinedNarrativeRecorder (auto-attached by setEnableNarrative()) instead.
  */
 export interface CombinedNarrativeEntry {
-    type: 'stage' | 'step' | 'condition' | 'fork' | 'subflow' | 'loop' | 'break' | 'error';
+    type: 'stage' | 'step' | 'condition' | 'fork' | 'selector' | 'subflow' | 'loop' | 'break' | 'error';
     text: string;
     depth: number;
     stageName?: string;

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

@@ -33,8 +33,9 @@ export declare class FlowRecorderDispatcher implements IControlFlowNarrative {
     onBreak(stageName: string, traversalContext?: TraversalContext): void;
     onError(stageName: string, errorMessage: string, error: unknown, traversalContext?: TraversalContext): void;
     /**
-     * Returns sentences from the first attached recorder that provides them.
-     * By convention, NarrativeFlowRecorder exposes getSentences().
+     * Returns sentences from an attached NarrativeFlowRecorder (looked up by ID).
+     * Callers that need sentences should attach a NarrativeFlowRecorder with id 'narrative'
+     * and retrieve it directly via getRecorderById() if they need typed access.
      */
     getSentences(): string[];
 }

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

@@ -14,7 +14,6 @@ export declare class NarrativeFlowRecorder implements FlowRecorder {
     private sentences;
     /** Parallel array: the actual stage name that produced each sentence. */
     private stageNames;
-    private isFirstStage;
     constructor(id?: string);
     onStageExecuted(event: FlowStageEvent): void;
     onNext(event: FlowNextEvent): void;

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

@@ -1,7 +1,6 @@
 export type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './CombinedNarrativeBuilder.js';
 export type { CombinedNarrativeRecorderOptions } from './CombinedNarrativeRecorder.js';
 export { CombinedNarrativeRecorder } from './CombinedNarrativeRecorder.js';
-export { ControlFlowNarrativeGenerator } from './ControlFlowNarrativeGenerator.js';
 export { NullControlFlowNarrativeGenerator } from './NullControlFlowNarrativeGenerator.js';
 export type { IControlFlowNarrative } from './types.js';
 export { FlowRecorderDispatcher } from './FlowRecorderDispatcher.js';

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

@@ -45,6 +45,11 @@ export interface TraverserOptions<TOut = any, TScope = any> {
     signal?: AbortSignal;
     /** Pre-configured FlowRecorders to attach when narrative is enabled. */
     flowRecorders?: FlowRecorder[];
+    /**
+     * Maximum recursive executeNode depth. Defaults to FlowchartTraverser.MAX_EXECUTE_DEPTH (500).
+     * Override in tests or unusually deep pipelines.
+     */
+    maxDepth?: number;
 }
 export declare class FlowchartTraverser<TOut = any, TScope = any> {
     private readonly root;
@@ -65,6 +70,42 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     private readonly narrativeGenerator;
     private readonly flowRecorderDispatcher;
     private subflowResults;
+    /**
+     * Per-traverser set of lazy subflow IDs that have been resolved by THIS run.
+     * Used instead of writing `node.subflowResolver = undefined` back to the shared
+     * StageNode graph — avoids a race where a concurrent traverser clears the shared
+     * resolver before another traverser has finished using it.
+     */
+    private readonly resolvedLazySubflows;
+    /**
+     * Recursion depth counter for executeNode.
+     * Each recursive executeNode call increments this; decrements on exit (try/finally).
+     * Prevents call-stack overflow on infinite loops or excessively deep stage chains.
+     */
+    private _executeDepth;
+    /**
+     * Per-instance maximum depth (set from TraverserOptions.maxDepth or the class default).
+     */
+    private readonly _maxDepth;
+    /**
+     * Default maximum recursive executeNode depth before an error is thrown.
+     * 500 comfortably covers any realistic pipeline depth (including deeply nested
+     * subflows) while preventing call-stack overflow (~10 000 frames in V8).
+     *
+     * **Note on counting:** the counter increments once per `executeNode` call, not once per
+     * logical user stage. Subflow root entry and subflow continuation after return each cost
+     * one tick. For pipelines with many nested subflows, budget roughly 2 × (avg stages per
+     * subflow) of headroom when computing a custom `maxDepth` via `RunOptions.maxDepth`.
+     *
+     * **Note on loops:** for `loopTo()` pipelines, this depth guard and `ContinuationResolver`'s
+     * iteration limit are independent — the lower one fires first. The default depth guard (500)
+     * fires before the default iteration limit (1000) for loop-heavy pipelines.
+     *
+     * @remarks Not safe for concurrent `.execute()` calls on the same instance — concurrent
+     * executions race on `_executeDepth`. Use a separate `FlowchartTraverser` per concurrent
+     * execution. `FlowChartExecutor.run()` always creates a fresh traverser per call.
+     */
+    static readonly MAX_EXECUTE_DEPTH = 500;
     constructor(opts: TraverserOptions<TOut, TScope>);
     private createDeps;
     execute(): Promise<TraversalResult>;
@@ -76,6 +117,12 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
         subflowResults?: Record<string, unknown> | undefined;
         recorders?: {
             id: string;
+            /**
+             * Per-traverser set of lazy subflow IDs that have been resolved by THIS run.
+             * Used instead of writing `node.subflowResolver = undefined` back to the shared
+             * StageNode graph — avoids a race where a concurrent traverser clears the shared
+             * resolver before another traverser has finished using it.
+             */
             name: string;
             data: unknown;
         }[] | undefined;
@@ -90,6 +137,12 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     getNarrative(): string[];
     /** Returns the FlowRecorderDispatcher, or undefined if narrative is disabled. */
     getFlowRecorderDispatcher(): FlowRecorderDispatcher | undefined;
+    /**
+     * Build an O(1) ID→node map from the root graph.
+     * Used by NodeResolver to avoid repeated DFS on every loopTo() call.
+     * Depth-guarded at MAX_EXECUTE_DEPTH to prevent infinite recursion on cyclic graphs.
+     */
+    private buildNodeIdMap;
     private getStageFn;
     private executeStage;
     /**

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

@@ -112,7 +112,7 @@ export interface HandlerDeps<TOut = any, TScope = any> {
     stageMap: Map<string, StageFunction<TOut, TScope>>;
     root: StageNode<TOut, TScope>;
     executionRuntime: IExecutionRuntime;
-    ScopeFactory: ScopeFactory<TScope>;
+    scopeFactory: ScopeFactory<TScope>;
     subflows?: Record<string, {
         root: StageNode<TOut, TScope>;
     }>;
@@ -144,10 +144,17 @@ export interface RunOptions {
      * Accessible via `scope.getEnv()`. Inherited by subflows automatically.
      */
     env?: ExecutionEnv;
+    /**
+     * Override the maximum recursive `executeNode` depth for this run.
+     * Defaults to `FlowchartTraverser.MAX_EXECUTE_DEPTH` (500).
+     * Useful when deeply nested subflows or long chains need more headroom.
+     * Must be >= 1.
+     */
+    maxDepth?: number;
 }
 export type { FlowControlType, FlowMessage };
 export interface RuntimeStructureMetadata {
-    type: 'stage' | 'decider' | 'fork' | 'streaming';
+    type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow';
     subflowId?: string;
     isSubflowRoot?: boolean;
     subflowName?: string;
@@ -200,7 +207,7 @@ export type TraversalResult = BranchResults | string | Error;
 export interface SerializedPipelineNode {
     name: string;
     id?: string;
-    type?: 'stage' | 'decider' | 'fork' | 'streaming' | 'loop' | 'user' | 'tool' | 'function' | 'sequence';
+    type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop' | 'user' | 'tool' | 'function' | 'sequence';
     description?: string;
     children?: SerializedPipelineNode[];
     next?: SerializedPipelineNode;

package/dist/types/lib/memory/StageContext.d.ts

@@ -53,11 +53,8 @@ export declare class StageContext {
     appendToArray(path: string[], key: string, items: unknown[], description?: string): void;
     mergeObject(path: string[], key: string, obj: Record<string, unknown>, description?: string): void;
     getValue(path: string[], key?: string, description?: string): any;
-    get(path: string[], key?: string): any;
     getRoot(key: string): any;
     getGlobal(key: string): any;
-    getFromRoot(key: string): any;
-    getFromGlobalContext(key: string): any;
     getScope(): Record<string, unknown>;
     getRunId(): string;
     commit(): void;

package/dist/types/lib/memory/pathOps.d.ts

@@ -1,10 +1,34 @@
 /**
  * pathOps.ts — Native nested-path helpers (replaces lodash.get/set/has/mergewith)
  *
- * All functions guard against prototype-pollution attacks.
+ * Security contract: all functions guard against prototype-pollution and
+ * prototype-chain-read attacks. The DENIED set blocks the three canonical
+ * pollution vectors (__proto__, constructor, prototype) on every function.
+ *
+ * Intentional asymmetry:
+ *   - nativeSet  — DENIED check only at each segment. No hasOwnProperty
+ *     check is needed because writing always creates an OWN property on `curr`,
+ *     which cannot pollute the prototype chain.
+ *   - nativeGet / nativeHas — DENIED check + hasOwnProperty at every step.
+ *     Reads follow the prototype chain by default (bracket notation), so the
+ *     hasOwnProperty guard is required to prevent leaking inherited values
+ *     (e.g. Object.prototype, Object constructor, toString).
+ *   - mergeContextWins — DENIED check only; Object.keys() is own-enumerable-only
+ *     by spec so prototype keys never appear in the iteration.
+ *
+ * Do NOT "fix" the nativeSet asymmetry by adding hasOwnProperty — it is
+ * intentional and would break path creation for new intermediate nodes.
+ *
  * Paths may be dot-notation strings or pre-split (string|number)[] arrays.
  */
-/** Get the value at `path` in `obj`, returning `defaultValue` if absent. */
+/**
+ * Get the value at `path` in `obj`, returning `defaultValue` if absent.
+ *
+ * Security: each path segment is checked against the DENIED list and requires
+ * an own property at every step, preventing prototype-chain reads.
+ * e.g. nativeGet({}, '__proto__') and nativeGet({}, 'constructor') both return
+ * `defaultValue` instead of leaking Object.prototype / the Object constructor.
+ */
 export declare function nativeGet(obj: any, path: string | (string | number)[], defaultValue?: any): any;
 /** Mutate `obj`, setting `value` at `path` (creates intermediate objects). Returns `obj`. */
 export declare function nativeSet(obj: any, path: string | (string | number)[], value: any): any;

package/dist/types/lib/memory/utils.d.ts

@@ -31,9 +31,18 @@ export declare function setNestedValue<T>(obj: NestedObject, runId: string, _pat
 export declare function updateNestedValue<T>(obj: any, runId: string | undefined, _path: (string | number)[], field: string | number, value: T, defaultValues?: unknown): any;
 /**
  * In-place value update with merge semantics.
- * - Arrays: concatenate
- * - Objects: shallow merge (spread)
+ * - Arrays (non-empty): concatenate onto existing
+ * - Arrays (empty):     direct replace — writing `[]` clears the field
+ * - Objects (non-empty): shallow merge (spread)
+ * - Objects (empty):    direct replace — writing `{}` clears the field
  * - Primitives: direct assignment
+ *
+ * Note on empty arrays: both `value && Array.isArray(value)` and
+ * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in
+ * JavaScript, so the `&&` guard was never the issue. The actual bug was the
+ * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`
+ * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.
+ * The fix is the explicit `value.length === 0` early-return branch.
  */
 export declare function updateValue(object: any, key: string | number, value: any): void;
 /**
@@ -50,7 +59,11 @@ export declare function redactPatch(patch: MemoryPatch, redactedSet: Set<string>
 export declare function normalisePath(path: (string | number)[]): string;
 /**
  * Deep union merge helper.
- * - Arrays: union without duplicates (encounter order preserved)
+ * - Arrays (non-empty): union without duplicates (encounter order preserved)
+ * - Arrays (empty):     replace — src `[]` clears the destination array.
+ *   Rationale: writing `scope.tags = []` means "clear tags", not "append nothing".
+ *   Without this rule, an empty-array write silently becomes a no-op which is
+ *   impossible to distinguish from a bug.
  * - Objects: recursive merge
  * - Primitives: source wins
  */

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

@@ -1,11 +1,20 @@
 /**
  * FlowChartExecutor — Public API for executing a compiled FlowChart.
  *
- * Wraps FlowchartTraverser. Pairs with FlowChartBuilder:
+ * Wraps FlowchartTraverser. Build a chart with flowChart() and pass the result here:
+ *
  *   const chart = flowChart('entry', entryFn).addFunction('process', processFn).build();
- *   const executor = new FlowChartExecutor(chart);          // uses default ScopeFacade
- *   const executor = new FlowChartExecutor(chart, myFactory); // custom scope factory
- *   const result = await executor.run();
+ *
+ *   // No-options form (uses auto-detected TypedScope factory from the chart):
+ *   const executor = new FlowChartExecutor(chart);
+ *
+ *   // Options-object form (preferred when you need to customize behavior):
+ *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory, enrichSnapshots: true });
+ *
+ *   // 2-param form (accepts a ScopeFactory directly, for backward compatibility):
+ *   const executor = new FlowChartExecutor(chart, myFactory);
+ *
+ *   const result = await executor.run({ input: data, env: { traceId: 'req-123' } });
  */
 import type { CombinedNarrativeEntry } from '../engine/narrative/CombinedNarrativeBuilder.js';
 import type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';
@@ -14,6 +23,54 @@ import { type ExtractorError, type FlowChart, type RunOptions, type ScopeFactory
 import type { ScopeProtectionMode } from '../scope/protection/types.js';
 import type { Recorder, RedactionPolicy, RedactionReport } from '../scope/types.js';
 import { type RuntimeSnapshot } from './ExecutionRuntime.js';
+/**
+ * Options object for `FlowChartExecutor` — preferred over positional params.
+ *
+ * ```typescript
+ * const ex = new FlowChartExecutor(chart, {
+ *   scopeFactory: myFactory,
+ *   enrichSnapshots: true,
+ * });
+ * ```
+ *
+ * **Sync note for maintainers:** Every field added here must also appear in the
+ * `flowChartArgs` private field type and in the constructor's options-resolution
+ * block (the `else if` branch that reads from `opts`). Missing any one of the
+ * three causes silent omission — the option is accepted but never applied.
+ *
+ * **TScope inference note:** When using the options-object form with a custom scope,
+ * TypeScript cannot infer `TScope` through the options object. Pass the type
+ * explicitly: `new FlowChartExecutor<TOut, MyScope>(chart, { scopeFactory })`.
+ */
+export interface FlowChartExecutorOptions<TScope = any> {
+    /** Custom scope factory. Defaults to TypedScope or ScopeFacade auto-detection. */
+    scopeFactory?: ScopeFactory<TScope>;
+    /** Whether to enrich snapshots with scope state (enables `getSnapshot()`). */
+    enrichSnapshots?: boolean;
+    /**
+     * Default values pre-populated into the shared context before **each** stage
+     * (re-applied every stage, acting as baseline defaults).
+     */
+    defaultValuesForContext?: unknown;
+    /**
+     * Initial context values merged into the shared context **once** at startup
+     * (applied before the first stage, not repeated on subsequent stages).
+     * Distinct from `defaultValuesForContext`, which is re-applied every stage.
+     */
+    initialContext?: unknown;
+    /** Read-only input accessible via `scope.getArgs()` — never tracked or written. */
+    readOnlyContext?: unknown;
+    /**
+     * Custom error classifier for throttling detection. Return `true` if the
+     * error represents a rate-limit or backpressure condition (the executor will
+     * treat it differently from hard failures). Defaults to no throttling classification.
+     */
+    throttlingErrorChecker?: (error: unknown) => boolean;
+    /** Handlers for streaming stage lifecycle events (see `addStreamingFunction`). */
+    streamHandlers?: StreamHandlers;
+    /** Scope protection mode for TypedScope direct-assignment detection. */
+    scopeProtectionMode?: ScopeProtectionMode;
+}
 export declare class FlowChartExecutor<TOut = any, TScope = any> {
     private traverser;
     private narrativeEnabled;
@@ -24,7 +81,23 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
     private sharedRedactedKeys;
     private sharedRedactedFieldsByKey;
     private readonly flowChartArgs;
-    constructor(flowChart: FlowChart<TOut, TScope>, scopeFactory?: ScopeFactory<TScope>, defaultValuesForContext?: unknown, initialContext?: unknown, readOnlyContext?: unknown, throttlingErrorChecker?: (error: unknown) => boolean, streamHandlers?: StreamHandlers, scopeProtectionMode?: ScopeProtectionMode, enrichSnapshots?: boolean);
+    /**
+     * Create a FlowChartExecutor.
+     *
+     * **Options object form** (preferred):
+     * ```typescript
+     * new FlowChartExecutor(chart, { scopeFactory, enrichSnapshots: true })
+     * ```
+     *
+     * **2-param form** (also supported):
+     * ```typescript
+     * new FlowChartExecutor(chart, scopeFactory)
+     * ```
+     *
+     * @param flowChart - The compiled FlowChart returned by `flowChart(...).build()`
+     * @param factoryOrOptions - A `ScopeFactory<TScope>` OR a `FlowChartExecutorOptions<TScope>` options object.
+     */
+    constructor(flowChart: FlowChart<TOut, TScope>, factoryOrOptions?: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope>);
     private createTraverser;
     enableNarrative(): void;
     /**
@@ -100,8 +173,6 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
     /** @internal */
     getExtractedResults<TResult = unknown>(): Map<string, TResult>;
     /** @internal */
-    getEnrichedResults<TResult = unknown>(): Map<string, TResult>;
-    /** @internal */
     getExtractorErrors(): ExtractorError[];
     /**
      * Returns the subflow manifest from an attached ManifestFlowRecorder.

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

@@ -47,6 +47,8 @@ export interface RunnableFlowChart<TOut = any, TScope = any> extends FlowChart<T
     toOpenAPI(options?: ChartOpenAPIOptions): object;
     /** Generate MCP tool description from chart metadata. Cached. */
     toMCPTool(): MCPToolDescription;
+    /** Generate a Mermaid flowchart diagram string from the chart's node graph. */
+    toMermaid(): string;
 }
 /**
  * Enrich a FlowChart with run + describe methods.

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

@@ -1,6 +1,7 @@
 export type { ComposableRunner } from './ComposableRunner.js';
 export type { NarrativeEntry, RecorderSnapshot, RuntimeSnapshot } from './ExecutionRuntime.js';
 export { ExecutionRuntime } from './ExecutionRuntime.js';
+export type { FlowChartExecutorOptions } from './FlowChartExecutor.js';
 export { FlowChartExecutor } from './FlowChartExecutor.js';
 export type { SubtreeSnapshot } from './getSubtreeSnapshot.js';
 export { getSubtreeSnapshot, listSubflowPaths } from './getSubtreeSnapshot.js';

package/dist/types/lib/scope/ScopeFacade.d.ts

@@ -111,8 +111,25 @@ export declare class ScopeFacade {
     getPipelineId(): string;
     /** Checks if a key is redacted (explicit _redactedKeys set). */
     private _isKeyRedacted;
-    /** Checks if a key should be auto-redacted by the policy (exact keys + patterns). */
+    /**
+     * Checks if a key should be auto-redacted by the policy (exact keys + patterns).
+     *
+     * ReDoS guard: pattern testing is capped at MAX_PATTERN_KEY_LEN characters.
+     * Scope state keys are always short identifiers; any key exceeding the cap
+     * is almost certainly not a legitimate scope key, so skipping pattern matching
+     * for it does not risk leaking PII. Exact-key matching (Array.includes) is
+     * still applied regardless of length and is not vulnerable to ReDoS.
+     */
     private _isPolicyRedacted;
+    /**
+     * Maximum key length (characters) that will be tested against regex redaction
+     * patterns. Keys longer than this are skipped for pattern matching to prevent
+     * ReDoS: a pathological regex tested against an unboundedly long key string
+     * can cause catastrophic backtracking.
+     *
+     * 256 characters comfortably exceeds any realistic scope-state key name.
+     */
+    private static readonly _MAX_PATTERN_KEY_LEN;
     /**
      * Returns a deep-cloned copy with specified fields replaced by '[REDACTED]'.
      * Supports dot-notation paths (e.g. 'address.zip') for nested objects.

package/dist/types/lib/scope/index.d.ts

@@ -10,7 +10,6 @@ export type { DebugEntry, DebugRecorderOptions, DebugVerbosity } from './recorde
 export { DebugRecorder } from './recorders/DebugRecorder.js';
 export type { AggregatedMetrics, StageMetrics } from './recorders/MetricRecorder.js';
 export { MetricRecorder } from './recorders/MetricRecorder.js';
-export type { NarrativeDetail, NarrativeOperation, NarrativeRecorderOptions, StageNarrativeData, } from './recorders/NarrativeRecorder.js';
 export type { ScopeProtectionMode, ScopeProtectionOptions } from './protection/index.js';
 export { createErrorMessage, createProtectedScope } from './protection/index.js';
 export type { ProviderResolver, ResolveOptions, ScopeFactory, ScopeProvider, StageContextLike, StrictMode, } from './providers/index.js';

package/dist/types/lib/scope/providers/types.d.ts

@@ -11,7 +11,7 @@ export interface StageContextLike {
     updateObject(path: string[], key: string, value: unknown, description?: string): void;
     addLog?(key: string, val: unknown): void;
     addError?(key: string, val: unknown): void;
-    getFromGlobalContext?(key: string): unknown;
+    getGlobal?(key: string): unknown;
     setRoot?(key: string, value: unknown): void;
     setGlobal?(key: string, value: unknown, description?: string): void;
     pipelineId?: string;

package/dist/types/lib/scope/recorders/index.d.ts

@@ -3,4 +3,3 @@ export type { DebugEntry, DebugRecorderOptions, DebugVerbosity } from './DebugRe
 export { DebugRecorder } from './DebugRecorder.js';
 export type { AggregatedMetrics, StageMetrics } from './MetricRecorder.js';
 export { MetricRecorder } from './MetricRecorder.js';
-export type { NarrativeDetail, NarrativeOperation, NarrativeRecorderOptions, StageNarrativeData, } from './NarrativeRecorder.js';

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

@@ -47,7 +47,13 @@ export interface StageEvent extends RecorderContext {
 export interface RedactionPolicy {
     /** Exact key names to always redact (e.g. ['ssn', 'creditCard']). */
     keys?: string[];
-    /** Regex patterns — any key matching a pattern is auto-redacted. */
+    /**
+     * Regex patterns — any key matching a pattern is auto-redacted.
+     *
+     * Pattern matching is skipped for keys that exceed an internal length cap
+     * (designed to prevent ReDoS on pathological patterns). For very long key
+     * names, use `keys` (exact match) instead of patterns.
+     */
     patterns?: RegExp[];
     /** Field-level redaction within objects — key → array of fields to scrub.
      *  Supports dot-notation for nested paths (e.g. 'address.zip'). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "3.0.21",
+  "version": "4.0.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",

package/dist/esm/lib/engine/narrative/ControlFlowNarrativeGenerator.js

@@ -1,110 +0,0 @@
-/**
- * ControlFlowNarrativeGenerator — Active implementation of IControlFlowNarrative.
- *
- * Converts traversal events into plain-English sentences at traversal time.
- * Produces a human-readable story as a first-class output, enabling any consumer
- * (cheaper LLM, follow-up agent, logging system) to understand what happened
- * without parsing technical structures.
- *
- * This is the FLOW narrative — it captures control flow decisions.
- * The DATA narrative comes from scope/recorders/NarrativeRecorder.
- * CombinedNarrativeBuilder merges both into one story.
- */
-export class ControlFlowNarrativeGenerator {
-    constructor() {
-        this.sentences = [];
-        this.isFirstStage = true;
-    }
-    onStageExecuted(stageName, description) {
-        if (this.isFirstStage) {
-            if (description) {
-                this.sentences.push(`The process began: ${description}.`);
-            }
-            else {
-                this.sentences.push(`The process began with ${stageName}.`);
-            }
-            this.isFirstStage = false;
-        }
-    }
-    onNext(fromStage, toStage, description) {
-        if (description) {
-            this.sentences.push(`Next step: ${description}.`);
-        }
-        else {
-            this.sentences.push(`Next, it moved on to ${toStage}.`);
-        }
-    }
-    onDecision(deciderName, chosenBranch, rationale, deciderDescription, _traversalContext, evidence) {
-        const branchName = chosenBranch;
-        if (evidence) {
-            const matchedRule = evidence.rules.find((r) => r.matched);
-            if (matchedRule) {
-                const label = matchedRule.label ? ` "${matchedRule.label}"` : '';
-                if (matchedRule.type === 'filter') {
-                    const parts = matchedRule.conditions.map((c) => `${c.key} ${c.actualSummary} ${c.op} ${JSON.stringify(c.threshold)} ${c.result ? '\u2713' : '\u2717'}`);
-                    this.sentences.push(`It evaluated${label}: ${parts.join(', ')}, and chose ${branchName}.`);
-                }
-                else {
-                    const parts = matchedRule.inputs.map((i) => `${i.key}=${i.valueSummary}`);
-                    this.sentences.push(`It examined${label}: ${parts.join(', ')}, and chose ${branchName}.`);
-                }
-            }
-            else {
-                this.sentences.push(`No rules matched, fell back to default: ${branchName}.`);
-            }
-        }
-        else if (deciderDescription && rationale) {
-            this.sentences.push(`It ${deciderDescription}: ${rationale}, so it chose ${branchName}.`);
-        }
-        else if (deciderDescription) {
-            this.sentences.push(`It ${deciderDescription} and chose ${branchName}.`);
-        }
-        else if (rationale) {
-            this.sentences.push(`A decision was made: ${rationale}, so the path taken was ${branchName}.`);
-        }
-        else {
-            this.sentences.push(`A decision was made, and the path taken was ${branchName}.`);
-        }
-    }
-    onFork(parentStage, childNames) {
-        const names = childNames.join(', ');
-        this.sentences.push(`Forking into ${childNames.length} parallel paths: ${names}.`);
-    }
-    onSelected(parentStage, selectedNames, totalCount) {
-        const names = selectedNames.join(', ');
-        this.sentences.push(`${selectedNames.length} of ${totalCount} paths were selected: ${names}.`);
-    }
-    onSubflowEntry(subflowName, _subflowId, description) {
-        if (description) {
-            this.sentences.push(`Entering the ${subflowName} subflow: ${description}.`);
-        }
-        else {
-            this.sentences.push(`Entering the ${subflowName} subflow.`);
-        }
-    }
-    onSubflowExit(subflowName, _subflowId) {
-        this.sentences.push(`Exiting the ${subflowName} subflow.`);
-    }
-    onSubflowRegistered(_subflowId, _name, _description, _specStructure) {
-        // No narrative output for registration events
-    }
-    onLoop(targetStage, iteration, description) {
-        if (description) {
-            this.sentences.push(`On pass ${iteration}: ${description} again.`);
-        }
-        else {
-            this.sentences.push(`On pass ${iteration} through ${targetStage}.`);
-        }
-    }
-    onBreak(stageName) {
-        this.sentences.push(`Execution stopped at ${stageName}.`);
-    }
-    onError(stageName, errorMessage, _error) {
-        this.sentences.push(`An error occurred at ${stageName}: ${errorMessage}.`);
-    }
-    /** Returns a defensive copy of accumulated sentences. */
-    getSentences() {
-        return [...this.sentences];
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ControlFlowNarrativeGenerator.js","sourceRoot":"","sources":["../../../../../src/lib/engine/narrative/ControlFlowNarrativeGenerator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ControlFlowNarrativeGenerator — Active implementation of IControlFlowNarrative.\n *\n * Converts traversal events into plain-English sentences at traversal time.\n * Produces a human-readable story as a first-class output, enabling any consumer\n * (cheaper LLM, follow-up agent, logging system) to understand what happened\n * without parsing technical structures.\n *\n * This is the FLOW narrative — it captures control flow decisions.\n * The DATA narrative comes from scope/recorders/NarrativeRecorder.\n * CombinedNarrativeBuilder merges both into one story.\n */\n\nimport type { DecisionEvidence } from '../../decide/types.js';\nimport type { IControlFlowNarrative } from './types.js';\n\nexport class ControlFlowNarrativeGenerator implements IControlFlowNarrative {\n  private sentences: string[] = [];\n  private isFirstStage = true;\n\n  onStageExecuted(stageName: string, description?: string): void {\n    if (this.isFirstStage) {\n      if (description) {\n        this.sentences.push(`The process began: ${description}.`);\n      } else {\n        this.sentences.push(`The process began with ${stageName}.`);\n      }\n      this.isFirstStage = false;\n    }\n  }\n\n  onNext(fromStage: string, toStage: string, description?: string): void {\n    if (description) {\n      this.sentences.push(`Next step: ${description}.`);\n    } else {\n      this.sentences.push(`Next, it moved on to ${toStage}.`);\n    }\n  }\n\n  onDecision(\n    deciderName: string,\n    chosenBranch: string,\n    rationale?: string,\n    deciderDescription?: string,\n    _traversalContext?: unknown,\n    evidence?: DecisionEvidence,\n  ): void {\n    const branchName = chosenBranch;\n    if (evidence) {\n      const matchedRule = evidence.rules.find((r) => r.matched);\n      if (matchedRule) {\n        const label = matchedRule.label ? ` \"${matchedRule.label}\"` : '';\n        if (matchedRule.type === 'filter') {\n          const parts = matchedRule.conditions.map(\n            (c) =>\n              `${c.key} ${c.actualSummary} ${c.op} ${JSON.stringify(c.threshold)} ${c.result ? '\\u2713' : '\\u2717'}`,\n          );\n          this.sentences.push(`It evaluated${label}: ${parts.join(', ')}, and chose ${branchName}.`);\n        } else {\n          const parts = matchedRule.inputs.map((i) => `${i.key}=${i.valueSummary}`);\n          this.sentences.push(`It examined${label}: ${parts.join(', ')}, and chose ${branchName}.`);\n        }\n      } else {\n        this.sentences.push(`No rules matched, fell back to default: ${branchName}.`);\n      }\n    } else if (deciderDescription && rationale) {\n      this.sentences.push(`It ${deciderDescription}: ${rationale}, so it chose ${branchName}.`);\n    } else if (deciderDescription) {\n      this.sentences.push(`It ${deciderDescription} and chose ${branchName}.`);\n    } else if (rationale) {\n      this.sentences.push(`A decision was made: ${rationale}, so the path taken was ${branchName}.`);\n    } else {\n      this.sentences.push(`A decision was made, and the path taken was ${branchName}.`);\n    }\n  }\n\n  onFork(parentStage: string, childNames: string[]): void {\n    const names = childNames.join(', ');\n    this.sentences.push(`Forking into ${childNames.length} parallel paths: ${names}.`);\n  }\n\n  onSelected(parentStage: string, selectedNames: string[], totalCount: number): void {\n    const names = selectedNames.join(', ');\n    this.sentences.push(`${selectedNames.length} of ${totalCount} paths were selected: ${names}.`);\n  }\n\n  onSubflowEntry(subflowName: string, _subflowId?: string, description?: string): void {\n    if (description) {\n      this.sentences.push(`Entering the ${subflowName} subflow: ${description}.`);\n    } else {\n      this.sentences.push(`Entering the ${subflowName} subflow.`);\n    }\n  }\n\n  onSubflowExit(subflowName: string, _subflowId?: string): void {\n    this.sentences.push(`Exiting the ${subflowName} subflow.`);\n  }\n\n  onSubflowRegistered(_subflowId: string, _name: string, _description?: string, _specStructure?: unknown): void {\n    // No narrative output for registration events\n  }\n\n  onLoop(targetStage: string, iteration: number, description?: string): void {\n    if (description) {\n      this.sentences.push(`On pass ${iteration}: ${description} again.`);\n    } else {\n      this.sentences.push(`On pass ${iteration} through ${targetStage}.`);\n    }\n  }\n\n  onBreak(stageName: string): void {\n    this.sentences.push(`Execution stopped at ${stageName}.`);\n  }\n\n  onError(stageName: string, errorMessage: string, _error: unknown): void {\n    this.sentences.push(`An error occurred at ${stageName}: ${errorMessage}.`);\n  }\n\n  /** Returns a defensive copy of accumulated sentences. */\n  getSentences(): string[] {\n    return [...this.sentences];\n  }\n}\n"]}