flowcraft 1.0.0-beta.8 → 1.0.0

package/dist/chunk-WGVHM7DU.js

@@ -0,0 +1,66 @@
+import { ParallelFlow } from './chunk-L5PK5VL2.js';
+import { Node } from './chunk-HEO3XL4Z.js';
+
+// src/builder/graph/internal-nodes.ts
+var InputMappingNode = class extends Node {
+  mappings;
+  constructor(options) {
+    super();
+    const { nodeId, originalId, isSubWorkflow, ...mappings } = options.data;
+    this.mappings = mappings;
+  }
+  async prep({ ctx, logger }) {
+    for (const [subKey, parentKey] of Object.entries(this.mappings)) {
+      if (await ctx.has(parentKey)) {
+        ctx.set(subKey, await ctx.get(parentKey));
+      } else {
+        logger.warn(`[InputMapper] Input mapping failed. Key '${parentKey}' not found in context.`);
+      }
+    }
+  }
+};
+var OutputMappingNode = class extends Node {
+  mappings;
+  constructor(options) {
+    super();
+    const { nodeId, originalId, isSubWorkflow, ...mappings } = options.data;
+    this.mappings = mappings;
+  }
+  async prep({ ctx, logger }) {
+    for (const [parentKey, subKey] of Object.entries(this.mappings)) {
+      if (await ctx.has(subKey)) {
+        ctx.set(parentKey, await ctx.get(subKey));
+      } else {
+        logger.warn(`[OutputMapper] Output mapping failed. Key '${subKey}' not found in context.`);
+      }
+    }
+  }
+};
+var SubWorkflowContainerNode = class extends Node {
+  constructor() {
+    super();
+    this.isPassthrough = true;
+  }
+  async exec() {
+  }
+};
+var ParallelBranchContainer = class extends ParallelFlow {
+  /** A tag to reliably identify this node type in the visualizer. */
+  isParallelContainer = true;
+  // This is now a public, mutable property for the executor to populate.
+  nodesToRun = [];
+  constructor() {
+    super();
+    this.isPassthrough = true;
+  }
+};
+var ConditionalJoinNode = class extends Node {
+  constructor() {
+    super();
+    this.isPassthrough = true;
+  }
+};
+
+export { ConditionalJoinNode, InputMappingNode, OutputMappingNode, ParallelBranchContainer, SubWorkflowContainerNode };
+//# sourceMappingURL=chunk-WGVHM7DU.js.map
+//# sourceMappingURL=chunk-WGVHM7DU.js.map

package/dist/chunk-WGVHM7DU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/builder/graph/internal-nodes.ts"],"names":[],"mappings":";;;;AAYO,IAAM,gBAAA,GAAN,cAAmE,IAAA,CAAqC;AAAA,EACtG,QAAA;AAAA,EACR,YAAY,OAAA,EAA2C;AACtD,IAAA,KAAA,EAAM;AAEN,IAAA,MAAM,EAAE,MAAA,EAAQ,UAAA,EAAY,eAAe,GAAG,QAAA,KAAa,OAAA,CAAQ,IAAA;AACnE,IAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAAA,EACjB;AAAA,EAEA,MAAM,IAAA,CAAK,EAAE,GAAA,EAAK,QAAO,EAAwC;AAChE,IAAA,KAAA,MAAW,CAAC,QAAQ,SAAS,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,QAAQ,CAAA,EAAG;AAChE,MAAA,IAAI,MAAM,GAAA,CAAI,GAAA,CAAI,SAAS,CAAA,EAAG;AAC7B,QAAA,GAAA,CAAI,IAAI,MAAA,EAAQ,MAAM,GAAA,CAAI,GAAA,CAAI,SAAS,CAAC,CAAA;AAAA,MACzC,CAAA,MACK;AACJ,QAAA,MAAA,CAAO,IAAA,CAAK,CAAA,yCAAA,EAA4C,SAAS,CAAA,uBAAA,CAAyB,CAAA;AAAA,MAC3F;AAAA,IACD;AAAA,EACD;AACD;AAQO,IAAM,iBAAA,GAAN,cAAoE,IAAA,CAAqC;AAAA,EACvG,QAAA;AAAA,EACR,YAAY,OAAA,EAA2C;AACtD,IAAA,KAAA,EAAM;AAEN,IAAA,MAAM,EAAE,MAAA,EAAQ,UAAA,EAAY,eAAe,GAAG,QAAA,KAAa,OAAA,CAAQ,IAAA;AACnE,IAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAAA,EACjB;AAAA,EAEA,MAAM,IAAA,CAAK,EAAE,GAAA,EAAK,QAAO,EAAwC;AAChE,IAAA,KAAA,MAAW,CAAC,WAAW,MAAM,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,QAAQ,CAAA,EAAG;AAChE,MAAA,IAAI,MAAM,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA,EAAG;AAC1B,QAAA,GAAA,CAAI,IAAI,SAAA,EAAW,MAAM,GAAA,CAAI,GAAA,CAAI,MAAM,CAAC,CAAA;AAAA,MACzC,CAAA,MACK;AACJ,QAAA,MAAA,CAAO,IAAA,CAAK,CAAA,2CAAA,EAA8C,MAAM,CAAA,uBAAA,CAAyB,CAAA;AAAA,MAC1F;AAAA,IACD;AAAA,EACD;AACD;AAOO,IAAM,wBAAA,GAAN,cAA2E,IAAA,CAAqC;AAAA,EACtH,WAAA,GAAc;AACb,IAAA,KAAA,EAAM;AACN,IAAA,IAAA,CAAK,aAAA,GAAgB,IAAA;AAAA,EACtB;AAAA,EAEA,MAAM,IAAA,GAAO;AAAA,EAGb;AACD;AAGO,IAAM,uBAAA,GAAN,cAA0E,YAAA,CAAuB;AAAA;AAAA,EAEvF,mBAAA,GAAsB,IAAA;AAAA;AAAA,EAE/B,aAA6B,EAAC;AAAA,EAErC,WAAA,GAAc;AACb,IAAA,KAAA,EAAM;AAEN,IAAA,IAAA,CAAK,aAAA,GAAgB,IAAA;AAAA,EACtB;AACD;AAQO,IAAM,mBAAA,GAAN,cAAsE,IAAA,CAAqC;AAAA,EACjH,WAAA,GAAc;AACb,IAAA,KAAA,EAAM;AACN,IAAA,IAAA,CAAK,aAAA,GAAgB,IAAA;AAAA,EACtB;AACD","file":"chunk-WGVHM7DU.js","sourcesContent":["import type { Context } from '../../context'\nimport type { NodeArgs } from '../../types'\nimport type { AbstractNode } from '../../workflow/index'\nimport { Node } from '../../workflow/index'\nimport { ParallelFlow } from '../patterns'\n\n/**\n * An internal node used by the GraphBuilder to handle the `inputs` mapping\n * of an inlined sub-workflow. It copies data from the parent context scope\n * to the sub-workflow's context scope.\n * @internal\n */\nexport class InputMappingNode<TContext extends Context = Context> extends Node<void, void, any, any, TContext> {\n\tprivate mappings: Record<string, string>\n\tconstructor(options: { data: Record<string, string> }) {\n\t\tsuper()\n\t\t// Exclude the injected nodeId from the mappings\n\t\tconst { nodeId, originalId, isSubWorkflow, ...mappings } = options.data\n\t\tthis.mappings = mappings\n\t}\n\n\tasync prep({ ctx, logger }: NodeArgs<void, void, any, TContext>) {\n\t\tfor (const [subKey, parentKey] of Object.entries(this.mappings)) {\n\t\t\tif (await ctx.has(parentKey)) {\n\t\t\t\tctx.set(subKey, await ctx.get(parentKey))\n\t\t\t}\n\t\t\telse {\n\t\t\t\tlogger.warn(`[InputMapper] Input mapping failed. Key '${parentKey}' not found in context.`)\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * An internal node used by the GraphBuilder to handle the `outputs` mapping\n * of an inlined sub-workflow. It copies data from the sub-workflow's\n * context scope back to the parent's context scope.\n * @internal\n */\nexport class OutputMappingNode<TContext extends Context = Context> extends Node<void, void, any, any, TContext> {\n\tprivate mappings: Record<string, string>\n\tconstructor(options: { data: Record<string, string> }) {\n\t\tsuper()\n\t\t// Exclude the injected nodeId from the mappings\n\t\tconst { nodeId, originalId, isSubWorkflow, ...mappings } = options.data\n\t\tthis.mappings = mappings\n\t}\n\n\tasync prep({ ctx, logger }: NodeArgs<void, void, any, TContext>) {\n\t\tfor (const [parentKey, subKey] of Object.entries(this.mappings)) {\n\t\t\tif (await ctx.has(subKey)) {\n\t\t\t\tctx.set(parentKey, await ctx.get(subKey))\n\t\t\t}\n\t\t\telse {\n\t\t\t\tlogger.warn(`[OutputMapper] Output mapping failed. Key '${subKey}' not found in context.`)\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * A private class used by the builder to represent the sub-workflow container itself.\n * It's a structural node that preserves the original node ID in the flattened graph.\n * @internal\n */\nexport class SubWorkflowContainerNode<TContext extends Context = Context> extends Node<void, void, any, any, TContext> {\n\tconstructor() {\n\t\tsuper()\n\t\tthis.isPassthrough = true\n\t}\n\n\tasync exec() {\n\t\t// This node performs no work; it just acts as a stable entry point.\n\t\t// The graph wiring ensures the InputMappingNode is executed next.\n\t}\n}\n\n/** A private class used by the builder to represent parallel execution blocks. */\nexport class ParallelBranchContainer<TContext extends Context = Context> extends ParallelFlow<TContext> {\n\t/** A tag to reliably identify this node type in the visualizer. */\n\tpublic readonly isParallelContainer = true\n\t// This is now a public, mutable property for the executor to populate.\n\tpublic nodesToRun: AbstractNode[] = []\n\n\tconstructor() {\n\t\tsuper() // Call the parent constructor, which can handle an empty/no-arg state.\n\t\t// semantic flag for distributed executors.\n\t\tthis.isPassthrough = true\n\t}\n}\n\n/**\n * A private class used by the builder to unify conditional branches\n * before they connect to a common successor. This ensures the successor\n * only has one predecessor, preventing false fan-in detection.\n * @internal\n */\nexport class ConditionalJoinNode<TContext extends Context = Context> extends Node<void, void, any, any, TContext> {\n\tconstructor() {\n\t\tsuper()\n\t\tthis.isPassthrough = true // It performs no logic, just structural\n\t}\n}\n"]}

package/dist/chunk-WR5PDOPP.js

@@ -0,0 +1,91 @@
+// src/utils/analysis.ts
+function isNodeType(type) {
+  return (node) => {
+    return node.type === type;
+  };
+}
+function analyzeGraph(graph) {
+  const typedGraph = graph;
+  const analysis = {
+    nodes: /* @__PURE__ */ new Map(),
+    allNodeIds: [],
+    startNodeIds: [],
+    cycles: []
+  };
+  if (!typedGraph || !typedGraph.nodes || !typedGraph.nodes.length)
+    return analysis;
+  const allNodeIds = typedGraph.nodes.map((node) => node.id);
+  analysis.allNodeIds = allNodeIds;
+  const adj = /* @__PURE__ */ new Map();
+  typedGraph.nodes.forEach((node) => {
+    analysis.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 });
+    adj.set(node.id, []);
+  });
+  typedGraph.edges.forEach((edge) => {
+    const source = analysis.nodes.get(edge.source);
+    const target = analysis.nodes.get(edge.target);
+    if (source)
+      source.outDegree++;
+    if (target)
+      target.inDegree++;
+    if (adj.has(edge.source))
+      adj.get(edge.source).push(edge.target);
+  });
+  analysis.startNodeIds = allNodeIds.filter((id) => analysis.nodes.get(id).inDegree === 0);
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function detectCycleUtil(nodeId, path) {
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    path.push(nodeId);
+    const neighbors = adj.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      if (recursionStack.has(neighbor)) {
+        const cycleStartIndex = path.indexOf(neighbor);
+        const cycle = path.slice(cycleStartIndex);
+        analysis.cycles.push([...cycle, neighbor]);
+      } else if (!visited.has(neighbor)) {
+        detectCycleUtil(neighbor, path);
+      }
+    }
+    recursionStack.delete(nodeId);
+    path.pop();
+  }
+  for (const nodeId of allNodeIds) {
+    if (!visited.has(nodeId))
+      detectCycleUtil(nodeId, []);
+  }
+  return analysis;
+}
+function createNodeRule(filter, check) {
+  return (analysis, _graph) => {
+    const errors = [];
+    for (const node of analysis.nodes.values()) {
+      if (filter(node)) {
+        const result = check(node);
+        if (result) {
+          if (Array.isArray(result))
+            errors.push(...result);
+          else
+            errors.push(result);
+        }
+      }
+    }
+    return errors;
+  };
+}
+var checkForCycles = (analysis) => {
+  const uniqueCycles = new Set(analysis.cycles.map((c) => c.slice(0, -1).sort().join(",")));
+  return Array.from(uniqueCycles).map((cycleKey) => {
+    const representativeCycle = analysis.cycles.find((c) => c.slice(0, -1).sort().join(",") === cycleKey);
+    return {
+      nodeId: representativeCycle[0],
+      type: "CycleDetected",
+      message: `Cycle detected involving nodes: ${representativeCycle.join(" -> ")}`
+    };
+  });
+};
+
+export { analyzeGraph, checkForCycles, createNodeRule, isNodeType };
+//# sourceMappingURL=chunk-WR5PDOPP.js.map
+//# sourceMappingURL=chunk-WR5PDOPP.js.map

package/dist/chunk-WR5PDOPP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/analysis.ts"],"names":[],"mappings":"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","file":"chunk-WR5PDOPP.js","sourcesContent":["import type { GraphNode, NodeTypeMap, TypedGraphNode, TypedWorkflowGraph, WorkflowGraph } from '../builder/graph/types'\n\n/** The rich metadata object returned by the analyzeGraph function. */\nexport interface GraphAnalysis<T extends NodeTypeMap = any> {\n\t/** A map of all nodes, keyed by ID, augmented with their connection degrees. */\n\tnodes: Map<string, TypedGraphNode<T> & { inDegree: number, outDegree: number }>\n\t/** An array of all node IDs in the graph. */\n\tallNodeIds: string[]\n\t/** An array of node IDs that have no incoming edges. */\n\tstartNodeIds: string[]\n\t/** A list of cycles found in the graph. Each cycle is an array of node IDs. */\n\tcycles: string[][]\n}\n\n/** A standard structure for reporting a single validation error. */\nexport interface ValidationError {\n\t/** The ID of the node where the error occurred, if applicable. */\n\tnodeId?: string\n\t/** A category for the error, e.g., 'CycleDetected', 'ConnectionRuleViolation'. */\n\ttype: string\n\t/** A human-readable message explaining the validation failure. */\n\tmessage: string\n}\n\n/**\n * A function that takes a graph analysis and the original graph,\n * and returns an array of validation errors.\n */\nexport type Validator<T extends NodeTypeMap = any> = (\n\tanalysis: GraphAnalysis<T>,\n\tgraph: TypedWorkflowGraph<T>\n) => ValidationError[]\n\n/**\n * A helper function that creates a type guard for filtering nodes by their type.\n * This simplifies writing type-safe validation rules by removing the need for\n * verbose, explicit type guard syntax.\n *\n * @param type The literal string of the node type to check for.\n * @returns A type guard function that narrows the node to its specific type.\n */\nexport function isNodeType<T extends NodeTypeMap, K extends keyof T>(type: K) {\n\treturn (node: TypedGraphNode<T>): node is TypedGraphNode<T> & { type: K } => {\n\t\treturn node.type === type\n\t}\n}\n\n/**\n * Analyzes a declarative workflow graph definition to extract structural metadata.\n * This is a lightweight, static utility that does not instantiate any nodes.\n *\n * @param graph The WorkflowGraph object containing nodes and edges.\n * @returns A GraphAnalysis object containing nodes with degree counts, start nodes, and any cycles.\n */\n// (Typesafe Overload) Analyzes a declarative workflow graph, preserving strong types.\nexport function analyzeGraph<T extends NodeTypeMap>(graph: TypedWorkflowGraph<T>): GraphAnalysis<T>\n// (Untyped Overload) Analyzes a declarative workflow graph with basic types.\nexport function analyzeGraph(graph: WorkflowGraph): GraphAnalysis\n// (Implementation) Analyzes a declarative workflow graph to extract structural metadata.\nexport function analyzeGraph<T extends NodeTypeMap>(graph: TypedWorkflowGraph<T> | WorkflowGraph): GraphAnalysis<T> {\n\tconst typedGraph = graph as TypedWorkflowGraph<T> // Cast for internal consistency\n\tconst analysis: GraphAnalysis<T> = {\n\t\tnodes: new Map(),\n\t\tallNodeIds: [],\n\t\tstartNodeIds: [],\n\t\tcycles: [],\n\t}\n\n\tif (!typedGraph || !typedGraph.nodes || !typedGraph.nodes.length)\n\t\treturn analysis\n\n\tconst allNodeIds = typedGraph.nodes.map(node => node.id)\n\tanalysis.allNodeIds = allNodeIds\n\n\tconst adj: Map<string, string[]> = new Map()\n\ttypedGraph.nodes.forEach((node) => {\n\t\tanalysis.nodes.set(node.id, { ...node, inDegree: 0, outDegree: 0 })\n\t\tadj.set(node.id, [])\n\t})\n\n\ttypedGraph.edges.forEach((edge) => {\n\t\tconst source = analysis.nodes.get(edge.source)\n\t\tconst target = analysis.nodes.get(edge.target)\n\t\tif (source)\n\t\t\tsource.outDegree++\n\t\tif (target)\n\t\t\ttarget.inDegree++\n\t\tif (adj.has(edge.source))\n\t\t\tadj.get(edge.source)!.push(edge.target)\n\t})\n\n\tanalysis.startNodeIds = allNodeIds.filter(id => analysis.nodes.get(id)!.inDegree === 0)\n\n\tconst visited = new Set<string>()\n\tconst recursionStack = new Set<string>()\n\tfunction detectCycleUtil(nodeId: string, path: string[]) {\n\t\tvisited.add(nodeId)\n\t\trecursionStack.add(nodeId)\n\t\tpath.push(nodeId)\n\n\t\tconst neighbors = adj.get(nodeId) || []\n\t\tfor (const neighbor of neighbors) {\n\t\t\tif (recursionStack.has(neighbor)) {\n\t\t\t\tconst cycleStartIndex = path.indexOf(neighbor)\n\t\t\t\tconst cycle = path.slice(cycleStartIndex)\n\t\t\t\tanalysis.cycles.push([...cycle, neighbor])\n\t\t\t}\n\t\t\telse if (!visited.has(neighbor)) {\n\t\t\t\tdetectCycleUtil(neighbor, path)\n\t\t\t}\n\t\t}\n\n\t\trecursionStack.delete(nodeId)\n\t\tpath.pop()\n\t}\n\n\tfor (const nodeId of allNodeIds) {\n\t\tif (!visited.has(nodeId))\n\t\t\tdetectCycleUtil(nodeId, [])\n\t}\n\n\treturn analysis\n}\n\n/**\n * Factory for creating a generic, reusable validator that checks node properties.\n * A single rule can now return multiple errors for a single node.\n *\n * @param filter A predicate to select which nodes this rule applies to.\n * @param check A function that validates a selected node. It can return a single\n *   ValidationError, an array of them, or null if the node is valid.\n * @returns A Validator function.\n */\n// (Type-Safe Overload) Creates a validator with strong types based on a NodeTypeMap.\nexport function createNodeRule<T extends NodeTypeMap>(\n\tfilter: (node: TypedGraphNode<T>) => boolean,\n\tcheck: (\n\t\tnode: TypedGraphNode<T> & { inDegree: number, outDegree: number },\n\t) => ValidationError | ValidationError[] | null | undefined,\n): Validator<T>\n// (Untyped Overload) Creates a validator with basic types.\nexport function createNodeRule(\n\tfilter: (node: GraphNode) => boolean,\n\tcheck: (\n\t\tnode: GraphNode & { inDegree: number, outDegree: number },\n\t) => ValidationError | ValidationError[] | null | undefined,\n): Validator\n// (Implementation) Factory for creating a generic, reusable validator.\nexport function createNodeRule(\n\tfilter: (node: any) => boolean,\n\tcheck: (\n\t\tnode: any,\n\t) => ValidationError | ValidationError[] | null | undefined,\n): Validator {\n\treturn (analysis: GraphAnalysis, _graph: WorkflowGraph): ValidationError[] => {\n\t\tconst errors: ValidationError[] = []\n\t\tfor (const node of analysis.nodes.values()) {\n\t\t\tif (filter(node)) {\n\t\t\t\tconst result = check(node)\n\t\t\t\tif (result) {\n\t\t\t\t\tif (Array.isArray(result))\n\t\t\t\t\t\terrors.push(...result)\n\t\t\t\t\telse\n\t\t\t\t\t\terrors.push(result)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn errors\n\t}\n}\n\n/**\n * A built-in validator that reports any cycles found in the graph.\n */\nexport const checkForCycles: Validator = (analysis) => {\n\tconst uniqueCycles = new Set(analysis.cycles.map(c => c.slice(0, -1).sort().join(',')))\n\treturn Array.from(uniqueCycles).map((cycleKey) => {\n\t\tconst representativeCycle = analysis.cycles.find(c => c.slice(0, -1).sort().join(',') === cycleKey)!\n\t\treturn {\n\t\t\tnodeId: representativeCycle[0],\n\t\t\ttype: 'CycleDetected',\n\t\t\tmessage: `Cycle detected involving nodes: ${representativeCycle.join(' -> ')}`,\n\t\t}\n\t})\n}\n"]}

package/dist/chunk-YR433ZDA.js

@@ -0,0 +1,20 @@
+// src/utils/sanitize.ts
+function sanitizeGraph(rawGraph) {
+  const nodes = rawGraph.nodes.map(({ id, type, data, config }) => ({
+    id,
+    type,
+    data,
+    ...config && { config }
+  }));
+  const edges = rawGraph.edges.map(({ id, source, target, action }) => ({
+    id,
+    source,
+    target,
+    ...action && { action }
+  }));
+  return { nodes, edges };
+}
+
+export { sanitizeGraph };
+//# sourceMappingURL=chunk-YR433ZDA.js.map
+//# sourceMappingURL=chunk-YR433ZDA.js.map

package/dist/chunk-YR433ZDA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/sanitize.ts"],"names":[],"mappings":";AAWO,SAAS,cAAc,QAAA,EAAyD;AACtF,EAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,KAAA,CAAM,GAAA,CAAI,CAAC,EAAE,EAAA,EAAI,IAAA,EAAM,IAAA,EAAM,MAAA,EAAO,MAAO;AAAA,IACjE,EAAA;AAAA,IACA,IAAA;AAAA,IACA,IAAA;AAAA,IACA,GAAI,MAAA,IAAU,EAAE,MAAA;AAAO,GACxB,CAAE,CAAA;AAEF,EAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,KAAA,CAAM,GAAA,CAAI,CAAC,EAAE,EAAA,EAAI,MAAA,EAAQ,MAAA,EAAQ,MAAA,EAAO,MAAO;AAAA,IACrE,EAAA;AAAA,IACA,MAAA;AAAA,IACA,MAAA;AAAA,IACA,GAAI,MAAA,IAAU,EAAE,MAAA;AAAO,GACxB,CAAE,CAAA;AAEF,EAAA,OAAO,EAAE,OAAO,KAAA,EAAM;AACvB","file":"chunk-YR433ZDA.js","sourcesContent":["import type { WorkflowGraph } from '../builder/graph/types'\n\n/**\n * Sanitizes a raw workflow graph object by removing properties that are not\n * relevant to the execution engine, such as UI-specific data.\n *\n * @param rawGraph - The raw graph object, potentially containing extraneous properties.\n * @param rawGraph.nodes - An array of node objects.\n * @param rawGraph.edges - An array of edge objects.\n * @returns A clean, execution-focused `WorkflowGraph` object.\n */\nexport function sanitizeGraph(rawGraph: { nodes: any[], edges: any[] }): WorkflowGraph {\n\tconst nodes = rawGraph.nodes.map(({ id, type, data, config }) => ({\n\t\tid,\n\t\ttype,\n\t\tdata,\n\t\t...(config && { config }),\n\t}))\n\n\tconst edges = rawGraph.edges.map(({ id, source, target, action }) => ({\n\t\tid,\n\t\tsource,\n\t\ttarget,\n\t\t...(action && { action }),\n\t}))\n\n\treturn { nodes, edges }\n}\n"]}

package/dist/context.d.ts

@@ -0,0 +1,113 @@
+/**
+ * A type-safe, opaque key for storing and retrieving values from the Context.
+ * Using a `ContextKey` provides compile-time safety for your workflow's state.
+ * @template T The type of the value this key refers to.
+ */
+type ContextKey<T> = symbol & {
+    __type: T;
+};
+/**
+ * Creates a new, unique `ContextKey` for type-safe access to the `Context`.
+ * @template T The type of the value this key will hold.
+ * @param description An optional description for debugging purposes (e.g., in logs or test snapshots).
+ * @returns A unique `ContextKey<T>`.
+ */
+declare const contextKey: <T>(description?: string) => ContextKey<T>;
+/**
+ * Defines the interface for the shared context object passed through the workflow.
+ * This interface is "async-aware", allowing for both synchronous (Map-based)
+ * and asynchronous (e.g., Redis-backed) implementations.
+ */
+interface Context {
+    /**
+     * Asynchronously retrieves a value from the context.
+     * Callers should ALWAYS `await` the result of this method.
+     */
+    get: (<T>(key: ContextKey<T>) => Promise<T | undefined>) & (<T = any>(key: string) => Promise<T | undefined>);
+    /** Asynchronously stores a value in the context. */
+    set: (<T>(key: ContextKey<T>, value: T) => Promise<this>) & ((key: string, value: any) => Promise<this>);
+    /** Asynchronously checks if a key exists in the context. */
+    has: ((key: ContextKey<any>) => Promise<boolean>) & ((key: string) => Promise<boolean>);
+    /** Asynchronously deletes a key from the context. */
+    delete: ((key: ContextKey<any>) => Promise<boolean>) & ((key: string) => Promise<boolean>);
+    /**
+     * Returns an iterator of all [key, value] pairs in the context.
+     * NOTE: This may not be supported or may be inefficient in some async implementations.
+     */
+    entries: () => IterableIterator<[any, any]>;
+    /**
+     * Returns an iterator of all keys in the context.
+     * NOTE: This may not be supported or may be inefficient in some async implementations.
+     */
+    keys: () => IterableIterator<any>;
+    /**
+     * Returns an iterator of all values in the context.
+     * NOTE: This may not be supported or may be inefficient in some async implementations.
+     */
+    values: () => IterableIterator<any>;
+}
+/**
+ * The default, `Map`-based implementation of the `Context` interface.
+ * Its methods are async to satisfy the `Context` interface, but they wrap
+ * synchronous operations.
+ */
+declare class TypedContext implements Context {
+    private data;
+    /**
+     * @param initialData An optional iterable (like an array of `[key, value]` pairs)
+     * to initialize the context with.
+     */
+    constructor(initialData?: Iterable<readonly [ContextKey<any> | string, any]> | null);
+    get(key: ContextKey<any> | string): Promise<any>;
+    set(key: ContextKey<any> | string, value: any): Promise<this>;
+    has(key: ContextKey<any> | string): Promise<boolean>;
+    delete(key: ContextKey<any> | string): Promise<boolean>;
+    entries(): IterableIterator<[any, any]>;
+    keys(): IterableIterator<any>;
+    values(): IterableIterator<any>;
+}
+/** A function that takes a `Context` and returns a (potentially new) `Context`. */
+type ContextTransform = (ctx: Context) => Context | Promise<Context>;
+/**
+ * A "lens" provides a way to "focus" on a single key in the `Context`,
+ * creating reusable, type-safe async functions to get, set, or update its value.
+ * @template T The type of the value the lens focuses on.
+ */
+interface ContextLens<T> {
+    /** Asynchronously retrieves the value for the key from the context. */
+    get: (ctx: Context) => Promise<T | undefined>;
+    /** Returns an asynchronous `ContextTransform` function that will set the key to the provided value. */
+    set: (value: T) => ContextTransform;
+    /** Returns an asynchronous `ContextTransform` function that updates the key's value based on its current value. */
+    update: (fn: (current: T | undefined) => T) => ContextTransform;
+}
+/**
+ * Creates a `ContextLens` object for a specific `ContextKey`.
+ * This is the entry point for functional context manipulation.
+ * All operations that read from the context are now async.
+ *
+ * @example
+ * const NAME = contextKey<string>('name')
+ * const nameLens = lens(NAME)
+ *
+ * // Usage in an async function:
+ * async function exampleUsage(ctx: Context) {
+ *   const currentName = await nameLens.get(ctx);
+ *   const setNameTransform = nameLens.set('Alice');
+ *   await setNameTransform(ctx);
+ * }
+ *
+ * @param key The `ContextKey` to focus on.
+ * @returns A `ContextLens<T>` object with async-aware methods.
+ */
+declare function lens<T>(key: ContextKey<T>): ContextLens<T>;
+/**
+ * Composes multiple `ContextTransform` functions into a single `ContextTransform` function.
+ * The transformations are applied in the order they are provided.
+ *
+ * @param transforms A sequence of `ContextTransform` functions.
+ * @returns A single function that applies all transformations.
+ */
+declare function composeContext(...transforms: ContextTransform[]): ContextTransform;
+
+export { type Context, type ContextKey, type ContextLens, type ContextTransform, TypedContext, composeContext, contextKey, lens };

package/dist/context.js

@@ -0,0 +1,3 @@
+export { TypedContext, composeContext, contextKey, lens } from './chunk-R27FIYR5.js';
+//# sourceMappingURL=context.js.map
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

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

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Error thrown when a workflow is gracefully aborted via an `AbortSignal`.
+ * This error is caught by the execution engine to halt the flow.
+ */
+declare class AbortError extends Error {
+    constructor(message?: string);
+}
+/**
+ * A custom error class for failures within a workflow, providing additional
+ * context about where and when the error occurred.
+ */
+declare class WorkflowError extends Error {
+    readonly nodeName: string;
+    readonly phase: 'prep' | 'exec' | 'post';
+    readonly originalError?: Error;
+    /**
+     * @param message The error message.
+     * @param nodeName The name of the `Node` class where the error occurred.
+     * @param phase The lifecycle phase (`'prep'`, `'exec'`, or `'post'`) where the error was thrown.
+     * @param originalError The underlying error that was caught and wrapped.
+     */
+    constructor(message: string, nodeName: string, phase: 'prep' | 'exec' | 'post', originalError?: Error);
+}
+/**
+ * An error thrown by a node to indicate a non-recoverable failure.
+ *
+ * When an executor catches this error, it should immediately terminate the
+ * entire workflow run, bypassing any remaining retries, fallbacks, or
+ * subsequent nodes in the graph.
+ */
+declare class FatalWorkflowError extends WorkflowError {
+    constructor(message: string, nodeName: string, phase: 'prep' | 'exec' | 'post', originalError?: Error);
+}
+
+export { AbortError, FatalWorkflowError, WorkflowError };

package/dist/errors.js

@@ -0,0 +1,3 @@
+export { AbortError, FatalWorkflowError, WorkflowError } from './chunk-64DNBF5W.js';
+//# sourceMappingURL=errors.js.map
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/executors/in-memory.d.ts

@@ -0,0 +1,39 @@
+import { Context } from '../context.js';
+import { I as IExecutor, A as AbstractNode, e as Middleware, p as InternalRunOptions, F as Flow, R as RunOptions } from '../types-U76Ukj96.js';
+import '../logger.js';
+
+/**
+ * The default executor that runs a workflow within a single, in-memory process.
+ * This class contains the core logic for traversing a workflow graph, applying middleware,
+ * and handling node execution.
+ */
+declare class InMemoryExecutor implements IExecutor {
+    /**
+     * A stateless, reusable method that orchestrates the traversal of a graph.
+     * It is called by `run()` for top-level flows and by `Flow.exec()` for sub-flows.
+     * @param startNode The node where the graph traversal begins.
+     * @param flowMiddleware The middleware array from the containing flow.
+     * @param context The shared workflow context.
+     * @param options The internal, normalized run options.
+     * @returns The final action from the last executed node in the graph.
+     * @internal
+     */
+    _orch<T = any>(startNode: AbstractNode, flowMiddleware: Middleware[], context: Context, options: InternalRunOptions): Promise<T>;
+    /**
+     * Executes a given flow with a specific context and options.
+     * This is the main entry point for the in-memory execution engine.
+     * @param flow The Flow instance to execute.
+     * @param context The shared context for the workflow.
+     * @param options Runtime options, including a logger, abort controller, or initial params.
+     * @returns A promise that resolves with the final action of the workflow.
+     */
+    run<T>(flow: Flow<any, T>, context: Context, options?: RunOptions): Promise<T>;
+    run(flow: Flow, context: Context, options?: RunOptions): Promise<any>;
+    /**
+     * Determines the next node to execute based on the action returned by the current node.
+     * @internal
+     */
+    getNextNode(curr: AbstractNode, action: any): AbstractNode | undefined;
+}
+
+export { InMemoryExecutor };

package/dist/executors/in-memory.js

@@ -0,0 +1,6 @@
+export { InMemoryExecutor } from '../chunk-BRFMFLR6.js';
+import '../chunk-PNWOW52F.js';
+import '../chunk-64DNBF5W.js';
+import '../chunk-IIKTTIW5.js';
+//# sourceMappingURL=in-memory.js.map
+//# sourceMappingURL=in-memory.js.map

package/dist/executors/in-memory.js.map

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

package/dist/executors/types.d.ts

@@ -0,0 +1,3 @@
+import '../context.js';
+import '../logger.js';
+export { I as IExecutor, p as InternalRunOptions } from '../types-U76Ukj96.js';

package/dist/executors/types.js

@@ -0,0 +1,3 @@
+import '../chunk-TS3M7MWA.js';
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/executors/types.js.map

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

package/dist/functions.d.ts

@@ -0,0 +1,88 @@
+import { Context, ContextTransform } from './context.js';
+import { P as Params, N as Node, F as Flow } from './types-U76Ukj96.js';
+import './logger.js';
+
+/**
+ * A type for a pure function that can be executed within a `Node`,
+ * typically taking the node's `params` as input.
+ * @template TIn The input type, corresponding to `params`.
+ * @template TOut The output type, which becomes the node's `execRes`.
+ */
+type NodeFunction<TIn = any, TOut = any> = (input: TIn) => TOut | Promise<TOut>;
+/**
+ * A type for a function that operates on the shared `Context` in addition
+ * to the node's `params`.
+ * @template TIn The input type, corresponding to `params`.
+ * @template TOut The output type, which becomes the node's `execRes`.
+ */
+type ContextFunction<TIn = any, TOut = any, TContext extends Context = Context> = (ctx: TContext, input: TIn) => TOut | Promise<TOut>;
+/**
+ * Creates a `Node` from a simple, pure function that transforms an input to an output.
+ * The node's `params` object is passed as the input to the function.
+ *
+ * @example
+ * const add = (n: number) => mapNode<{ value: number }, number>(params => params.value + n)
+ * const add5Node = add(5) // A reusable node that adds 5 to its input parameter.
+ *
+ * @param fn A function that takes an input object and returns a result.
+ * @returns A new `Node` instance that wraps the function.
+ */
+declare function mapNode<TIn extends Params, TOut, TContext extends Context = Context>(fn: NodeFunction<TIn, TOut>): Node<void, TOut, any, TIn, TContext>;
+/**
+ * Creates a `Node` from a function that requires access to the shared `Context`.
+ * Both the `Context` and the node's `params` are passed as arguments to the function.
+ *
+ * @example
+ * const greeter = contextNode(async (ctx, params: { name: string }) => {
+ *   const language = await ctx.get(LANGUAGE_KEY) || 'en'
+ *   return language === 'en' ? `Hello, ${params.name}` : `Hola, ${params.name}`
+ * })
+ *
+ * @param fn A function that takes the context and an input object, and returns a result.
+ * @returns A new `Node` instance that wraps the function.
+ */
+declare function contextNode<TIn extends Params, TOut, TContext extends Context = Context>(fn: ContextFunction<TIn, TOut, TContext>): Node<void, TOut, any, TIn, TContext>;
+/**
+ * Creates a `Node` that declaratively applies a series of transformations to the `Context`.
+ * This is a "side-effect" node used purely for state management; its logic runs in the `prep` phase,
+ * and it does not produce an `exec` output.
+ *
+ * @example
+ * const USER_ID = contextKey<string>('user_id')
+ * const userLens = lens(USER_ID)
+ * const setupUserContext = (userId: string) => transformNode(userLens.set(userId))
+ *
+ * @param transforms A sequence of `ContextTransform` functions (e.g., from a lens) to apply.
+ * @returns A new `Node` instance that will mutate the context when executed.
+ */
+declare function transformNode<TContext extends Context = Context>(...transforms: ContextTransform[]): Node<void, void, any, Params, TContext>;
+/**
+ * A functional-style alias for `SequenceFlow`. It constructs a linear workflow
+ * where each node executes in the order it is provided.
+ *
+ * @example
+ * const mathPipeline = pipeline(addNode(5), multiplyNode(2))
+ *
+ * @param nodes A sequence of `Node` instances to chain together.
+ * @returns A `Flow` instance representing the linear sequence.
+ */
+declare function pipeline<TContext extends Context = Context>(...nodes: Node<any, any, any, any, TContext>[]): Flow<any, any, Params, TContext>;
+/**
+ * A classic functional composition utility. It takes two functions, `f` and `g`,
+ * and returns a new function that computes `f(g(x))`.
+ *
+ * This is a general-purpose helper, not a `Node` builder itself, but it can be
+ * used to create more complex `NodeFunction`s to pass to `mapNode`.
+ *
+ * @example
+ * const add5 = (x: number) => x + 5
+ * const multiply2 = (x: number) => x * 2
+ * const add5ThenMultiply2 = compose(multiply2, add5) // equivalent to: x => (x + 5) * 2
+ *
+ * @param f The outer function, which receives the result of `g`.
+ * @param g The inner function, which receives the initial input.
+ * @returns A new `NodeFunction` that combines both operations.
+ */
+declare function compose<A, B, C>(f: NodeFunction<B, C>, g: NodeFunction<A, B>): NodeFunction<A, C>;
+
+export { type ContextFunction, type NodeFunction, compose, contextNode, mapNode, pipeline, transformNode };

package/dist/functions.js

@@ -0,0 +1,21 @@
+export { compose, contextNode, mapNode, pipeline, transformNode } from './chunk-P3RPDZHO.js';
+import './chunk-R27FIYR5.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=functions.js.map
+//# sourceMappingURL=functions.js.map

package/dist/functions.js.map

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