footprintjs 3.0.21 → 3.1.0

package/dist/lib/scope/providers/types.js

@@ -6,4 +6,4 @@
  * StageContextLike is the minimal surface from StageContext to avoid tight coupling.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/scope/types.js

@@ -7,4 +7,4 @@
  * attached to Scope instances to observe read/write/commit operations.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/lib/builder/typedFlowChart.d.ts

@@ -26,9 +26,20 @@ export declare function createTypedScopeFactory<T extends object>(): ScopeFactor
 /**
  * Convenience builder for typed pipelines.
  *
- * Usage:
- *   const chart = typedFlowChart<LoanState>('Intake', intakeFn, 'intake')
- *     .addFunction('Process', processFn, 'process')
- *     .build();
+ * @deprecated Use {@link flowChart} instead. `flowChart<T>(name, fn, id)` is identical
+ * to `typedFlowChart<T>(name, fn, id)` and auto-embeds the TypedScope factory at build time.
+ * `typedFlowChart` will be removed in a future major version.
+ * No changes to executor construction are required — `build()` now embeds the scope factory automatically.
+ *
+ * Migration:
+ * ```typescript
+ * // Before:
+ * import { typedFlowChart } from 'footprintjs/advanced';
+ * const chart = typedFlowChart<LoanState>('Intake', fn, 'intake').build();
+ *
+ * // After:
+ * import { flowChart } from 'footprintjs';
+ * const chart = flowChart<LoanState>('Intake', fn, 'intake').build();
+ * ```
  */
 export declare function typedFlowChart<T extends object>(name: string, fn: TypedStageFunction<T>, id: string, buildTimeExtractor?: BuildTimeExtractor<any>, description?: string): FlowChartBuilder<any, TypedScope<T>>;

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

@@ -19,7 +19,7 @@ export type { ScopeProtectionMode };
 export interface SerializedPipelineStructure {
     name: string;
     id?: string;
-    type: 'stage' | 'decider' | 'fork' | 'streaming';
+    type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming';
     /** Semantic icon hint for visualization (e.g., "llm", "tool", "rag", "agent", "start") */
     icon?: string;
     description?: string;
@@ -36,6 +36,13 @@ export interface SerializedPipelineStructure {
     isSubflowRoot?: boolean;
     subflowId?: string;
     subflowName?: string;
+    /**
+     * Nested pipeline structure for a subflow node.
+     * WARNING: Any future walker that traverses this field recursively must apply its own
+     * depth guard (see MAX_WALK_DEPTH in contract/openapi.ts). The current `buildDescription`
+     * walk in openapi.ts does NOT traverse subflowStructure — if it ever does, the depth
+     * guard must cover both the `next` chain and this nested structure.
+     */
     subflowStructure?: SerializedPipelineStructure;
     iterationCount?: number;
     /** True when this subflow uses lazy resolution (deferred until execution). */
@@ -44,6 +51,8 @@ export interface SerializedPipelineStructure {
 export interface FlowChartSpec {
     name: string;
     id?: string;
+    /** Node type — matches `SerializedPipelineStructure.type` for visualization alignment. */
+    type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming';
     /** Semantic icon hint for visualization (e.g., "llm", "tool", "rag", "agent", "start") */
     icon?: string;
     description?: string;

package/dist/types/lib/contract/openapi.d.ts

@@ -2,11 +2,17 @@
  * contract/openapi.ts — OpenAPI 3.1 spec generator.
  *
  * Generates an OpenAPI spec from a FlowChartContract by combining:
- * - chart.description → operation description
- * - chart.stageDescriptions → step-by-step detail
+ * - chart.description → operation description (built incrementally during FlowChartBuilder.build())
  * - inputSchema → requestBody
  * - outputSchema → response
- * - chart.buildTimeStructure → operation metadata (branches, forks, etc.)
+ *
+ * chart.description is assembled by FlowChartBuilder as each stage is added —
+ * no post-processing walk of buildTimeStructure is needed or performed here.
  */
 import type { FlowChartContract, OpenAPIOptions, OpenAPISpec } from './types.js';
+/**
+ * Generates an OpenAPI 3.1 spec from a FlowChartContract.
+ * Uses `chart.description` which FlowChartBuilder assembles at build time —
+ * no post-processing walk of buildTimeStructure is performed here.
+ */
 export declare function generateOpenAPI(contract: FlowChartContract, options?: OpenAPIOptions): OpenAPISpec;

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

@@ -36,7 +36,18 @@ export interface FlowChartContractOptions<_TInput = unknown, TOutput = unknown>
     outputMapper?: (finalScope: Record<string, unknown>) => TOutput;
 }
 export interface FlowChartContract<_TInput = unknown, TOutput = unknown> {
-    /** The compiled flowchart. */
+    /**
+     * Prototype-linked view of the original compiled FlowChart.
+     *
+     * Own properties (inputSchema, outputSchema, outputMapper) are shadowed here
+     * so that the contract's values take precedence over builder-set values.
+     * All other fields (root, stageMap, methods) are inherited via the prototype
+     * chain with zero copying. The original chart is never mutated.
+     *
+     * ⚠️ Do NOT use Object.keys(), spread ({...chart}), or JSON.stringify() on
+     * this object — it will only see own (shadowed) properties. Use named
+     * property access or chart.toSpec() instead.
+     */
     chart: FlowChart;
     /** JSON Schema for the input (normalized from Zod or raw). */
     inputSchema?: JsonSchema;
@@ -44,7 +55,7 @@ export interface FlowChartContract<_TInput = unknown, TOutput = unknown> {
     outputSchema?: JsonSchema;
     /** Maps the final scope state into the response shape. */
     outputMapper?: (finalScope: Record<string, unknown>) => TOutput;
-    /** Auto-generated OpenAPI spec. */
+    /** Auto-generated OpenAPI spec. Description is read from `chart.description` (pre-built at build time). */
     toOpenAPI(options?: OpenAPIOptions): OpenAPISpec;
 }
 export interface OpenAPIOptions {

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

@@ -15,6 +15,11 @@ import type { DecideRule, DecisionResult, SelectionResult } from './types.js';
  * @param scope - TypedScope or ScopeFacade
  * @param rules - Array of DecideRule (function or filter when clauses)
  * @param defaultBranch - Branch ID if no rule matches
+ *
+ * **Error behavior:** If a `when` function throws during evaluation, the rule is
+ * treated as non-matching (`matched: false`) and the error message is captured in
+ * `matchError` on that rule's `RuleEvidence` entry. Execution continues with
+ * subsequent rules; errors do not propagate to the caller.
  */
 export declare function decide<S extends object>(scope: S, rules: DecideRule<S>[], defaultBranch: string): DecisionResult;
 /**
@@ -22,5 +27,10 @@ export declare function decide<S extends object>(scope: S, rules: DecideRule<S>[
  *
  * @param scope - TypedScope or ScopeFacade
  * @param rules - Array of DecideRule (function or filter when clauses)
+ *
+ * **Error behavior:** If a `when` function throws during evaluation, the rule is
+ * treated as non-matching (`matched: false`) and the error message is captured in
+ * `matchError` on that rule's `RuleEvidence` entry. Evaluation continues with
+ * remaining rules; errors do not propagate to the caller.
  */
 export declare function select<S extends object>(scope: S, rules: DecideRule<S>[]): SelectionResult;

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

@@ -53,6 +53,16 @@ export interface FunctionRuleEvidence {
     matched: boolean;
     label?: string;
     inputs: ReadInput[];
+    /**
+     * Error message if the `when` function threw during evaluation.
+     * Present only when an exception occurred; `matched` is `false` in that case.
+     * Surfaces the error for debugging rather than swallowing it silently.
+     *
+     * **Security note:** Error messages from user-provided `when` functions are captured
+     * as-is and are NOT filtered through the redaction policy. Avoid including sensitive
+     * scope values in thrown error messages.
+     */
+    matchError?: string;
 }
 export interface FilterRuleEvidence {
     type: 'filter';
@@ -62,6 +72,16 @@ export interface FilterRuleEvidence {
     matched: boolean;
     label?: string;
     conditions: FilterCondition[];
+    /**
+     * Error message if the filter evaluator threw during evaluation.
+     * Present only when an exception occurred; `matched` is `false` in that case.
+     * Surfaces the error for debugging rather than swallowing it silently.
+     *
+     * **Security note:** Error messages from user-provided `when` functions are captured
+     * as-is and are NOT filtered through the redaction policy. Avoid including sensitive
+     * scope values in thrown error messages.
+     */
+    matchError?: string;
 }
 export type RuleEvidence = FunctionRuleEvidence | FilterRuleEvidence;
 export interface ReadInput {

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';
 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/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;

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

@@ -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';
     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' | 'loop' | 'user' | 'tool' | 'function' | 'sequence';
     description?: string;
     children?: SerializedPipelineNode[];
     next?: SerializedPipelineNode;

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

@@ -53,10 +53,22 @@ 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;
+    /**
+     * @deprecated since v3.1.0 — use {@link getValue} instead. Will be removed in v4.0.0.
+     * This alias exists for backward compatibility only.
+     */
     get(path: string[], key?: string): any;
     getRoot(key: string): any;
     getGlobal(key: string): any;
+    /**
+     * @deprecated since v3.1.0 — use {@link getRoot} instead. Will be removed in v4.0.0.
+     * This alias exists for backward compatibility only.
+     */
     getFromRoot(key: string): any;
+    /**
+     * @deprecated since v3.1.0 — use {@link getGlobal} instead. Will be removed in v4.0.0.
+     * This alias exists for backward compatibility only.
+     */
     getFromGlobalContext(key: string): any;
     getScope(): Record<string, unknown>;
     getRunId(): string;

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

@@ -3,8 +3,14 @@
  *
  * Wraps FlowchartTraverser. Pairs with FlowChartBuilder:
  *   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
+ *
+ *   // Recommended — options object form:
+ *   const executor = new FlowChartExecutor(chart);
+ *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory, enrichSnapshots: true });
+ *
+ *   // Legacy — positional params 3-9 are deprecated; pass an options object instead:
+ *   const executor = new FlowChartExecutor(chart, myFactory); // still supported
+ *
  *   const result = await executor.run();
  */
 import type { CombinedNarrativeEntry } from '../engine/narrative/CombinedNarrativeBuilder.js';
@@ -14,6 +20,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 +78,48 @@ 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.
+     *
+     * **Preferred form** (options object — avoids positional parameter confusion):
+     * ```typescript
+     * new FlowChartExecutor(chart, { scopeFactory, enrichSnapshots: true })
+     * ```
+     *
+     * **Backward-compatible positional form** (params 3–9 deprecated — use options object):
+     * ```typescript
+     * new FlowChartExecutor(chart, scopeFactory)  // fine — 2 params
+     * new FlowChartExecutor(chart, factory, defaultValues, ...)  // deprecated: use options object
+     * ```
+     *
+     * @param flowChart - The compiled FlowChart returned by `flowChart(...).build()`
+     * @param factoryOrOptions - A `ScopeFactory<TScope>` (still supported — NOT deprecated) OR a
+     *   `FlowChartExecutorOptions<TScope>` options object (preferred for 3+ settings).
+     *   Passing `(chart, scopeFactory)` — the 2-param form — is fine and will not be removed.
+     *   Only params 3–9 are deprecated.
+     * @param defaultValuesForContext - @deprecated Pass via `options.defaultValuesForContext` instead.
+     * @param initialContext - @deprecated Pass via `options.initialContext` instead.
+     * @param readOnlyContext - @deprecated Pass via `options.readOnlyContext` instead.
+     * @param throttlingErrorChecker - @deprecated Pass via `options.throttlingErrorChecker` instead.
+     * @param streamHandlers - @deprecated Pass via `options.streamHandlers` instead.
+     * @param scopeProtectionMode - @deprecated Pass via `options.scopeProtectionMode` instead.
+     * @param enrichSnapshots - @deprecated Pass via `options.enrichSnapshots` instead.
+     */
+    constructor(flowChart: FlowChart<TOut, TScope>, factoryOrOptions?: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope>, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    defaultValuesForContext?: unknown, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    initialContext?: unknown, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    readOnlyContext?: unknown, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    throttlingErrorChecker?: (error: unknown) => boolean, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    streamHandlers?: StreamHandlers, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    scopeProtectionMode?: ScopeProtectionMode, 
+    /** @deprecated Use {@link FlowChartExecutorOptions} instead. */
+    enrichSnapshots?: boolean);
     private createTraverser;
     enableNarrative(): void;
     /**

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/providers/types.d.ts

@@ -11,6 +11,12 @@ 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;
+    getGlobal?(key: string): unknown;
+    /**
+     * @deprecated since v3.1.0 — use {@link getGlobal} instead. Will be removed in v4.0.0.
+     * Internal callers no longer invoke this method — implementors of `StageContextLike`
+     * must provide `getGlobal?` (not just `getFromGlobalContext?`) for `getInitialValueFor` to work.
+     */
     getFromGlobalContext?(key: string): unknown;
     setRoot?(key: string, value: unknown): void;
     setGlobal?(key: string, value: unknown, description?: string): void;

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": "3.1.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",