flowcraft 1.0.0 → 2.1.0

package/dist/index.js

@@ -1,27 +1,19 @@
-import './chunk-TS3M7MWA.js';
-export { compose, contextNode, mapNode, pipeline, transformNode } from './chunk-P3RPDZHO.js';
-export { TypedContext, composeContext, contextKey, lens } from './chunk-R27FIYR5.js';
-import './chunk-F2RSES6P.js';
-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';
-export { BatchFlow, ParallelBatchFlow, ParallelFlow, SequenceFlow, filterCollection, mapCollection, reduceCollection } from './chunk-L5PK5VL2.js';
-import './chunk-F6C6J7HK.js';
-export { Flow } from './chunk-UY4PNPBX.js';
-export { ExecNode, PostNode, PreNode } from './chunk-ELEHMJPM.js';
-export { Node } from './chunk-HEO3XL4Z.js';
-import './chunk-7XUN3OQT.js';
-export { analyzeGraph, checkForCycles, createNodeRule, isNodeType } from './chunk-WR5PDOPP.js';
-export { generateMermaidFromBlueprint, generateMermaidGraph } from './chunk-VMH2LRM6.js';
-export { sanitizeGraph } from './chunk-YR433ZDA.js';
-export { sleep } from './chunk-6QCXIRLA.js';
-export { InMemoryExecutor } from './chunk-BRFMFLR6.js';
-export { applyMiddleware } from './chunk-PNWOW52F.js';
-export { AbstractNode } from './chunk-VZDHIOCH.js';
-import './chunk-S4WFNGQG.js';
-export { AbortError, FatalWorkflowError, WorkflowError } from './chunk-64DNBF5W.js';
-export { ConsoleLogger, NullLogger } from './chunk-IIKTTIW5.js';
-export { DEFAULT_ACTION, FILTER_FAILED } from './chunk-AOHBHYF6.js';
+import './chunk-55J6XMHW.js';
+import './chunk-HMR2GEGE.js';
+export { BaseDistributedAdapter } from './chunk-5EHIPX23.js';
+export { FlowRuntime } from './chunk-CO5BTPKI.js';
+export { WorkflowState } from './chunk-CSZ6EOWG.js';
+export { GraphTraverser } from './chunk-UMXW3TCY.js';
+export { sanitizeBlueprint } from './chunk-DSYAC4WB.js';
+import './chunk-CYHZ2YVH.js';
+export { BuiltInNodeExecutor, ClassNodeExecutor, FunctionNodeExecutor } from './chunk-QRMUKDSP.js';
+export { AsyncContextView, Context } from './chunk-KWQHFT7E.js';
+export { CancelledWorkflowError, FatalNodeExecutionError, NodeExecutionError } from './chunk-5ZXV3R5D.js';
+export { PropertyEvaluator, UnsafeEvaluator } from './chunk-PH2IYZHV.js';
+export { Flow, createFlow } from './chunk-5ZWYSKMH.js';
+export { BaseNode, isNodeClass } from './chunk-5QMPFUKA.js';
+export { lintBlueprint } from './chunk-UETC63DP.js';
+export { analyzeBlueprint, checkForCycles, generateMermaid } from './chunk-HN72TZY5.js';
+export { ConsoleLogger, NullLogger } from './chunk-4PELJWF7.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/linter.d.ts

@@ -0,0 +1,24 @@
+import { W as WorkflowBlueprint, d as NodeFunction, e as NodeClass } from './types-lG3xCzp_.js';
+
+type LinterIssueCode = 'INVALID_EDGE_SOURCE' | 'INVALID_EDGE_TARGET' | 'MISSING_NODE_IMPLEMENTATION' | 'ORPHAN_NODE';
+interface LinterIssue {
+    code: LinterIssueCode;
+    message: string;
+    nodeId?: string;
+    relatedId?: string;
+}
+interface LinterResult {
+    isValid: boolean;
+    issues: LinterIssue[];
+}
+/**
+ * Statically analyzes a workflow blueprint against a registry of implementations
+ * to find common errors before runtime.
+ *
+ * @param blueprint The WorkflowBlueprint to analyze.
+ * @param registry A map of node implementations (functions or classes) to check against.
+ * @returns A LinterResult object containing any issues found.
+ */
+declare function lintBlueprint(blueprint: WorkflowBlueprint, registry: Map<string, NodeFunction | NodeClass> | Record<string, NodeFunction | NodeClass>): LinterResult;
+
+export { type LinterIssue, type LinterIssueCode, type LinterResult, lintBlueprint };

package/dist/linter.js

@@ -0,0 +1,4 @@
+export { lintBlueprint } from './chunk-UETC63DP.js';
+import './chunk-HN72TZY5.js';
+//# sourceMappingURL=linter.js.map
+//# sourceMappingURL=linter.js.map

package/dist/linter.js.map

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

package/dist/logger.d.ts

@@ -1,43 +1,18 @@
-/**
- * Defines the interface for a logger that can be used by the workflow engine.
- * This allows for plugging in any logging library (e.g., Pino, Winston).
- */
-interface Logger {
-    debug: (message: string, context?: object) => void;
-    info: (message: string, context?: object) => void;
-    warn: (message: string, context?: object) => void;
-    error: (message: string, context?: object) => void;
-}
-/**
- * A logger implementation that performs no action (a "no-op" logger).
- * This is the default logger used by the framework if none is provided,
- * making Flowcraft silent out-of-the-box.
- */
-declare class NullLogger implements Logger {
-    debug(): void;
-    info(): void;
-    warn(): void;
-    error(): void;
+import { l as ILogger } from './types-lG3xCzp_.js';
+
+/** A logger implementation that outputs to the console. */
+declare class ConsoleLogger implements 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;
 }
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-/**
- * A default logger implementation that writes messages to the `console`.
- * It supports a minimum log level to control verbosity.
- */
-declare class ConsoleLogger implements Logger {
-    private minLevel;
-    /**
-     * @param options Configuration for the logger.
-     * @param options.level The minimum level of messages to log. Defaults to 'info'.
-     */
-    constructor(options?: {
-        level?: LogLevel;
-    });
-    private log;
-    debug(message: string, context?: object): void;
-    info(message: string, context?: object): void;
-    warn(message: string, context?: object): void;
-    error(message: string, context?: object): void;
+/** A logger implementation that does nothing (no-op). */
+declare class NullLogger implements 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;
 }
 
-export { ConsoleLogger, type Logger, NullLogger };
+export { ConsoleLogger, NullLogger };

package/dist/logger.js

@@ -1,3 +1,3 @@
-export { ConsoleLogger, NullLogger } from './chunk-IIKTTIW5.js';
+export { ConsoleLogger, NullLogger } from './chunk-4PELJWF7.js';
 //# sourceMappingURL=logger.js.map
 //# sourceMappingURL=logger.js.map

package/dist/node.d.ts

@@ -0,0 +1 @@
+export { B as BaseNode, i as isNodeClass } from './types-lG3xCzp_.js';

package/dist/node.js

@@ -0,0 +1,3 @@
+export { BaseNode, isNodeClass } from './chunk-5QMPFUKA.js';
+//# sourceMappingURL=node.js.map
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

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

package/dist/runtime/adapter.d.ts

@@ -0,0 +1,94 @@
+import { j as RuntimeOptions, n as ISerializer, h as IAsyncContext, p as WorkflowResult, W as WorkflowBlueprint } from '../types-lG3xCzp_.js';
+import { FlowRuntime } from './runtime.js';
+import './state.js';
+import './types.js';
+
+/**
+ * Defines the contract for an atomic, distributed key-value store required by
+ * the adapter for coordination tasks like fan-in joins and locking.
+ */
+interface ICoordinationStore {
+    /** Atomically increments a key and returns the new value. Ideal for 'all' joins. */
+    increment: (key: string, ttlSeconds: number) => Promise<number>;
+    /** Sets a key only if it does not already exist. Ideal for 'any' joins (locking). */
+    setIfNotExist: (key: string, value: string, ttlSeconds: number) => Promise<boolean>;
+    /** Deletes a key. Used for cleanup. */
+    delete: (key: string) => Promise<void>;
+}
+/** Configuration options for constructing a BaseDistributedAdapter. */
+interface AdapterOptions {
+    runtimeOptions: RuntimeOptions<any>;
+    coordinationStore: ICoordinationStore;
+}
+/** The data payload expected for a job in the queue. */
+interface JobPayload {
+    runId: string;
+    blueprintId: string;
+    nodeId: string;
+}
+/**
+ * The base class for all distributed adapters. It handles the technology-agnostic
+ * orchestration logic and leaves queue-specific implementation to subclasses.
+ */
+declare abstract class BaseDistributedAdapter {
+    protected readonly runtime: FlowRuntime<any, any>;
+    protected readonly store: ICoordinationStore;
+    protected readonly serializer: ISerializer;
+    constructor(options: AdapterOptions);
+    /**
+     * Starts the worker, which begins listening for and processing jobs from the queue.
+     */
+    start(): void;
+    /**
+     * Creates a technology-specific distributed context for a given workflow run.
+     * @param runId The unique ID for the workflow execution.
+     */
+    protected abstract createContext(runId: string): IAsyncContext<Record<string, any>>;
+    /**
+     * Sets up the listener for the message queue. The implementation should call the
+     * provided `handler` function for each new job received.
+     * @param handler The core logic to execute for each job.
+     */
+    protected abstract processJobs(handler: (job: JobPayload) => Promise<void>): void;
+    /**
+     * Enqueues a new job onto the message queue.
+     * @param job The payload for the job to be enqueued.
+     */
+    protected abstract enqueueJob(job: JobPayload): Promise<void>;
+    /**
+     * Publishes the final result of a completed or failed workflow run.
+     * @param runId The unique ID of the workflow run.
+     * @param result The final status and payload of the workflow.
+     */
+    protected abstract publishFinalResult(runId: string, result: {
+        status: 'completed' | 'failed';
+        payload?: WorkflowResult;
+        reason?: string;
+    }): Promise<void>;
+    /**
+     * Hook called at the start of job processing. Subclasses can override this
+     * to perform additional setup (e.g., timestamp tracking for reconciliation).
+     */
+    protected onJobStart(_runId: string, _blueprintId: string, _nodeId: string): Promise<void>;
+    /**
+     * The main handler for processing a single job from the queue.
+     */
+    protected handleJob(job: JobPayload): Promise<void>;
+    /**
+     * Encapsulates the fan-in join logic using the coordination store.
+     */
+    protected isReadyForFanIn(runId: string, blueprint: WorkflowBlueprint, targetNodeId: string): Promise<boolean>;
+    /**
+     * Reconciles the state of a workflow run. It inspects the persisted
+     * context to find completed nodes, determines the next set of executable
+     * nodes (the frontier), and enqueues jobs for them if they aren't
+     * already running. This is the core of the resume functionality.
+     *
+     * @param runId The unique ID of the workflow execution to reconcile.
+     * @returns The set of node IDs that were enqueued for execution.
+     */
+    reconcile(runId: string): Promise<Set<string>>;
+    private calculateResumedFrontier;
+}
+
+export { type AdapterOptions, BaseDistributedAdapter, type ICoordinationStore, type JobPayload };

package/dist/runtime/adapter.js

@@ -0,0 +1,15 @@
+export { BaseDistributedAdapter } from '../chunk-5EHIPX23.js';
+import '../chunk-CO5BTPKI.js';
+import '../chunk-CSZ6EOWG.js';
+import '../chunk-UMXW3TCY.js';
+import '../chunk-DSYAC4WB.js';
+import '../chunk-CYHZ2YVH.js';
+import '../chunk-QRMUKDSP.js';
+import '../chunk-KWQHFT7E.js';
+import '../chunk-5ZXV3R5D.js';
+import '../chunk-PH2IYZHV.js';
+import '../chunk-5QMPFUKA.js';
+import '../chunk-HN72TZY5.js';
+import '../chunk-4PELJWF7.js';
+//# sourceMappingURL=adapter.js.map
+//# sourceMappingURL=adapter.js.map

package/dist/runtime/adapter.js.map

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

package/dist/runtime/executors.d.ts

@@ -0,0 +1,26 @@
+import { N as NodeDefinition, c as NodeContext, b as NodeResult, d as NodeFunction, m as IEventBus, e as NodeClass, C as ContextImplementation } from '../types-lG3xCzp_.js';
+
+interface ExecutionStrategy {
+    execute: (nodeDef: NodeDefinition, context: NodeContext<any, any, any>, executionId?: string, signal?: AbortSignal) => Promise<NodeResult<any, any>>;
+}
+declare class FunctionNodeExecutor implements ExecutionStrategy {
+    private implementation;
+    private maxRetries;
+    private eventBus;
+    constructor(implementation: NodeFunction, maxRetries: number, eventBus: IEventBus);
+    execute(nodeDef: NodeDefinition, context: NodeContext<any, any, any>, executionId?: string, signal?: AbortSignal): Promise<NodeResult<any, any>>;
+}
+declare class ClassNodeExecutor implements ExecutionStrategy {
+    private implementation;
+    private maxRetries;
+    private eventBus;
+    constructor(implementation: NodeClass, maxRetries: number, eventBus: IEventBus);
+    execute(nodeDef: NodeDefinition, context: NodeContext<any, any, any>, executionId?: string, signal?: AbortSignal): Promise<NodeResult<any, any>>;
+}
+declare class BuiltInNodeExecutor implements ExecutionStrategy {
+    private executeBuiltIn;
+    constructor(executeBuiltIn: (nodeDef: NodeDefinition, context: ContextImplementation<any>) => Promise<NodeResult<any, any>>);
+    execute(nodeDef: NodeDefinition, context: NodeContext<Record<string, unknown>, Record<string, unknown>, any>): Promise<NodeResult<any, any>>;
+}
+
+export { BuiltInNodeExecutor, ClassNodeExecutor, type ExecutionStrategy, FunctionNodeExecutor };

package/dist/runtime/executors.js

@@ -0,0 +1,4 @@
+export { BuiltInNodeExecutor, ClassNodeExecutor, FunctionNodeExecutor } from '../chunk-QRMUKDSP.js';
+import '../chunk-5ZXV3R5D.js';
+//# sourceMappingURL=executors.js.map
+//# sourceMappingURL=executors.js.map

package/dist/runtime/executors.js.map

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

package/dist/runtime/index.d.ts

@@ -0,0 +1,7 @@
+export { AdapterOptions, BaseDistributedAdapter, ICoordinationStore, JobPayload } from './adapter.js';
+export { BuiltInNodeExecutor, ClassNodeExecutor, ExecutionStrategy, FunctionNodeExecutor } from './executors.js';
+export { FlowRuntime } from './runtime.js';
+export { WorkflowState } from './state.js';
+export { GraphTraverser } from './traverser.js';
+import '../types-lG3xCzp_.js';
+import './types.js';

package/dist/runtime/index.js

@@ -0,0 +1,16 @@
+import '../chunk-HMR2GEGE.js';
+export { BaseDistributedAdapter } from '../chunk-5EHIPX23.js';
+export { FlowRuntime } from '../chunk-CO5BTPKI.js';
+export { WorkflowState } from '../chunk-CSZ6EOWG.js';
+export { GraphTraverser } from '../chunk-UMXW3TCY.js';
+import '../chunk-DSYAC4WB.js';
+import '../chunk-CYHZ2YVH.js';
+export { BuiltInNodeExecutor, ClassNodeExecutor, FunctionNodeExecutor } from '../chunk-QRMUKDSP.js';
+import '../chunk-KWQHFT7E.js';
+import '../chunk-5ZXV3R5D.js';
+import '../chunk-PH2IYZHV.js';
+import '../chunk-5QMPFUKA.js';
+import '../chunk-HN72TZY5.js';
+import '../chunk-4PELJWF7.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,34 @@
+import { j as RuntimeOptions, W as WorkflowBlueprint, p as WorkflowResult, b as NodeResult, C as ContextImplementation, N as NodeDefinition, E as EdgeDefinition } from '../types-lG3xCzp_.js';
+import { WorkflowState } from './state.js';
+import { IRuntime } from './types.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;
+        concurrency?: number;
+    }): 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<any, any>>;
+    private getExecutor;
+    private executeWithFallback;
+    determineNextNodes(blueprint: WorkflowBlueprint, nodeId: string, result: NodeResult<any, any>, context: ContextImplementation<TContext>): Promise<{
+        node: NodeDefinition;
+        edge: EdgeDefinition;
+    }[]>;
+    applyEdgeTransform(edge: EdgeDefinition, sourceResult: NodeResult<any, any>, targetNode: NodeDefinition, context: ContextImplementation<TContext>, allPredecessors?: Map<string, Set<string>>): Promise<void>;
+    private _resolveNodeInput;
+    protected _executeBuiltInNode(nodeDef: NodeDefinition, contextImpl: ContextImplementation<TContext>): Promise<NodeResult<any, any>>;
+}
+
+export { FlowRuntime };

package/dist/runtime/runtime.js

@@ -0,0 +1,14 @@
+export { FlowRuntime } from '../chunk-CO5BTPKI.js';
+import '../chunk-CSZ6EOWG.js';
+import '../chunk-UMXW3TCY.js';
+import '../chunk-DSYAC4WB.js';
+import '../chunk-CYHZ2YVH.js';
+import '../chunk-QRMUKDSP.js';
+import '../chunk-KWQHFT7E.js';
+import '../chunk-5ZXV3R5D.js';
+import '../chunk-PH2IYZHV.js';
+import '../chunk-5QMPFUKA.js';
+import '../chunk-HN72TZY5.js';
+import '../chunk-4PELJWF7.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-lG3xCzp_.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-CSZ6EOWG.js';
+import '../chunk-KWQHFT7E.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,25 @@
+import { W as WorkflowBlueprint } from '../types-lG3xCzp_.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 runtime;
+    private state;
+    private functionRegistry;
+    private executionId;
+    private signal?;
+    private concurrency?;
+    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, concurrency?: number | undefined);
+    private isFallbackNode;
+    traverse(): Promise<void>;
+    private executeWithConcurrency;
+    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-UMXW3TCY.js';
+import '../chunk-5ZXV3R5D.js';
+import '../chunk-HN72TZY5.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-lG3xCzp_.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-lG3xCzp_.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-DSYAC4WB.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,16 @@
+import { n as ISerializer } from './types-lG3xCzp_.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 {
+    private hasWarned;
+    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-CYHZ2YVH.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"}