flowcraft 1.0.0 → 2.0.0

package/dist/runtime/index.js

@@ -0,0 +1,16 @@
+import '../chunk-HMR2GEGE.js';
+export { BaseDistributedAdapter } from '../chunk-NPAJNLXQ.js';
+export { FlowRuntime } from '../chunk-RYTIQZIB.js';
+export { WorkflowState } from '../chunk-UYPIWXZG.js';
+export { GraphTraverser } from '../chunk-RW4FH7IL.js';
+import '../chunk-J3RNCPED.js';
+import '../chunk-REH55ZXV.js';
+export { BuiltInNodeExecutor, ClassNodeExecutor, FunctionNodeExecutor } from '../chunk-734J4PTM.js';
+import '../chunk-MICPMOTW.js';
+import '../chunk-WXT3YEWU.js';
+import '../chunk-GTZC6PQI.js';
+import '../chunk-DSZSR7UE.js';
+import '../chunk-M23P46ZL.js';
+import '../chunk-VFC342WL.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,33 @@
+import { j as RuntimeOptions, W as WorkflowBlueprint, p as WorkflowResult, b as NodeResult, C as ContextImplementation, N as NodeDefinition, E as EdgeDefinition } from '../types-CZN_FcB6.js';
+import { IRuntime } from './types.js';
+import { WorkflowState } from './state.js';
+
+declare class FlowRuntime<TContext extends Record<string, any>, TDependencies extends Record<string, any>> implements IRuntime<TContext, TDependencies> {
+    private registry;
+    private blueprints;
+    private dependencies;
+    private logger;
+    private eventBus;
+    private serializer;
+    private middleware;
+    private evaluator;
+    options: RuntimeOptions<TDependencies>;
+    constructor(options: RuntimeOptions<TDependencies>);
+    run(blueprint: WorkflowBlueprint, initialState?: Partial<TContext> | string, options?: {
+        functionRegistry?: Map<string, any>;
+        strict?: boolean;
+        signal?: AbortSignal;
+    }): Promise<WorkflowResult<TContext>>;
+    executeNode(blueprint: WorkflowBlueprint, nodeId: string, state: WorkflowState<TContext>, allPredecessors?: Map<string, Set<string>>, functionRegistry?: Map<string, any>, executionId?: string, signal?: AbortSignal): Promise<NodeResult>;
+    private getExecutor;
+    private executeWithFallback;
+    determineNextNodes(blueprint: WorkflowBlueprint, nodeId: string, result: NodeResult, context: ContextImplementation<TContext>): Promise<{
+        node: NodeDefinition;
+        edge: EdgeDefinition;
+    }[]>;
+    applyEdgeTransform(edge: EdgeDefinition, sourceResult: NodeResult, targetNode: NodeDefinition, context: ContextImplementation<TContext>, allPredecessors?: Map<string, Set<string>>): Promise<void>;
+    private _resolveNodeInput;
+    protected _executeBuiltInNode(nodeDef: NodeDefinition, contextImpl: ContextImplementation<TContext>): Promise<NodeResult>;
+}
+
+export { FlowRuntime };

package/dist/runtime/runtime.js

@@ -0,0 +1,14 @@
+export { FlowRuntime } from '../chunk-RYTIQZIB.js';
+import '../chunk-UYPIWXZG.js';
+import '../chunk-RW4FH7IL.js';
+import '../chunk-J3RNCPED.js';
+import '../chunk-REH55ZXV.js';
+import '../chunk-734J4PTM.js';
+import '../chunk-MICPMOTW.js';
+import '../chunk-WXT3YEWU.js';
+import '../chunk-GTZC6PQI.js';
+import '../chunk-DSZSR7UE.js';
+import '../chunk-M23P46ZL.js';
+import '../chunk-VFC342WL.js';
+//# sourceMappingURL=runtime.js.map
+//# sourceMappingURL=runtime.js.map

package/dist/runtime/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"runtime.js"}

package/dist/runtime/state.d.ts

@@ -0,0 +1,21 @@
+import { C as ContextImplementation, o as WorkflowError, p as WorkflowResult, n as ISerializer } from '../types-CZN_FcB6.js';
+
+declare class WorkflowState<TContext extends Record<string, any>> {
+    private _completedNodes;
+    private errors;
+    private anyFallbackExecuted;
+    private context;
+    constructor(initialData: Partial<TContext>);
+    addCompletedNode(nodeId: string, output: any): void;
+    addError(nodeId: string, error: Error): void;
+    clearError(nodeId: string): void;
+    markFallbackExecuted(): void;
+    getContext(): ContextImplementation<TContext>;
+    getCompletedNodes(): Set<string>;
+    getErrors(): WorkflowError[];
+    getAnyFallbackExecuted(): boolean;
+    getStatus(allNodeIds: Set<string>, fallbackNodeIds: Set<string>): WorkflowResult['status'];
+    toResult(serializer: ISerializer): WorkflowResult<TContext>;
+}
+
+export { WorkflowState };

package/dist/runtime/state.js

@@ -0,0 +1,4 @@
+export { WorkflowState } from '../chunk-UYPIWXZG.js';
+import '../chunk-MICPMOTW.js';
+//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/dist/runtime/state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"state.js"}

package/dist/runtime/traverser.d.ts

@@ -0,0 +1,24 @@
+import { W as WorkflowBlueprint } from '../types-CZN_FcB6.js';
+import { WorkflowState } from './state.js';
+import { IRuntime } from './types.js';
+
+declare class GraphTraverser<TContext extends Record<string, any>, TDependencies extends Record<string, any>> {
+    private blueprint;
+    private runtime;
+    private state;
+    private functionRegistry;
+    private executionId;
+    private signal?;
+    private frontier;
+    private allPredecessors;
+    private dynamicBlueprint;
+    constructor(blueprint: WorkflowBlueprint, runtime: IRuntime<TContext, TDependencies>, state: WorkflowState<TContext>, functionRegistry: Map<string, any> | undefined, executionId: string, signal?: AbortSignal | undefined);
+    private isFallbackNode;
+    traverse(): Promise<void>;
+    private handleDynamicNodes;
+    getAllNodeIds(): Set<string>;
+    getFallbackNodeIds(): Set<string>;
+    getDynamicBlueprint(): WorkflowBlueprint;
+}
+
+export { GraphTraverser };

package/dist/runtime/traverser.js

@@ -0,0 +1,5 @@
+export { GraphTraverser } from '../chunk-RW4FH7IL.js';
+import '../chunk-WXT3YEWU.js';
+import '../chunk-M23P46ZL.js';
+//# sourceMappingURL=traverser.js.map
+//# sourceMappingURL=traverser.js.map

package/dist/runtime/traverser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"traverser.js"}

package/dist/runtime/types.d.ts

@@ -0,0 +1,15 @@
+import { R as RuntimeDependencies, j as RuntimeOptions, W as WorkflowBlueprint, b as NodeResult, C as ContextImplementation, N as NodeDefinition, E as EdgeDefinition } from '../types-CZN_FcB6.js';
+import { WorkflowState } from './state.js';
+
+/** Interface for the core runtime operations used by the traverser. */
+interface IRuntime<TContext extends Record<string, any> = Record<string, any>, TDependencies extends RuntimeDependencies = RuntimeDependencies> {
+    options: RuntimeOptions<TDependencies>;
+    executeNode: (blueprint: WorkflowBlueprint, nodeId: string, state: WorkflowState<TContext>, allPredecessors?: Map<string, Set<string>>, functionRegistry?: Map<string, any>, executionId?: string, signal?: AbortSignal) => Promise<NodeResult>;
+    determineNextNodes: (blueprint: WorkflowBlueprint, nodeId: string, result: NodeResult, context: ContextImplementation<TContext>) => Promise<{
+        node: NodeDefinition;
+        edge: EdgeDefinition;
+    }[]>;
+    applyEdgeTransform: (edge: EdgeDefinition, sourceResult: NodeResult, targetNode: NodeDefinition, context: ContextImplementation<TContext>, allPredecessors?: Map<string, Set<string>>) => Promise<void>;
+}
+
+export type { IRuntime };

package/dist/runtime/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/sanitizer.d.ts

@@ -0,0 +1,10 @@
+import { W as WorkflowBlueprint } from './types-CZN_FcB6.js';
+
+/**
+ * Sanitizes a raw workflow blueprint by removing extra properties
+ * added by UI tools (e.g., position, style) and keeping only the
+ * properties defined in NodeDefinition and EdgeDefinition.
+ */
+declare function sanitizeBlueprint(raw: any): WorkflowBlueprint;
+
+export { sanitizeBlueprint };

package/dist/sanitizer.js

@@ -0,0 +1,3 @@
+export { sanitizeBlueprint } from './chunk-J3RNCPED.js';
+//# sourceMappingURL=sanitizer.js.map
+//# sourceMappingURL=sanitizer.js.map

package/dist/{utils/sanitize.js.map → sanitizer.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"sanitize.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sanitizer.js"}

package/dist/serializer.d.ts

@@ -0,0 +1,15 @@
+import { n as ISerializer } from './types-CZN_FcB6.js';
+
+/**
+ * A default serializer using standard JSON.
+ *
+ * @warning This implementation is lossy and does not handle complex data types
+ * like `Date`, `Map`, `Set`, `undefined`, etc. It is recommended to provide a robust
+ * serializer like `superjson` if working with complex data types.
+ */
+declare class JsonSerializer implements ISerializer {
+    serialize(data: Record<string, any>): string;
+    deserialize(text: string): Record<string, any>;
+}
+
+export { JsonSerializer };

package/dist/serializer.js

@@ -0,0 +1,3 @@
+export { JsonSerializer } from './chunk-REH55ZXV.js';
+//# sourceMappingURL=serializer.js.map
+//# sourceMappingURL=serializer.js.map

package/dist/serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"serializer.js"}

package/dist/types-CZN_FcB6.d.ts

@@ -0,0 +1,201 @@
+/** eslint-disable unused-imports/no-unused-vars */
+
+/** A type guard to reliably distinguish a NodeClass from a NodeFunction. */
+declare function isNodeClass(impl: any): impl is NodeClass;
+/**
+ * A structured, class-based node for complex logic with a safe, granular lifecycle.
+ * This class is generic, allowing implementations to specify the exact context
+ * and dependency types they expect.
+ */
+declare abstract class BaseNode<TContext extends Record<string, any> = Record<string, any>, TDependencies extends RuntimeDependencies = RuntimeDependencies> {
+    protected params: Record<string, any>;
+    /**
+     * @param params Static parameters for this node instance, passed from the blueprint.
+     */
+    constructor(params: Record<string, any>);
+    /**
+     * Phase 1: Gathers and prepares data for execution. This phase is NOT retried on failure.
+     * @param context The node's execution context.
+     * @returns The data needed for the `exec` phase.
+     */
+    prep(context: NodeContext<TContext, TDependencies>): Promise<any>;
+    /**
+     * Phase 2: Performs the core, isolated logic. This is the ONLY phase that is retried.
+     * @param prepResult The data returned from the `prep` phase.
+     * @param context The node's execution context.
+     */
+    abstract exec(prepResult: any, context: NodeContext<TContext, TDependencies>): Promise<Omit<NodeResult, 'error'>>;
+    /**
+     * Phase 3: Processes the result and saves state. This phase is NOT retried.
+     * @param execResult The successful result from the `exec` or `fallback` phase.
+     * @param _context The node's execution context.
+     */
+    post(execResult: Omit<NodeResult, 'error'>, _context: NodeContext<TContext, TDependencies>): Promise<NodeResult>;
+    /**
+     * An optional safety net that runs if all `exec` retries fail.
+     * @param error The final error from the last `exec` attempt.
+     * @param _context The node's execution context.
+     */
+    fallback(error: Error, _context: NodeContext<TContext, TDependencies>): Promise<Omit<NodeResult, 'error'>>;
+}
+
+/** The central, serializable representation of a workflow. */
+interface WorkflowBlueprint {
+    id: string;
+    nodes: NodeDefinition[];
+    edges: EdgeDefinition[];
+    metadata?: Record<string, any>;
+}
+/** Defines a single step in the workflow. */
+interface NodeDefinition {
+    id: string;
+    /** A key that resolves to an implementation in a registry. */
+    uses: string;
+    /** Static parameters for the node. */
+    params?: Record<string, any>;
+    /** Maps context data to this node's `input`. */
+    inputs?: string | Record<string, string>;
+    /** Configuration for retries, timeouts, etc. */
+    config?: NodeConfig;
+}
+/** Defines the connection and data flow between two nodes. */
+interface EdgeDefinition {
+    source: string;
+    target: string;
+    /** An 'action' from the source node that triggers this edge. */
+    action?: string;
+    /** A condition that must be met for this edge to be taken. */
+    condition?: string;
+    /** A string expression to transform the data before passing it to the target node. */
+    transform?: string;
+}
+/** Configuration for a node's resiliency and behavior. */
+interface NodeConfig {
+    maxRetries?: number;
+    retryDelay?: number;
+    timeout?: number;
+    /** The `uses` key of another node implementation for fallback. */
+    fallback?: string;
+    /** Determines how a node with multiple incoming edges should be triggered. */
+    joinStrategy?: 'all' | 'any';
+}
+/** The required return type for any node implementation. */
+interface NodeResult<TOutput = any> {
+    output?: TOutput;
+    action?: string;
+    error?: {
+        message: string;
+        [key: string]: any;
+    };
+    /** Allows a node to dynamically schedule new nodes for the orchestrator to execute. */
+    dynamicNodes?: NodeDefinition[];
+    /** Internal flag: Indicates that this result came from a fallback execution. */
+    _fallbackExecuted?: boolean;
+}
+/** The context object passed to every node's execution logic. */
+interface NodeContext<TContext extends Record<string, any> = Record<string, any>, TDependencies extends RuntimeDependencies = RuntimeDependencies> {
+    /** The async-only interface for interacting with the workflow's state. */
+    context: IAsyncContext<TContext>;
+    /** The primary input data for this node, typically from its predecessor. */
+    input?: any;
+    /** Static parameters defined in the blueprint. */
+    params: Record<string, any>;
+    /** Shared, runtime-level dependencies (e.g., database clients, loggers). */
+    dependencies: TDependencies;
+    /** A signal to gracefully cancel long-running node operations. */
+    signal?: AbortSignal;
+}
+/** A simple function-based node implementation. */
+type NodeFunction<TContext extends Record<string, any> = Record<string, any>, TDependencies extends RuntimeDependencies = RuntimeDependencies> = (context: NodeContext<TContext, TDependencies>) => Promise<NodeResult>;
+/** Represents a constructor for any concrete class that extends the abstract BaseNode. */
+type NodeClass = new (params?: any) => BaseNode<any, any>;
+/** A union of all possible node implementation types. */
+type NodeImplementation = NodeFunction | NodeClass;
+/** A registry mapping node types to their implementations. */
+type NodeRegistry = Record<string, NodeImplementation>;
+/** A discriminated union for all possible context implementations. */
+type ContextImplementation<T extends Record<string, any>> = ISyncContext<T> | IAsyncContext<T>;
+/** The synchronous context interface for high-performance, in-memory state. */
+interface ISyncContext<TContext extends Record<string, any> = Record<string, any>> {
+    readonly type: 'sync';
+    get: <K extends keyof TContext>(key: K) => TContext[K] | undefined;
+    set: <K extends keyof TContext>(key: K, value: TContext[K]) => void;
+    has: (key: keyof TContext) => boolean;
+    delete: (key: keyof TContext) => boolean;
+    toJSON: () => Record<string, any>;
+}
+/** The asynchronous context interface for remote or distributed state. */
+interface IAsyncContext<TContext extends Record<string, any> = Record<string, any>> {
+    readonly type: 'async';
+    get: <K extends keyof TContext>(key: K) => Promise<TContext[K] | undefined>;
+    set: <K extends keyof TContext>(key: K, value: TContext[K]) => Promise<void>;
+    has: (key: keyof TContext) => Promise<boolean>;
+    delete: (key: keyof TContext) => Promise<boolean>;
+    toJSON: () => Promise<Record<string, any>>;
+}
+/** Generic for any set of dependencies. */
+interface RuntimeDependencies {
+    [key: string]: any;
+}
+/** Configuration options for the FlowRuntime. */
+interface RuntimeOptions<TDependencies extends RuntimeDependencies = RuntimeDependencies> {
+    /** A registry of globally available node implementations. */
+    registry?: Record<string, NodeFunction | NodeClass>;
+    /** A registry of all available workflow blueprints for subflow execution. */
+    blueprints?: Record<string, WorkflowBlueprint>;
+    /** Shared dependencies to be injected into every node. */
+    dependencies?: TDependencies;
+    /** A pluggable logger for consistent output. */
+    logger?: ILogger;
+    /** A pluggable event bus for observability. */
+    eventBus?: IEventBus;
+    /** A pluggable evaluator for edge conditions and transforms. */
+    evaluator?: IEvaluator;
+    /** An array of middleware to wrap node execution. */
+    middleware?: Middleware[];
+    /** A pluggable serializer for handling complex data types in the context. */
+    serializer?: ISerializer;
+    /** A flag to enforce strictness in the workflow. */
+    strict?: boolean;
+}
+/** Interface for a pluggable expression evaluator for conditions and transforms. */
+interface IEvaluator {
+    evaluate: (expression: string, context: Record<string, any>) => any;
+}
+/** Interface for a pluggable logger. */
+interface ILogger {
+    debug: (message: string, meta?: Record<string, any>) => void;
+    info: (message: string, meta?: Record<string, any>) => void;
+    warn: (message: string, meta?: Record<string, any>) => void;
+    error: (message: string, meta?: Record<string, any>) => void;
+}
+/** Interface for a pluggable event bus. */
+interface IEventBus {
+    emit: (eventName: string, payload: Record<string, any>) => void | Promise<void>;
+}
+/** Interface for a pluggable serializer. */
+interface ISerializer {
+    serialize: (data: Record<string, any>) => string;
+    deserialize: (text: string) => Record<string, any>;
+}
+/** Interface for middleware to handle cross-cutting concerns. */
+interface Middleware<TContext extends Record<string, any> = Record<string, any>> {
+    beforeNode?: (ctx: ContextImplementation<TContext>, nodeId: string) => void | Promise<void>;
+    afterNode?: (ctx: ContextImplementation<TContext>, nodeId: string, result: NodeResult | undefined, error: Error | undefined) => void | Promise<void>;
+    aroundNode?: (ctx: ContextImplementation<TContext>, nodeId: string, next: () => Promise<NodeResult>) => Promise<NodeResult>;
+}
+/** A structured error object returned from a failed workflow execution. */
+interface WorkflowError {
+    nodeId: string;
+    message: string;
+    originalError?: any;
+}
+/** The final result of a workflow execution. */
+interface WorkflowResult<TContext = any> {
+    context: TContext;
+    serializedContext: string;
+    status: 'completed' | 'failed' | 'stalled' | 'cancelled';
+    errors?: WorkflowError[];
+}
+
+export { BaseNode as B, type ContextImplementation as C, type EdgeDefinition as E, type ISyncContext as I, type Middleware as M, type NodeDefinition as N, type RuntimeDependencies as R, type WorkflowBlueprint as W, type NodeConfig as a, type NodeResult as b, type NodeContext as c, type NodeFunction as d, type NodeClass as e, type NodeImplementation as f, type NodeRegistry as g, type IAsyncContext as h, isNodeClass as i, type RuntimeOptions as j, type IEvaluator as k, type ILogger as l, type IEventBus as m, type ISerializer as n, type WorkflowError as o, type WorkflowResult as p };

package/dist/types.d.ts

@@ -1,3 +1 @@
-import './context.js';
-export { D as DEFAULT_ACTION, a as FILTER_FAILED, e as Middleware, M as MiddlewareNext, b as NodeArgs, d as NodeOptions, c as NodeRunContext, P as Params, R as RunOptions } from './types-U76Ukj96.js';
-import './logger.js';
+export { C as ContextImplementation, E as EdgeDefinition, h as IAsyncContext, k as IEvaluator, m as IEventBus, l as ILogger, n as ISerializer, I as ISyncContext, M as Middleware, e as NodeClass, a as NodeConfig, c as NodeContext, N as NodeDefinition, d as NodeFunction, f as NodeImplementation, g as NodeRegistry, b as NodeResult, R as RuntimeDependencies, j as RuntimeOptions, W as WorkflowBlueprint, o as WorkflowError, p as WorkflowResult } from './types-CZN_FcB6.js';

package/dist/types.js

@@ -1,3 +1,3 @@
-export { DEFAULT_ACTION, FILTER_FAILED } from './chunk-AOHBHYF6.js';
+import './chunk-55J6XMHW.js';
 //# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,9 +1,8 @@
 {
 	"name": "flowcraft",
 	"type": "module",
-	"version": "1.0.0",
-	"packageManager": "pnpm@10.18.1",
-	"description": "A flexible workflow framework",
+	"version": "2.0.0",
+	"description": "A lightweight workflow framework",
 	"license": "MIT",
 	"homepage": "https://github.com/gorango/flowcraft",
 	"repository": {
@@ -36,28 +35,18 @@
 		"dist"
 	],
 	"scripts": {
-		"dev": "tsup --watch --config config/tsup.config.ts",
-		"build": "tsup --config config/tsup.config.ts",
-		"lint": "eslint --fix . --ext .ts",
-		"typecheck": "tsc --noEmit -p config/tsconfig.json",
-		"test": "vitest run --config config/vitest.config.ts",
-		"test:watch": "vitest --config config/vitest.config.ts",
-		"test:coverage": "vitest run --coverage --config config/vitest.config.ts",
-		"docs:dev": "vitepress dev docs",
-		"docs:build": "vitepress build docs",
-		"docs:preview": "vitepress preview docs"
+		"dev": "tsup --watch",
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage"
 	},
 	"devDependencies": {
-		"@antfu/eslint-config": "^5.4.1",
-		"@types/node": "^24.7.0",
+		"@types/node": "^24.7.2",
 		"@vitest/coverage-v8": "3.2.4",
-		"eslint": "^9.37.0",
-		"jiti": "^2.6.1",
-		"mermaid": "^11.12.0",
 		"tsup": "^8.5.0",
 		"typescript": "^5.9.3",
-		"vitepress": "^1.6.4",
-		"vitepress-plugin-mermaid": "^2.0.17",
 		"vitest": "^3.2.4"
 	}
 }

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2024 Feathers
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/builder/graph/graph.d.ts

@@ -1,57 +0,0 @@
-import { Logger } from '../../logger.js';
-import { f as NodeTypeMap, i as TypedNodeRegistry, n as NodeRegistry, o as GraphBuilderOptions, h as TypedWorkflowGraph, k as BuildResult, m as WorkflowGraph, B as BlueprintBuildResult } from '../../types-U76Ukj96.js';
-import '../../context.js';
-
-/**
- * A smart factory that takes an object of custom node classes and returns a fully
- * prepared `NodeRegistry` map with all internal nodes required by the GraphBuilder.
- *
- * @param registry An object where keys are node type strings and values are the corresponding Node constructors.
- * @returns A `Map` instance ready to be used by the `GraphBuilder` or a custom executor.
- */
-declare function createNodeRegistry<TNodeMap extends NodeTypeMap, TContext = object>(registry: TypedNodeRegistry<TNodeMap, TContext>): NodeRegistry;
-/**
- * Constructs a serializable `WorkflowBlueprint` from a declarative `WorkflowGraph` definition.
- * The blueprint is a static, storable artifact that can be executed by a `BlueprintExecutor`.
- * @template TNodeMap A `NodeTypeMap` for validating type-safe graph definitions.
- * @template TContext The shape of the dependency injection context object.
- */
-declare class GraphBuilder<TNodeMap extends NodeTypeMap, TContext extends object = object> {
-    private nodeOptionsContext;
-    private registry;
-    private subWorkflowNodeTypes;
-    private conditionalNodeTypes;
-    private subWorkflowResolver?;
-    private logger;
-    /**
-     * @param registry A type-safe object or a `Map` where keys are node `type` strings and
-     * values are the corresponding `Node` class constructors. For type-safety, use `createNodeRegistry`.
-     * @param nodeOptionsContext An optional object that is passed to every node's
-     * constructor, useful for dependency injection (e.g., passing a database client or the builder itself).
-     */
-    constructor(registry: TypedNodeRegistry<TNodeMap, TContext>, nodeOptionsContext?: TContext, options?: GraphBuilderOptions, logger?: Logger);
-    constructor(registry: NodeRegistry, nodeOptionsContext?: Record<string, any>, options?: GraphBuilderOptions, logger?: Logger);
-    private _logMermaid;
-    private _flattenGraph;
-    /**
-     * Builds a runnable `Flow` from a graph definition for immediate in-memory execution.
-     * @param graph The `WorkflowGraph` object describing the flow.
-     * @param log Whether to log the graph after flattening. Defaults to `false`.
-     * @returns A `BuildResult` object containing the executable `flow` and a `nodeMap`.
-     */
-    build(graph: TypedWorkflowGraph<TNodeMap>, log?: boolean): BuildResult;
-    build(graph: WorkflowGraph, log?: boolean): BuildResult;
-    /**
-     * Builds a serializable `WorkflowBlueprint` from a graph definition.
-     * This is the recommended method for preparing a workflow for a distributed environment.
-     * @param graph The `WorkflowGraph` object describing the flow.
-     * @returns A `BlueprintBuildResult` object containing the serializable `blueprint`.
-     */
-    buildBlueprint(graph: TypedWorkflowGraph<TNodeMap>): BlueprintBuildResult;
-    buildBlueprint(graph: WorkflowGraph): BlueprintBuildResult;
-    private _createPredecessorIdMaps;
-    private _findBranchTerminals;
-    private _findConditionalConvergence;
-}
-
-export { GraphBuilder, createNodeRegistry };

package/dist/builder/graph/graph.js

@@ -1,21 +0,0 @@
-export { GraphBuilder, createNodeRegistry } from '../../chunk-3YMBNZ77.js';
-import '../../chunk-WGVHM7DU.js';
-import '../../chunk-L5PK5VL2.js';
-import '../../chunk-F6C6J7HK.js';
-import '../../chunk-UY4PNPBX.js';
-import '../../chunk-ELEHMJPM.js';
-import '../../chunk-HEO3XL4Z.js';
-import '../../chunk-7XUN3OQT.js';
-import '../../chunk-WR5PDOPP.js';
-import '../../chunk-VMH2LRM6.js';
-import '../../chunk-YR433ZDA.js';
-import '../../chunk-6QCXIRLA.js';
-import '../../chunk-BRFMFLR6.js';
-import '../../chunk-PNWOW52F.js';
-import '../../chunk-VZDHIOCH.js';
-import '../../chunk-S4WFNGQG.js';
-import '../../chunk-64DNBF5W.js';
-import '../../chunk-IIKTTIW5.js';
-import '../../chunk-AOHBHYF6.js';
-//# sourceMappingURL=graph.js.map
-//# sourceMappingURL=graph.js.map

package/dist/builder/graph/graph.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"graph.js"}

package/dist/builder/graph/index.d.ts

@@ -1,8 +0,0 @@
-export { GraphBuilder, createNodeRegistry } from './graph.js';
-export { ConditionalJoinNode, InputMappingNode, OutputMappingNode, ParallelBranchContainer, SubWorkflowContainerNode } from './internal-nodes.js';
-export { BlueprintExecutor } from './runner.js';
-export { B as BlueprintBuildResult, k as BuildResult, o as GraphBuilderOptions, G as GraphEdge, l as GraphNode, g as NodeConstructorOptions, n as NodeRegistry, f as NodeTypeMap, O as OriginalPredecessorIdMap, j as PredecessorIdMap, S as SubWorkflowResolver, T as TypedGraphNode, i as TypedNodeRegistry, h as TypedWorkflowGraph, W as WorkflowBlueprint, m as WorkflowGraph } from '../../types-U76Ukj96.js';
-import '../patterns.js';
-import '../../logger.js';
-import '../../context.js';
-import '../../functions.js';

package/dist/builder/graph/index.js

@@ -1,23 +0,0 @@
-import '../../chunk-GMKJ34T2.js';
-import '../../chunk-KOBEU2EM.js';
-export { BlueprintExecutor, GraphBuilder, createNodeRegistry } from '../../chunk-3YMBNZ77.js';
-export { ConditionalJoinNode, InputMappingNode, OutputMappingNode, ParallelBranchContainer, SubWorkflowContainerNode } from '../../chunk-WGVHM7DU.js';
-import '../../chunk-L5PK5VL2.js';
-import '../../chunk-F6C6J7HK.js';
-import '../../chunk-UY4PNPBX.js';
-import '../../chunk-ELEHMJPM.js';
-import '../../chunk-HEO3XL4Z.js';
-import '../../chunk-7XUN3OQT.js';
-import '../../chunk-WR5PDOPP.js';
-import '../../chunk-VMH2LRM6.js';
-import '../../chunk-YR433ZDA.js';
-import '../../chunk-6QCXIRLA.js';
-import '../../chunk-BRFMFLR6.js';
-import '../../chunk-PNWOW52F.js';
-import '../../chunk-VZDHIOCH.js';
-import '../../chunk-S4WFNGQG.js';
-import '../../chunk-64DNBF5W.js';
-import '../../chunk-IIKTTIW5.js';
-import '../../chunk-AOHBHYF6.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map