footprintjs 0.2.3 → 0.4.0

package/dist/lib/runner/FlowChartExecutor.js

@@ -17,6 +17,7 @@ const ExecutionRuntime_1 = require("./ExecutionRuntime");
 class FlowChartExecutor {
     constructor(flowChart, scopeFactory, defaultValuesForContext, initialContext, readOnlyContext, throttlingErrorChecker, streamHandlers, scopeProtectionMode, enrichSnapshots) {
         this.narrativeEnabled = false;
+        this.flowRecorders = [];
         this.flowChartArgs = {
             flowChart,
             scopeFactory,
@@ -70,11 +71,30 @@ class FlowChartExecutor {
             buildTimeStructure: fc.buildTimeStructure,
             logger: (_c = fc.logger) !== null && _c !== void 0 ? _c : types_1.defaultLogger,
             signal,
+            flowRecorders: this.flowRecorders.length > 0 ? this.flowRecorders : undefined,
         });
     }
     enableNarrative() {
         this.narrativeEnabled = true;
     }
+    // ─── FlowRecorder Management ───
+    /**
+     * Attach a FlowRecorder to observe control flow events.
+     * Automatically enables narrative if not already enabled.
+     * Must be called before run() — recorders are passed to the traverser at creation time.
+     */
+    attachFlowRecorder(recorder) {
+        this.flowRecorders.push(recorder);
+        this.narrativeEnabled = true;
+    }
+    /** Detach all FlowRecorders with the given ID. */
+    detachFlowRecorder(id) {
+        this.flowRecorders = this.flowRecorders.filter((r) => r.id !== id);
+    }
+    /** Returns a defensive copy of attached FlowRecorders. */
+    getFlowRecorders() {
+        return [...this.flowRecorders];
+    }
     /**
      * Returns the execution narrative.
      *
@@ -159,4 +179,4 @@ class FlowChartExecutor {
     }
 }
 exports.FlowChartExecutor = FlowChartExecutor;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartExecutor.js","sourceRoot":"","sources":["../../../src/lib/runner/FlowChartExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartExecutor — Public API for executing a compiled FlowChart.\n *\n * Wraps FlowchartTraverser. Pairs with FlowChartBuilder:\n *   const chart = flowChart('entry', entryFn).addFunction('process', processFn).build();\n *   const executor = new FlowChartExecutor(chart, scopeFactory);\n *   const result = await executor.run();\n */\n\nimport type { CombinedNarrativeEntry } from '../engine/narrative/CombinedNarrativeBuilder';\nimport { CombinedNarrativeBuilder } from '../engine/narrative/CombinedNarrativeBuilder';\nimport { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser';\nimport {\n  type ExtractorError,\n  type FlowChart,\n  type RunOptions,\n  type ScopeFactory,\n  type SerializedPipelineStructure,\n  type StageNode,\n  type StreamHandlers,\n  type SubflowResult,\n  type TraversalResult,\n  defaultLogger,\n} from '../engine/types';\nimport type { ScopeProtectionMode } from '../scope/protection/types';\nimport { NarrativeRecorder } from '../scope/recorders/NarrativeRecorder';\nimport { ExecutionRuntime } from './ExecutionRuntime';\n\nexport class FlowChartExecutor<TOut = any, TScope = any> {\n  private traverser: FlowchartTraverser<TOut, TScope>;\n  private narrativeEnabled = false;\n  private narrativeRecorder: NarrativeRecorder | undefined;\n\n  private readonly flowChartArgs: {\n    flowChart: FlowChart<TOut, TScope>;\n    scopeFactory: ScopeFactory<TScope>;\n    defaultValuesForContext?: unknown;\n    initialContext?: unknown;\n    readOnlyContext?: unknown;\n    throttlingErrorChecker?: (error: unknown) => boolean;\n    streamHandlers?: StreamHandlers;\n    scopeProtectionMode?: ScopeProtectionMode;\n    enrichSnapshots?: boolean;\n  };\n\n  constructor(\n    flowChart: FlowChart<TOut, TScope>,\n    scopeFactory: ScopeFactory<TScope>,\n    defaultValuesForContext?: unknown,\n    initialContext?: unknown,\n    readOnlyContext?: unknown,\n    throttlingErrorChecker?: (error: unknown) => boolean,\n    streamHandlers?: StreamHandlers,\n    scopeProtectionMode?: ScopeProtectionMode,\n    enrichSnapshots?: boolean,\n  ) {\n    this.flowChartArgs = {\n      flowChart,\n      scopeFactory,\n      defaultValuesForContext,\n      initialContext,\n      readOnlyContext,\n      throttlingErrorChecker,\n      streamHandlers,\n      scopeProtectionMode,\n      enrichSnapshots,\n    };\n    this.traverser = this.createTraverser();\n  }\n\n  private createTraverser(signal?: AbortSignal): FlowchartTraverser<TOut, TScope> {\n    const args = this.flowChartArgs;\n    const fc = args.flowChart;\n    const narrativeFlag = this.narrativeEnabled || (fc.enableNarrative ?? false);\n\n    // When narrative is enabled, create a recorder and wrap the scope factory\n    // to auto-attach it to every scope that supports attachRecorder().\n    let scopeFactory = args.scopeFactory;\n    if (narrativeFlag) {\n      this.narrativeRecorder = new NarrativeRecorder();\n      const recorder = this.narrativeRecorder;\n      const originalFactory = args.scopeFactory;\n      scopeFactory = ((ctx: any, stageName: string, readOnly?: unknown) => {\n        const scope = originalFactory(ctx, stageName, readOnly);\n        if (scope && typeof (scope as any).attachRecorder === 'function') {\n          (scope as any).attachRecorder(recorder);\n        }\n        return scope;\n      }) as ScopeFactory<TScope>;\n    } else {\n      this.narrativeRecorder = undefined;\n    }\n\n    const runtime = new ExecutionRuntime(fc.root.name, args.defaultValuesForContext, args.initialContext);\n\n    return new FlowchartTraverser<TOut, TScope>({\n      root: fc.root,\n      stageMap: fc.stageMap,\n      scopeFactory,\n      executionRuntime: runtime,\n      readOnlyContext: args.readOnlyContext,\n      throttlingErrorChecker: args.throttlingErrorChecker,\n      streamHandlers: args.streamHandlers,\n      extractor: fc.extractor,\n      scopeProtectionMode: args.scopeProtectionMode,\n      subflows: fc.subflows,\n      enrichSnapshots: args.enrichSnapshots ?? fc.enrichSnapshots,\n      narrativeEnabled: narrativeFlag,\n      buildTimeStructure: fc.buildTimeStructure,\n      logger: fc.logger ?? defaultLogger,\n      signal,\n    });\n  }\n\n  enableNarrative(): void {\n    this.narrativeEnabled = true;\n  }\n\n  /**\n   * Returns the execution narrative.\n   *\n   * When using ScopeFacade-based scopes, returns a combined narrative that\n   * interleaves flow events (stages, decisions, forks) with data operations\n   * (reads, writes, updates). For plain scopes without attachRecorder support,\n   * returns flow-only narrative sentences.\n   */\n  getNarrative(): string[] {\n    const flowSentences = this.traverser.getNarrative();\n    if (this.narrativeRecorder && this.narrativeRecorder.getStageData().size > 0) {\n      return new CombinedNarrativeBuilder().build(flowSentences, this.narrativeRecorder);\n    }\n    return flowSentences;\n  }\n\n  /**\n   * Returns structured narrative entries for programmatic consumption.\n   * Each entry has a type (stage, step, condition, fork, etc.), text, and depth.\n   */\n  getNarrativeEntries(): CombinedNarrativeEntry[] {\n    const flowSentences = this.traverser.getNarrative();\n    if (this.narrativeRecorder) {\n      return new CombinedNarrativeBuilder().buildEntries(flowSentences, this.narrativeRecorder);\n    }\n    return flowSentences.map((text) => ({ type: 'stage' as const, text, depth: 0 }));\n  }\n\n  /**\n   * Returns flow-only narrative sentences (without data operations).\n   * Use this when you only want control flow descriptions.\n   */\n  getFlowNarrative(): string[] {\n    return this.traverser.getNarrative();\n  }\n\n  async run(options?: RunOptions): Promise<TraversalResult> {\n    let signal = options?.signal;\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n    // Create an internal AbortController for timeoutMs\n    if (options?.timeoutMs && !signal) {\n      const controller = new AbortController();\n      signal = controller.signal;\n      timeoutId = setTimeout(\n        () => controller.abort(new Error(`Execution timed out after ${options.timeoutMs}ms`)),\n        options.timeoutMs,\n      );\n    }\n\n    this.traverser = this.createTraverser(signal);\n    try {\n      return await this.traverser.execute();\n    } finally {\n      if (timeoutId !== undefined) clearTimeout(timeoutId);\n    }\n  }\n\n  // ─── Introspection ───\n\n  getSnapshot() {\n    return this.traverser.getSnapshot();\n  }\n\n  getRuntime() {\n    return this.traverser.getRuntime();\n  }\n\n  setRootObject(path: string[], key: string, value: unknown): void {\n    this.traverser.setRootObject(path, key, value);\n  }\n\n  getBranchIds() {\n    return this.traverser.getBranchIds();\n  }\n\n  getRuntimeRoot(): StageNode {\n    return this.traverser.getRuntimeRoot();\n  }\n\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.traverser.getRuntimeStructure();\n  }\n\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.traverser.getSubflowResults();\n  }\n\n  getExtractedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.traverser.getExtractedResults<TResult>();\n  }\n\n  getEnrichedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.traverser.getExtractedResults<TResult>();\n  }\n\n  getExtractorErrors(): ExtractorError[] {\n    return this.traverser.getExtractorErrors();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartExecutor.js","sourceRoot":"","sources":["../../../src/lib/runner/FlowChartExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartExecutor — Public API for executing a compiled FlowChart.\n *\n * Wraps FlowchartTraverser. Pairs with FlowChartBuilder:\n *   const chart = flowChart('entry', entryFn).addFunction('process', processFn).build();\n *   const executor = new FlowChartExecutor(chart, scopeFactory);\n *   const result = await executor.run();\n */\n\nimport type { CombinedNarrativeEntry } from '../engine/narrative/CombinedNarrativeBuilder';\nimport { CombinedNarrativeBuilder } from '../engine/narrative/CombinedNarrativeBuilder';\nimport type { FlowRecorder } from '../engine/narrative/types';\nimport { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser';\nimport {\n  type ExtractorError,\n  type FlowChart,\n  type RunOptions,\n  type ScopeFactory,\n  type SerializedPipelineStructure,\n  type StageNode,\n  type StreamHandlers,\n  type SubflowResult,\n  type TraversalResult,\n  defaultLogger,\n} from '../engine/types';\nimport type { ScopeProtectionMode } from '../scope/protection/types';\nimport { NarrativeRecorder } from '../scope/recorders/NarrativeRecorder';\nimport { ExecutionRuntime } from './ExecutionRuntime';\n\nexport class FlowChartExecutor<TOut = any, TScope = any> {\n  private traverser: FlowchartTraverser<TOut, TScope>;\n  private narrativeEnabled = false;\n  private narrativeRecorder: NarrativeRecorder | undefined;\n  private flowRecorders: FlowRecorder[] = [];\n\n  private readonly flowChartArgs: {\n    flowChart: FlowChart<TOut, TScope>;\n    scopeFactory: ScopeFactory<TScope>;\n    defaultValuesForContext?: unknown;\n    initialContext?: unknown;\n    readOnlyContext?: unknown;\n    throttlingErrorChecker?: (error: unknown) => boolean;\n    streamHandlers?: StreamHandlers;\n    scopeProtectionMode?: ScopeProtectionMode;\n    enrichSnapshots?: boolean;\n  };\n\n  constructor(\n    flowChart: FlowChart<TOut, TScope>,\n    scopeFactory: ScopeFactory<TScope>,\n    defaultValuesForContext?: unknown,\n    initialContext?: unknown,\n    readOnlyContext?: unknown,\n    throttlingErrorChecker?: (error: unknown) => boolean,\n    streamHandlers?: StreamHandlers,\n    scopeProtectionMode?: ScopeProtectionMode,\n    enrichSnapshots?: boolean,\n  ) {\n    this.flowChartArgs = {\n      flowChart,\n      scopeFactory,\n      defaultValuesForContext,\n      initialContext,\n      readOnlyContext,\n      throttlingErrorChecker,\n      streamHandlers,\n      scopeProtectionMode,\n      enrichSnapshots,\n    };\n    this.traverser = this.createTraverser();\n  }\n\n  private createTraverser(signal?: AbortSignal): FlowchartTraverser<TOut, TScope> {\n    const args = this.flowChartArgs;\n    const fc = args.flowChart;\n    const narrativeFlag = this.narrativeEnabled || (fc.enableNarrative ?? false);\n\n    // When narrative is enabled, create a recorder and wrap the scope factory\n    // to auto-attach it to every scope that supports attachRecorder().\n    let scopeFactory = args.scopeFactory;\n    if (narrativeFlag) {\n      this.narrativeRecorder = new NarrativeRecorder();\n      const recorder = this.narrativeRecorder;\n      const originalFactory = args.scopeFactory;\n      scopeFactory = ((ctx: any, stageName: string, readOnly?: unknown) => {\n        const scope = originalFactory(ctx, stageName, readOnly);\n        if (scope && typeof (scope as any).attachRecorder === 'function') {\n          (scope as any).attachRecorder(recorder);\n        }\n        return scope;\n      }) as ScopeFactory<TScope>;\n    } else {\n      this.narrativeRecorder = undefined;\n    }\n\n    const runtime = new ExecutionRuntime(fc.root.name, args.defaultValuesForContext, args.initialContext);\n\n    return new FlowchartTraverser<TOut, TScope>({\n      root: fc.root,\n      stageMap: fc.stageMap,\n      scopeFactory,\n      executionRuntime: runtime,\n      readOnlyContext: args.readOnlyContext,\n      throttlingErrorChecker: args.throttlingErrorChecker,\n      streamHandlers: args.streamHandlers,\n      extractor: fc.extractor,\n      scopeProtectionMode: args.scopeProtectionMode,\n      subflows: fc.subflows,\n      enrichSnapshots: args.enrichSnapshots ?? fc.enrichSnapshots,\n      narrativeEnabled: narrativeFlag,\n      buildTimeStructure: fc.buildTimeStructure,\n      logger: fc.logger ?? defaultLogger,\n      signal,\n      flowRecorders: this.flowRecorders.length > 0 ? this.flowRecorders : undefined,\n    });\n  }\n\n  enableNarrative(): void {\n    this.narrativeEnabled = true;\n  }\n\n  // ─── FlowRecorder Management ───\n\n  /**\n   * Attach a FlowRecorder to observe control flow events.\n   * Automatically enables narrative if not already enabled.\n   * Must be called before run() — recorders are passed to the traverser at creation time.\n   */\n  attachFlowRecorder(recorder: FlowRecorder): void {\n    this.flowRecorders.push(recorder);\n    this.narrativeEnabled = true;\n  }\n\n  /** Detach all FlowRecorders with the given ID. */\n  detachFlowRecorder(id: string): void {\n    this.flowRecorders = this.flowRecorders.filter((r) => r.id !== id);\n  }\n\n  /** Returns a defensive copy of attached FlowRecorders. */\n  getFlowRecorders(): FlowRecorder[] {\n    return [...this.flowRecorders];\n  }\n\n  /**\n   * Returns the execution narrative.\n   *\n   * When using ScopeFacade-based scopes, returns a combined narrative that\n   * interleaves flow events (stages, decisions, forks) with data operations\n   * (reads, writes, updates). For plain scopes without attachRecorder support,\n   * returns flow-only narrative sentences.\n   */\n  getNarrative(): string[] {\n    const flowSentences = this.traverser.getNarrative();\n    if (this.narrativeRecorder && this.narrativeRecorder.getStageData().size > 0) {\n      return new CombinedNarrativeBuilder().build(flowSentences, this.narrativeRecorder);\n    }\n    return flowSentences;\n  }\n\n  /**\n   * Returns structured narrative entries for programmatic consumption.\n   * Each entry has a type (stage, step, condition, fork, etc.), text, and depth.\n   */\n  getNarrativeEntries(): CombinedNarrativeEntry[] {\n    const flowSentences = this.traverser.getNarrative();\n    if (this.narrativeRecorder) {\n      return new CombinedNarrativeBuilder().buildEntries(flowSentences, this.narrativeRecorder);\n    }\n    return flowSentences.map((text) => ({ type: 'stage' as const, text, depth: 0 }));\n  }\n\n  /**\n   * Returns flow-only narrative sentences (without data operations).\n   * Use this when you only want control flow descriptions.\n   */\n  getFlowNarrative(): string[] {\n    return this.traverser.getNarrative();\n  }\n\n  async run(options?: RunOptions): Promise<TraversalResult> {\n    let signal = options?.signal;\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n    // Create an internal AbortController for timeoutMs\n    if (options?.timeoutMs && !signal) {\n      const controller = new AbortController();\n      signal = controller.signal;\n      timeoutId = setTimeout(\n        () => controller.abort(new Error(`Execution timed out after ${options.timeoutMs}ms`)),\n        options.timeoutMs,\n      );\n    }\n\n    this.traverser = this.createTraverser(signal);\n    try {\n      return await this.traverser.execute();\n    } finally {\n      if (timeoutId !== undefined) clearTimeout(timeoutId);\n    }\n  }\n\n  // ─── Introspection ───\n\n  getSnapshot() {\n    return this.traverser.getSnapshot();\n  }\n\n  getRuntime() {\n    return this.traverser.getRuntime();\n  }\n\n  setRootObject(path: string[], key: string, value: unknown): void {\n    this.traverser.setRootObject(path, key, value);\n  }\n\n  getBranchIds() {\n    return this.traverser.getBranchIds();\n  }\n\n  getRuntimeRoot(): StageNode {\n    return this.traverser.getRuntimeRoot();\n  }\n\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.traverser.getRuntimeStructure();\n  }\n\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.traverser.getSubflowResults();\n  }\n\n  getExtractedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.traverser.getExtractedResults<TResult>();\n  }\n\n  getEnrichedResults<TResult = unknown>(): Map<string, TResult> {\n    return this.traverser.getExtractedResults<TResult>();\n  }\n\n  getExtractorErrors(): ExtractorError[] {\n    return this.traverser.getExtractorErrors();\n  }\n}\n"]}

package/dist/types/index.d.ts

@@ -19,5 +19,18 @@ export type { CommitEvent, ErrorEvent, ReadEvent, Recorder, WriteEvent } from '.
 export { defineScopeFromZod } from './lib/scope';
 export type { CombinedNarrativeEntry } from './lib/engine';
 export { CombinedNarrativeBuilder } from './lib/engine';
+export type { FlowLoopEvent, FlowRecorder } from './lib/engine';
+export { NarrativeFlowRecorder } from './lib/engine';
+export { AdaptiveNarrativeFlowRecorder } from './lib/engine';
+export { MilestoneNarrativeFlowRecorder } from './lib/engine';
+export { ProgressiveNarrativeFlowRecorder } from './lib/engine';
+export { RLENarrativeFlowRecorder } from './lib/engine';
+export { SeparateNarrativeFlowRecorder } from './lib/engine';
+export { SilentNarrativeFlowRecorder } from './lib/engine';
+export { WindowedNarrativeFlowRecorder } from './lib/engine';
 export type { RunOptions } from './lib/engine';
 export type { ScopeFactory } from './lib/memory';
+export type { FlowChartContract, FlowChartContractOptions, JsonSchema, OpenAPIOptions, OpenAPISpec, } from './lib/contract';
+export { defineContract } from './lib/contract';
+export { normalizeSchema, zodToJsonSchema } from './lib/contract';
+export { generateOpenAPI } from './lib/contract';

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

@@ -77,11 +77,20 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
     private _stepCounter;
     private _stageDescriptions;
     private _stageStepMap;
+    private _inputSchema?;
+    private _outputSchema?;
+    private _outputMapper?;
     constructor(buildTimeExtractor?: BuildTimeExtractor<any>);
     private _appendDescriptionLine;
     private _appendSubflowDescription;
     setEnableNarrative(): this;
     setLogger(logger: ILogger): this;
+    /** Declare the input schema (readOnlyContext shape). Accepts Zod schema or JSON Schema. */
+    setInputSchema(schema: unknown): this;
+    /** Declare the output schema (response shape). Accepts Zod schema or JSON Schema. */
+    setOutputSchema(schema: unknown): this;
+    /** Set the output mapper that extracts the response from final scope. */
+    setOutputMapper(mapper: (finalScope: Record<string, unknown>) => unknown): this;
     start(name: string, fn?: PipelineStageFunction<TOut, TScope>, id?: string, description?: string): this;
     addFunction(name: string, fn?: PipelineStageFunction<TOut, TScope>, id?: string, description?: string): this;
     addStreamingFunction(name: string, streamId?: string, fn?: PipelineStageFunction<TOut, TScope>, id?: string, description?: string): this;

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

@@ -126,6 +126,12 @@ export type FlowChart<TOut = any, TScope = any> = {
     logger?: ILogger;
     description: string;
     stageDescriptions: Map<string, string>;
+    /** Input schema (Zod or JSON Schema) — declared via setInputSchema(). */
+    inputSchema?: unknown;
+    /** Output schema (Zod or JSON Schema) — declared via setOutputSchema(). */
+    outputSchema?: unknown;
+    /** Output mapper — extracts response from final scope. */
+    outputMapper?: (finalScope: Record<string, unknown>) => unknown;
 };
 export type SimplifiedParallelSpec<TOut = any, TScope = any> = {
     id: string;

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

@@ -0,0 +1,18 @@
+/**
+ * contract/defineContract.ts — Factory for creating a FlowChartContract.
+ *
+ * Wraps a compiled FlowChart with I/O schemas and an output mapper,
+ * using the same pattern as SubflowMountOptions (inputMapper/outputMapper).
+ *
+ * Usage:
+ *   const contract = defineContract(chart, {
+ *     inputSchema: z.object({ name: z.string() }),
+ *     outputSchema: z.object({ greeting: z.string() }),
+ *     outputMapper: (scope) => ({ greeting: scope.message as string }),
+ *   });
+ *
+ *   const openapi = contract.toOpenAPI();
+ */
+import type { FlowChart } from '../builder/types';
+import type { FlowChartContract, FlowChartContractOptions } from './types';
+export declare function defineContract<TInput = unknown, TOutput = unknown>(chart: FlowChart, options: FlowChartContractOptions<TInput, TOutput>): FlowChartContract<TInput, TOutput>;

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

@@ -0,0 +1,14 @@
+/**
+ * contract/ — FlowChart I/O contract and OpenAPI generation layer.
+ *
+ * Standalone library: wraps a compiled FlowChart with input/output schemas
+ * and generates OpenAPI 3.1 specs. Uses the same inputMapper/outputMapper
+ * pattern as subflow mounting.
+ *
+ * Zero runtime deps on Zod — Zod schemas detected via duck-typing and
+ * converted to JSON Schema at contract creation time.
+ */
+export { defineContract } from './defineContract';
+export { isZodSchema, normalizeSchema, zodToJsonSchema } from './schema';
+export { generateOpenAPI } from './openapi';
+export type { FlowChartContract, FlowChartContractOptions, JsonSchema, OpenAPIOptions, OpenAPISpec, SchemaInput, } from './types';

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

@@ -0,0 +1,12 @@
+/**
+ * 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
+ * - inputSchema → requestBody
+ * - outputSchema → response
+ * - chart.buildTimeStructure → operation metadata (branches, forks, etc.)
+ */
+import type { FlowChartContract, OpenAPIOptions, OpenAPISpec } from './types';
+export declare function generateOpenAPI(contract: FlowChartContract, options?: OpenAPIOptions): OpenAPISpec;

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

@@ -0,0 +1,14 @@
+/**
+ * contract/schema.ts — Schema normalization utilities.
+ *
+ * Converts Zod schemas or raw JSON Schema objects into a normalized
+ * JsonSchema format. Zod detection uses duck-typing (checks for `_def`).
+ *
+ * Standalone: no dependency on Zod at import time.
+ * Compatible with Zod v4 internals.
+ */
+import type { JsonSchema, SchemaInput } from './types';
+export declare function isZodSchema(input: unknown): boolean;
+/** Convert a Zod schema object to JSON Schema. */
+export declare function zodToJsonSchema(zodSchema: Record<string, unknown>): JsonSchema;
+export declare function normalizeSchema(input: SchemaInput): JsonSchema;

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

@@ -0,0 +1,94 @@
+/**
+ * contract/types.ts — Types for the FlowChart contract layer.
+ *
+ * Defines the I/O boundary for a flowchart: input schema, output schema,
+ * and output mapper. Uses the same pattern as SubflowMountOptions
+ * (inputMapper/outputMapper) but at the top-level flowchart boundary.
+ */
+import type { FlowChart } from '../builder/types';
+export type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    default?: unknown;
+    format?: string;
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    $ref?: string;
+    [key: string]: unknown;
+};
+/** Anything with a `def` (Zod v4) or `_def` (Zod v3) property is treated as a Zod schema. */
+export type SchemaInput = JsonSchema | {
+    def: unknown;
+    [key: string]: unknown;
+};
+export interface FlowChartContractOptions<_TInput = unknown, TOutput = unknown> {
+    /** Schema describing the input (readOnlyContext) shape. Zod or JSON Schema. */
+    inputSchema?: SchemaInput;
+    /** Schema describing the output shape. Zod or JSON Schema. */
+    outputSchema?: SchemaInput;
+    /** Maps the final scope state into the response shape. */
+    outputMapper?: (finalScope: Record<string, unknown>) => TOutput;
+}
+export interface FlowChartContract<_TInput = unknown, TOutput = unknown> {
+    /** The compiled flowchart. */
+    chart: FlowChart;
+    /** JSON Schema for the input (normalized from Zod or raw). */
+    inputSchema?: JsonSchema;
+    /** JSON Schema for the output (normalized from Zod or raw). */
+    outputSchema?: JsonSchema;
+    /** Maps the final scope state into the response shape. */
+    outputMapper?: (finalScope: Record<string, unknown>) => TOutput;
+    /** Auto-generated OpenAPI spec. */
+    toOpenAPI(options?: OpenAPIOptions): OpenAPISpec;
+}
+export interface OpenAPIOptions {
+    /** API version string (default: "1.0.0"). */
+    version?: string;
+    /** Base path prefix (default: "/"). */
+    basePath?: string;
+    /** HTTP method for the execute endpoint (default: "post"). */
+    method?: string;
+}
+export interface OpenAPISpec {
+    openapi: '3.1.0';
+    info: {
+        title: string;
+        description: string;
+        version: string;
+    };
+    paths: Record<string, Record<string, OpenAPIOperation>>;
+    components?: {
+        schemas?: Record<string, JsonSchema>;
+    };
+}
+export interface OpenAPIOperation {
+    operationId: string;
+    summary: string;
+    description: string;
+    requestBody?: {
+        required: boolean;
+        content: {
+            'application/json': {
+                schema: JsonSchema | {
+                    $ref: string;
+                };
+            };
+        };
+    };
+    responses: Record<string, {
+        description: string;
+        content?: {
+            'application/json': {
+                schema: JsonSchema | {
+                    $ref: string;
+                };
+            };
+        };
+    }>;
+}

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

@@ -14,3 +14,13 @@ export { CombinedNarrativeBuilder } from './narrative/CombinedNarrativeBuilder';
 export { ControlFlowNarrativeGenerator } from './narrative/ControlFlowNarrativeGenerator';
 export { NullControlFlowNarrativeGenerator } from './narrative/NullControlFlowNarrativeGenerator';
 export type { IControlFlowNarrative } from './narrative/types';
+export { FlowRecorderDispatcher } from './narrative/FlowRecorderDispatcher';
+export { NarrativeFlowRecorder } from './narrative/NarrativeFlowRecorder';
+export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './narrative/types';
+export { AdaptiveNarrativeFlowRecorder } from './narrative/recorders/AdaptiveNarrativeFlowRecorder';
+export { MilestoneNarrativeFlowRecorder } from './narrative/recorders/MilestoneNarrativeFlowRecorder';
+export { ProgressiveNarrativeFlowRecorder } from './narrative/recorders/ProgressiveNarrativeFlowRecorder';
+export { RLENarrativeFlowRecorder } from './narrative/recorders/RLENarrativeFlowRecorder';
+export { SeparateNarrativeFlowRecorder } from './narrative/recorders/SeparateNarrativeFlowRecorder';
+export { SilentNarrativeFlowRecorder } from './narrative/recorders/SilentNarrativeFlowRecorder';
+export { WindowedNarrativeFlowRecorder } from './narrative/recorders/WindowedNarrativeFlowRecorder';

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

@@ -0,0 +1,38 @@
+/**
+ * FlowRecorderDispatcher — Fans out control flow events to N attached FlowRecorders.
+ *
+ * Implements IControlFlowNarrative so it can replace the single
+ * ControlFlowNarrativeGenerator in the traverser's HandlerDeps.
+ *
+ * Design mirrors ScopeFacade._invokeHook: iterate recorders, call optional
+ * hooks, swallow errors so a failing recorder never breaks execution.
+ *
+ * When no recorders are attached, every method is a fast no-op (empty array check).
+ */
+import type { FlowRecorder, IControlFlowNarrative } from './types';
+export declare class FlowRecorderDispatcher implements IControlFlowNarrative {
+    private recorders;
+    /** Attach a FlowRecorder. Duplicate IDs are allowed (same as scope Recorder). */
+    attach(recorder: FlowRecorder): void;
+    /** Detach all FlowRecorders with the given ID. */
+    detach(id: string): void;
+    /** Returns a defensive copy of attached recorders. */
+    getRecorders(): FlowRecorder[];
+    /** Find a recorder by ID. Useful for retrieving built-in recorders like NarrativeFlowRecorder. */
+    getRecorderById<T extends FlowRecorder = FlowRecorder>(id: string): T | undefined;
+    onStageExecuted(stageName: string, description?: string): void;
+    onNext(fromStage: string, toStage: string, description?: string): void;
+    onDecision(deciderName: string, chosenBranch: string, rationale?: string, deciderDescription?: string): void;
+    onFork(parentStage: string, childNames: string[]): void;
+    onSelected(parentStage: string, selectedNames: string[], totalCount: number): void;
+    onSubflowEntry(subflowName: string): void;
+    onSubflowExit(subflowName: string): void;
+    onLoop(targetStage: string, iteration: number, description?: string): void;
+    onBreak(stageName: string): void;
+    onError(stageName: string, errorMessage: string): void;
+    /**
+     * Returns sentences from the first attached recorder that provides them.
+     * By convention, NarrativeFlowRecorder exposes getSentences().
+     */
+    getSentences(): string[];
+}

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

@@ -0,0 +1,31 @@
+/**
+ * NarrativeFlowRecorder — Default FlowRecorder that generates plain-English narrative.
+ *
+ * This is the FlowRecorder equivalent of ControlFlowNarrativeGenerator.
+ * Produces the same sentences, same format, same behavior — but as a
+ * pluggable FlowRecorder that can be swapped, extended, or composed.
+ *
+ * Consumers who want different narrative behavior (windowed loops, adaptive
+ * summarization, etc.) can replace this with a different FlowRecorder.
+ */
+import type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent } from './types';
+export declare class NarrativeFlowRecorder implements FlowRecorder {
+    readonly id: string;
+    private sentences;
+    private isFirstStage;
+    constructor(id?: string);
+    onStageExecuted(event: FlowStageEvent): void;
+    onNext(event: FlowNextEvent): void;
+    onDecision(event: FlowDecisionEvent): void;
+    onFork(event: FlowForkEvent): void;
+    onSelected(event: FlowSelectedEvent): void;
+    onSubflowEntry(event: FlowSubflowEvent): void;
+    onSubflowExit(event: FlowSubflowEvent): void;
+    onLoop(event: FlowLoopEvent): void;
+    onBreak(event: FlowBreakEvent): void;
+    onError(event: FlowErrorEvent): void;
+    /** Returns a defensive copy of accumulated sentences. */
+    getSentences(): string[];
+    /** Clears accumulated sentences. Useful for reuse across runs. */
+    clear(): void;
+}

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

@@ -3,3 +3,13 @@ export { CombinedNarrativeBuilder } from './CombinedNarrativeBuilder';
 export { ControlFlowNarrativeGenerator } from './ControlFlowNarrativeGenerator';
 export { NullControlFlowNarrativeGenerator } from './NullControlFlowNarrativeGenerator';
 export type { IControlFlowNarrative } from './types';
+export { FlowRecorderDispatcher } from './FlowRecorderDispatcher';
+export { NarrativeFlowRecorder } from './NarrativeFlowRecorder';
+export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './types';
+export { AdaptiveNarrativeFlowRecorder } from './recorders/AdaptiveNarrativeFlowRecorder';
+export { MilestoneNarrativeFlowRecorder } from './recorders/MilestoneNarrativeFlowRecorder';
+export { ProgressiveNarrativeFlowRecorder } from './recorders/ProgressiveNarrativeFlowRecorder';
+export { RLENarrativeFlowRecorder } from './recorders/RLENarrativeFlowRecorder';
+export { SeparateNarrativeFlowRecorder } from './recorders/SeparateNarrativeFlowRecorder';
+export { SilentNarrativeFlowRecorder } from './recorders/SilentNarrativeFlowRecorder';
+export { WindowedNarrativeFlowRecorder } from './recorders/WindowedNarrativeFlowRecorder';

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

@@ -0,0 +1,25 @@
+/**
+ * AdaptiveNarrativeFlowRecorder — Full detail until threshold, then samples every Nth.
+ *
+ * Best for: Unknown loop counts where you want full detail for short loops
+ * but automatic compression for long ones.
+ *
+ * @example
+ * ```typescript
+ * // Full detail for first 5, then every 10th iteration
+ * executor.attachFlowRecorder(new AdaptiveNarrativeFlowRecorder(5, 10));
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class AdaptiveNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private readonly threshold;
+    private readonly sampleRate;
+    private totalPerTarget;
+    private suppressedCount;
+    constructor(threshold?: number, sampleRate?: number, id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    /** Returns the number of suppressed loop sentences. */
+    getSuppressedCount(): number;
+    clear(): void;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * MilestoneNarrativeFlowRecorder — Emits every Nth iteration (milestones only).
+ *
+ * Best for: High-iteration loops where you want regular progress markers
+ * without caring about individual iterations.
+ *
+ * @example
+ * ```typescript
+ * // Emit every 10th iteration
+ * executor.attachFlowRecorder(new MilestoneNarrativeFlowRecorder(10));
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class MilestoneNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private readonly interval;
+    private readonly alwaysEmitFirst;
+    private suppressedCount;
+    constructor(interval?: number, alwaysEmitFirst?: boolean, id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    /** Returns the number of suppressed loop sentences. */
+    getSuppressedCount(): number;
+    clear(): void;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * ProgressiveNarrativeFlowRecorder — Exponentially decreasing detail as iterations grow.
+ *
+ * Emits at exponentially increasing intervals: 1, 2, 4, 8, 16, 32, ...
+ * Gives rich detail for early iterations and progressively less as the loop continues.
+ *
+ * Best for: Convergence-style loops (gradient descent, iterative refinement)
+ * where early iterations are most informative.
+ *
+ * @example
+ * ```typescript
+ * executor.attachFlowRecorder(new ProgressiveNarrativeFlowRecorder());
+ * // Emits: pass 1, 2, 4, 8, 16, 32, 64, 128...
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class ProgressiveNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private readonly base;
+    private suppressedCount;
+    /**
+     * @param base - The exponential base. Default 2 means emit at 1, 2, 4, 8, 16...
+     */
+    constructor(base?: number, id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    private shouldEmit;
+    /** Returns the number of suppressed loop sentences. */
+    getSuppressedCount(): number;
+    clear(): void;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * RLENarrativeFlowRecorder — Run-Length Encoding for consecutive identical loop targets.
+ *
+ * Instead of emitting one sentence per iteration, collapses consecutive loops
+ * through the same target into a single "Looped N times through X" sentence.
+ *
+ * Best for: Simple retry loops where every iteration looks the same.
+ *
+ * @example
+ * ```typescript
+ * executor.attachFlowRecorder(new RLENarrativeFlowRecorder());
+ * // Instead of 50 "On pass N..." lines:
+ * // "Looped through AskLLM 50 times (passes 1–50)."
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class RLENarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private currentRun;
+    private completedRuns;
+    constructor(id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    getSentences(): string[];
+    clear(): void;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * SeparateNarrativeFlowRecorder — Collects loop iterations in a separate channel.
+ *
+ * Keeps the main narrative clean (no loop sentences) while preserving full
+ * iteration detail in a separate accessor for consumers who need it.
+ *
+ * Best for: UIs or reports where loop detail is in a collapsible section,
+ * or LLM pipelines where loop context should be available but not in the main prompt.
+ *
+ * @example
+ * ```typescript
+ * const recorder = new SeparateNarrativeFlowRecorder();
+ * executor.attachFlowRecorder(recorder);
+ * await executor.run();
+ *
+ * const mainNarrative = executor.getNarrative();     // No loop sentences
+ * const loopDetail = recorder.getLoopSentences();    // All loop detail
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class SeparateNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private loopSentences;
+    private loopCounts;
+    constructor(id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    /** Returns all loop iteration sentences (the separate channel). */
+    getLoopSentences(): string[];
+    /** Returns total loop count per target. */
+    getLoopCounts(): Map<string, number>;
+    clear(): void;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * SilentNarrativeFlowRecorder — Suppresses all per-iteration loop sentences,
+ * emits a single summary sentence at the end.
+ *
+ * Best for: Loops where iteration details are irrelevant and you only care
+ * about the total count.
+ *
+ * @example
+ * ```typescript
+ * executor.attachFlowRecorder(new SilentNarrativeFlowRecorder());
+ * // Produces: "Looped 50 times through AskLLM."
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class SilentNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private loopCounts;
+    private loopOrder;
+    constructor(id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    getSentences(): string[];
+    /** Returns the total loop count per target. */
+    getLoopCounts(): Map<string, number>;
+    clear(): void;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * WindowedNarrativeFlowRecorder — Shows first N and last M loop iterations, skips the middle.
+ *
+ * Best for: Moderate loops (10–200 iterations) where you want to see how it started
+ * and how it ended, without the noise in between.
+ *
+ * When total iterations <= head + tail, all iterations are emitted (no compression).
+ * When total > head + tail, the middle is replaced with a summary line.
+ *
+ * @example
+ * ```typescript
+ * // Show first 3 and last 2 iterations
+ * executor.attachFlowRecorder(new WindowedNarrativeFlowRecorder(3, 2));
+ * ```
+ */
+import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder';
+import type { FlowLoopEvent } from '../types';
+export declare class WindowedNarrativeFlowRecorder extends NarrativeFlowRecorder {
+    private readonly head;
+    private readonly tail;
+    private loopEvents;
+    constructor(head?: number, tail?: number, id?: string);
+    onLoop(event: FlowLoopEvent): void;
+    getSentences(): string[];
+    /** Returns the number of suppressed loop sentences. */
+    getSuppressedCount(): number;
+    clear(): void;
+    private formatLoopSentence;
+}

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

@@ -0,0 +1,7 @@
+export { AdaptiveNarrativeFlowRecorder } from './AdaptiveNarrativeFlowRecorder';
+export { MilestoneNarrativeFlowRecorder } from './MilestoneNarrativeFlowRecorder';
+export { ProgressiveNarrativeFlowRecorder } from './ProgressiveNarrativeFlowRecorder';
+export { RLENarrativeFlowRecorder } from './RLENarrativeFlowRecorder';
+export { SeparateNarrativeFlowRecorder } from './SeparateNarrativeFlowRecorder';
+export { SilentNarrativeFlowRecorder } from './SilentNarrativeFlowRecorder';
+export { WindowedNarrativeFlowRecorder } from './WindowedNarrativeFlowRecorder';