flowcraft 1.0.0 → 2.1.0

package/dist/builder/patterns.d.ts

@@ -1,136 +0,0 @@
-import { Context } from '../context.js';
-import { NodeFunction } from '../functions.js';
-import { F as Flow, P as Params, A as AbstractNode, b as NodeArgs } from '../types-U76Ukj96.js';
-import '../logger.js';
-
-/**
- * A `Flow` that creates a linear workflow from a sequence of nodes,
- * automatically chaining them in order.
- */
-declare class SequenceFlow<PrepRes = any, ExecRes = any, TParams extends Params = Params, TContext extends Context = Context> extends Flow<PrepRes, ExecRes, TParams, TContext> {
-    /**
-     * @param nodes A sequence of `Node` or `Flow` instances to be executed in order.
-     */
-    constructor(...nodes: AbstractNode<any, any, TContext>[]);
-}
-/**
- * A `Flow` that executes a collection of different nodes concurrently.
- * This is the core of the "fan-out, fan-in" pattern for structural parallelism.
- * After all parallel branches complete, the flow can proceed to a single successor.
- */
-declare class ParallelFlow<TContext extends Context = Context> extends Flow<void, void, Params, TContext> {
-    protected nodesToRun: AbstractNode<any, any, TContext>[];
-    /** A tag to reliably identify this node type in the visualizer. */
-    readonly isParallelContainer = true;
-    /**
-     * @param nodesToRun The array of nodes to execute concurrently.
-     */
-    constructor(nodesToRun?: AbstractNode<any, any, TContext>[]);
-    /**
-     * Orchestrates the parallel execution of all nodes.
-     * @internal
-     */
-    exec({ ctx, params, signal, logger, executor, visitedInParallel }: NodeArgs<void, void, Params, TContext>): Promise<void>;
-}
-/**
- * An abstract `Flow` that processes a collection of items sequentially, one by one.
- * Subclasses must implement the `prep` method to provide the items and the
- * `nodeToRun` property to define the processing logic for each item.
- */
-declare abstract class BatchFlow<T = any, TContext extends Context = Context> extends Flow<Iterable<T>, null, Params, TContext> {
-    /**
-     * The `Node` instance that will be executed for each item in the batch.
-     * This must be implemented by any subclass.
-     */
-    protected abstract nodeToRun: AbstractNode<any, any, TContext>;
-    constructor();
-    /**
-     * (Abstract) Prepares the list of items to be processed.
-     * This method is called once before the batch processing begins.
-     * @param _args The arguments for the node, including `ctx` and `params`.
-     * @returns An array or iterable of parameter objects, one for each item.
-     * The `nodeToRun` will be executed once for each of these objects.
-     */
-    prep(_args: NodeArgs<void, void, Params, TContext>): Promise<Iterable<any>>;
-    /**
-     * Orchestrates the sequential execution of `nodeToRun` for each item.
-     * @internal
-     */
-    exec(args: NodeArgs<void, void, Params, TContext>): Promise<null>;
-}
-/**
- * An abstract `Flow` that processes a collection of items concurrently.
- * Subclasses must implement the `prep` method to provide the items and the
- * `nodeToRun` property to define the processing logic for each item.
- * This provides a significant performance boost for I/O-bound tasks.
- */
-declare abstract class ParallelBatchFlow<T = any, TContext extends Context = Context> extends Flow<Iterable<T>, PromiseSettledResult<any>[], Params, TContext> {
-    /**
-     * The `Node` instance that will be executed concurrently for each item in the batch.
-     * This must be implemented by any subclass.
-     */
-    protected abstract nodeToRun: AbstractNode<any, any, TContext>;
-    constructor();
-    /**
-     * (Abstract) Prepares the list of items to be processed.
-     * This method is called once before the batch processing begins.
-     * @param _args The arguments for the node, including `ctx` and `params`.
-     * @returns An array or iterable of parameter objects, one for each item.
-     * The `nodeToRun` will be executed concurrently for each of these objects.
-     */
-    prep(_args: NodeArgs<void, void, Params, TContext>): Promise<Iterable<any>>;
-    /**
-     * Orchestrates the parallel execution of `nodeToRun` for each item.
-     * @internal
-     */
-    exec(args: NodeArgs<any, void, Params, TContext>): Promise<PromiseSettledResult<any>[]>;
-}
-/**
- * Creates a flow that applies a mapping function to each item in a collection in parallel
- * and returns a new array containing the results.
- *
- * @example
- * const numbers = [1, 2, 3];
- * const double = (n: number) => n * 2;
- * const processingFlow = mapCollection(numbers, double);
- * // When run, processingFlow's result will be [2, 4, 6]
- *
- * @param items The initial array of items of type `T`.
- * @param fn An async or sync function that transforms an item from type `T` to type `U`.
- * @returns A `Flow` instance that, when run, will output an array of type `U[]`.
- */
-declare function mapCollection<T, U, TContext extends Context = Context>(items: T[], fn: NodeFunction<T, U>): Flow<void, U[], Params, TContext>;
-/**
- * Creates a flow that filters a collection based on a predicate function,
- * returning a new array containing only the items that pass the predicate.
- * The predicate is applied to all items concurrently.
- *
- * @example
- * const users = [{ id: 1, admin: true }, { id: 2, admin: false }];
- * const isAdmin = async (user: { admin: boolean }) => user.admin;
- * const adminFilterFlow = filterCollection(users, isAdmin);
- * // When run, the result will be [{ id: 1, admin: true }]
- *
- * @param items The initial array of items of type `T`.
- * @param predicate An async or sync function that returns `true` or `false` for an item.
- * @returns A `Flow` instance that, when run, will output a filtered array of type `T[]`.
- */
-declare function filterCollection<T, TContext extends Context = Context>(items: T[], predicate: (item: T) => boolean | Promise<boolean>): Flow<void, T[], Params, TContext>;
-/**
- * Creates a flow that reduces a collection to a single value by executing a
- * reducer function sequentially for each item, similar to `Array.prototype.reduce()`.
- *
- * @example
- * const numbers = [1, 2, 3, 4];
- * const sumReducer = (acc: number, val: number) => acc + val;
- * const sumFlow = reduceCollection(numbers, sumReducer, 0);
- * // When run, the result will be 10.
- *
- * @param items The array of items to be reduced.
- * @param reducer An async or sync function that processes the accumulator and the current item.
- * @param initialValue The initial value for the accumulator.
- * @returns A `Flow` instance that, when run, will output the final accumulated value of type `U`.
- */
-declare function reduceCollection<T, U, TContext extends Context = Context>(items: T[], reducer: (accumulator: U, item: T) => U | Promise<U>, initialValue: U): Flow<void, U, Params, TContext>;
-
-export { BatchFlow, ParallelBatchFlow, ParallelFlow, SequenceFlow, filterCollection, mapCollection, reduceCollection };

package/dist/builder/patterns.js

@@ -1,19 +0,0 @@
-export { BatchFlow, ParallelBatchFlow, ParallelFlow, SequenceFlow, filterCollection, mapCollection, reduceCollection } from '../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=patterns.js.map
-//# sourceMappingURL=patterns.js.map

package/dist/builder/patterns.js.map

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

package/dist/chunk-3YMBNZ77.js

@@ -1,441 +0,0 @@
-import { InputMappingNode, OutputMappingNode, SubWorkflowContainerNode, ConditionalJoinNode, ParallelBranchContainer } from './chunk-WGVHM7DU.js';
-import { Flow } from './chunk-UY4PNPBX.js';
-import { generateMermaidGraph } from './chunk-VMH2LRM6.js';
-import { InMemoryExecutor } from './chunk-BRFMFLR6.js';
-import { NullLogger } from './chunk-IIKTTIW5.js';
-import { DEFAULT_ACTION } from './chunk-AOHBHYF6.js';
-
-// src/builder/graph/graph.ts
-function createNodeRegistry(registry) {
-  const finalRegistry = /* @__PURE__ */ new Map();
-  for (const key in registry) {
-    if (Object.prototype.hasOwnProperty.call(registry, key))
-      finalRegistry.set(key, registry[key]);
-  }
-  if (!finalRegistry.has("__internal_input_mapper__"))
-    finalRegistry.set("__internal_input_mapper__", InputMappingNode);
-  if (!finalRegistry.has("__internal_output_mapper__"))
-    finalRegistry.set("__internal_output_mapper__", OutputMappingNode);
-  if (!finalRegistry.has("__internal_sub_workflow_container__"))
-    finalRegistry.set("__internal_sub_workflow_container__", SubWorkflowContainerNode);
-  if (!finalRegistry.has("__internal_conditional_join__"))
-    finalRegistry.set("__internal_conditional_join__", ConditionalJoinNode);
-  if (!finalRegistry.has("__internal_parallel_container__"))
-    finalRegistry.set("__internal_parallel_container__", ParallelBranchContainer);
-  return finalRegistry;
-}
-var GraphBuilder = class {
-  // handle both cases
-  constructor(registry, nodeOptionsContext = {}, options = {}, logger = new NullLogger()) {
-    this.nodeOptionsContext = nodeOptionsContext;
-    this.logger = logger;
-    this.registry = registry instanceof Map ? registry : createNodeRegistry(registry);
-    this.subWorkflowNodeTypes = options.subWorkflowNodeTypes ?? [];
-    this.conditionalNodeTypes = options.conditionalNodeTypes ?? [];
-    this.subWorkflowResolver = options.subWorkflowResolver;
-  }
-  registry;
-  subWorkflowNodeTypes;
-  conditionalNodeTypes;
-  subWorkflowResolver;
-  logger;
-  _logMermaid(flow) {
-    if (!(this.logger instanceof NullLogger)) {
-      this.logger.info("[GraphBuilder] Flattened Graph");
-      const mermaid = generateMermaidGraph(flow);
-      mermaid.split("\n").forEach((line) => this.logger.info(line));
-    }
-  }
-  _flattenGraph(graph, idPrefix = "") {
-    const finalNodes = [];
-    const finalEdges = [];
-    const localNodeIds = new Set(graph.nodes.map((n) => n.id));
-    for (const node of graph.nodes) {
-      const prefixedNodeId = `${idPrefix}${node.id}`;
-      const sanitizedId = prefixedNodeId.replace(/:/g, "_").replace(/\W/g, "");
-      const isRegisteredSubWorkflow = this.subWorkflowNodeTypes.includes(node.type);
-      const hasWorkflowId = node.data && "workflowId" in node.data;
-      const newNodeData = JSON.parse(JSON.stringify(node.data || {}));
-      if (newNodeData.inputs) {
-        const inputs = newNodeData.inputs;
-        for (const [templateKey, sourcePathOrPaths] of Object.entries(inputs)) {
-          const sourcePaths = Array.isArray(sourcePathOrPaths) ? sourcePathOrPaths : [sourcePathOrPaths];
-          const newSourcePaths = sourcePaths.map((sourcePath) => {
-            if (localNodeIds.has(sourcePath))
-              return `${idPrefix}${sourcePath}`;
-            return sourcePath;
-          });
-          inputs[templateKey] = Array.isArray(sourcePathOrPaths) ? newSourcePaths : newSourcePaths[0];
-        }
-      }
-      if (isRegisteredSubWorkflow) {
-        if (!this.subWorkflowResolver)
-          throw new Error("GraphBuilder: `subWorkflowResolver` must be provided in options to handle sub-workflows.");
-        const subWorkflowData = node.data;
-        const subWorkflowId = subWorkflowData.workflowId;
-        const subGraph = this.subWorkflowResolver.getGraph(subWorkflowId);
-        if (!subGraph)
-          throw new Error(`Sub-workflow with ID ${subWorkflowId} not found in resolver.`);
-        finalNodes.push({
-          id: prefixedNodeId,
-          type: "__internal_sub_workflow_container__",
-          data: { ...newNodeData, originalId: node.id }
-        });
-        const inputMapperId = `${sanitizedId}_input_mapper`;
-        const outputMapperId = `${sanitizedId}_output_mapper`;
-        finalNodes.push({
-          id: inputMapperId,
-          type: "__internal_input_mapper__",
-          data: { ...subWorkflowData.inputs || {}, originalId: node.id }
-        });
-        finalNodes.push({
-          id: outputMapperId,
-          type: "__internal_output_mapper__",
-          data: { ...subWorkflowData.outputs || {}, originalId: node.id }
-        });
-        const inlinedSubGraph = this._flattenGraph(subGraph, `${prefixedNodeId}:`);
-        const augmentedInlinedNodes = inlinedSubGraph.nodes.map((n) => ({
-          ...n,
-          data: { ...n.data || {}, isSubWorkflow: true }
-        }));
-        finalNodes.push(...augmentedInlinedNodes);
-        finalEdges.push(...inlinedSubGraph.edges);
-        finalEdges.push({ source: prefixedNodeId, target: inputMapperId });
-        const subGraphStartIds = inlinedSubGraph.nodes.map((n) => n.id).filter((id) => !inlinedSubGraph.edges.some((e) => e.target === id));
-        for (const startId of subGraphStartIds)
-          finalEdges.push({ source: inputMapperId, target: startId });
-        const subGraphTerminalIds = inlinedSubGraph.nodes.map((n) => n.id).filter((id) => !inlinedSubGraph.edges.some((e) => e.source === id));
-        for (const terminalId of subGraphTerminalIds)
-          finalEdges.push({ source: terminalId, target: outputMapperId });
-      } else if (hasWorkflowId) {
-        throw new Error(`Node with ID '${node.id}' has a 'workflowId' but its type '${node.type}' is not in 'subWorkflowNodeTypes'.`);
-      } else {
-        finalNodes.push({ ...node, id: prefixedNodeId, data: { ...newNodeData, originalId: node.id } });
-      }
-    }
-    for (const edge of graph.edges) {
-      const sourceNode = graph.nodes.find((n) => n.id === edge.source);
-      const prefixedSourceId = `${idPrefix}${edge.source}`;
-      const prefixedTargetId = `${idPrefix}${edge.target}`;
-      const isSourceSub = this.subWorkflowNodeTypes.includes(sourceNode.type);
-      const sanitizedSourceId = prefixedSourceId.replace(/:/g, "_").replace(/\W/g, "");
-      if (isSourceSub)
-        finalEdges.push({ ...edge, source: `${sanitizedSourceId}_output_mapper`, target: prefixedTargetId });
-      else
-        finalEdges.push({ ...edge, source: prefixedSourceId, target: prefixedTargetId });
-    }
-    return { nodes: finalNodes, edges: finalEdges };
-  }
-  build(graph, log) {
-    const { blueprint } = this.buildBlueprint(graph);
-    const executor = new BlueprintExecutor(blueprint, this.registry, this.nodeOptionsContext);
-    if (log)
-      this._logMermaid(executor.flow);
-    return {
-      flow: executor.flow,
-      nodeMap: executor.nodeMap,
-      predecessorCountMap: new Map(Object.entries(blueprint.predecessorCountMap)),
-      predecessorIdMap: new Map(Object.entries(blueprint.originalPredecessorIdMap).map(([k, v]) => [k, v])),
-      originalPredecessorIdMap: new Map(Object.entries(blueprint.originalPredecessorIdMap).map(([k, v]) => [k, v]))
-    };
-  }
-  // single implementation that handles both cases
-  buildBlueprint(graph) {
-    const flatGraph = this._flattenGraph(graph);
-    const conditionalNodes = flatGraph.nodes.filter((n) => this.conditionalNodeTypes.includes(n.type));
-    for (const conditionalNode of conditionalNodes) {
-      const branches = flatGraph.edges.filter((e) => e.source === conditionalNode.id).map((e) => e.target);
-      if (branches.length > 1) {
-        const convergenceTargetId = this._findConditionalConvergence(branches, flatGraph);
-        if (convergenceTargetId) {
-          const joinNodeId = `${conditionalNode.id}__conditional_join`;
-          if (!flatGraph.nodes.some((n) => n.id === joinNodeId)) {
-            this.logger.debug(`[GraphBuilder] Inserting conditional join node for '${conditionalNode.id}' converging at '${convergenceTargetId}'`);
-            flatGraph.nodes.push({ id: joinNodeId, type: "__internal_conditional_join__", data: {} });
-            const branchTerminalIds = this._findBranchTerminals(branches, convergenceTargetId, flatGraph);
-            const terminalsToReroute = new Set(branchTerminalIds);
-            if (flatGraph.edges.some((e) => e.source === conditionalNode.id && e.target === convergenceTargetId)) {
-              terminalsToReroute.add(conditionalNode.id);
-            }
-            for (const terminalId of terminalsToReroute) {
-              const edgesToUpdate = flatGraph.edges.filter((e) => e.source === terminalId && e.target === convergenceTargetId);
-              for (const edge of edgesToUpdate) {
-                edge.target = joinNodeId;
-              }
-            }
-            flatGraph.edges.push({ source: joinNodeId, target: convergenceTargetId });
-          }
-        }
-      }
-    }
-    const edgeGroups = flatGraph.edges.reduce((acc, edge) => {
-      if (!acc.has(edge.source))
-        acc.set(edge.source, /* @__PURE__ */ new Map());
-      const sourceActions = acc.get(edge.source);
-      const action = edge.action || DEFAULT_ACTION;
-      if (!sourceActions.has(action))
-        sourceActions.set(action, []);
-      sourceActions.get(action).push(edge.target);
-      return acc;
-    }, /* @__PURE__ */ new Map());
-    const nodesToProcess = [...flatGraph.nodes];
-    for (const sourceNode of nodesToProcess) {
-      const actions = edgeGroups.get(sourceNode.id);
-      if (!actions)
-        continue;
-      for (const [action, successors] of actions.entries()) {
-        if (successors.length > 1 && !this.conditionalNodeTypes.includes(sourceNode.type)) {
-          const parallelNodeId = `${sourceNode.id}__parallel_container`;
-          if (!flatGraph.nodes.some((n) => n.id === parallelNodeId)) {
-            flatGraph.nodes.push({ id: parallelNodeId, type: "__internal_parallel_container__", data: {} });
-            const edgesToReplace = flatGraph.edges.filter((e) => e.source === sourceNode.id && (e.action || DEFAULT_ACTION) === action);
-            flatGraph.edges = flatGraph.edges.filter((e) => !edgesToReplace.includes(e));
-            flatGraph.edges.push({ source: sourceNode.id, target: parallelNodeId, action: action === DEFAULT_ACTION ? void 0 : String(action) });
-            successors.forEach((succId) => flatGraph.edges.push({ source: parallelNodeId, target: succId }));
-          }
-        }
-      }
-    }
-    const { predecessorIdMap, originalPredecessorIdMap } = this._createPredecessorIdMaps(flatGraph);
-    const predecessorCountMap = /* @__PURE__ */ new Map();
-    for (const [key, val] of predecessorIdMap.entries()) {
-      predecessorCountMap.set(key, val.length);
-    }
-    const allNodeIds = new Set(flatGraph.nodes.map((n) => n.id));
-    for (const id of allNodeIds) {
-      if (!predecessorCountMap.has(id))
-        predecessorCountMap.set(id, 0);
-    }
-    const allTargetIds = new Set(flatGraph.edges.map((e) => e.target));
-    const startNodeIds = [...allNodeIds].filter((id) => !allTargetIds.has(id));
-    let startNodeId;
-    if (startNodeIds.length === 0 && allNodeIds.size > 0)
-      throw new Error("GraphBuilder: This graph has a cycle and no clear start node.");
-    if (startNodeIds.length === 1) {
-      startNodeId = startNodeIds[0];
-    } else {
-      startNodeId = "__root_parallel_start";
-      if (!flatGraph.nodes.some((n) => n.id === startNodeId)) {
-        flatGraph.nodes.push({ id: startNodeId, type: "__internal_parallel_container__", data: {} });
-        for (const id of startNodeIds)
-          flatGraph.edges.push({ source: startNodeId, target: id });
-      }
-    }
-    const blueprint = {
-      nodes: flatGraph.nodes,
-      edges: flatGraph.edges,
-      startNodeId,
-      predecessorCountMap: Object.fromEntries(predecessorCountMap.entries()),
-      originalPredecessorIdMap: Object.fromEntries(originalPredecessorIdMap.entries())
-    };
-    return { blueprint };
-  }
-  _createPredecessorIdMaps(graph) {
-    const predecessorIdMap = /* @__PURE__ */ new Map();
-    for (const edge of graph.edges) {
-      if (!predecessorIdMap.has(edge.target))
-        predecessorIdMap.set(edge.target, []);
-      predecessorIdMap.get(edge.target).push(edge.source);
-    }
-    const originalPredecessorIdMap = /* @__PURE__ */ new Map();
-    const nodeDataMap = new Map(graph.nodes.map((n) => [n.id, n]));
-    const memo = /* @__PURE__ */ new Map();
-    const findOriginalProducers = (nodeId) => {
-      if (memo.has(nodeId))
-        return memo.get(nodeId);
-      const nodeData = nodeDataMap.get(nodeId);
-      if (!nodeData)
-        return [];
-      const selfType = nodeData.type;
-      const selfOriginalId = nodeData.data?.originalId ?? nodeId;
-      if (!selfType.startsWith("__internal_")) {
-        const result2 = [selfOriginalId];
-        memo.set(nodeId, result2);
-        return result2;
-      }
-      if (selfType === "__internal_output_mapper__") {
-        const result2 = [selfOriginalId];
-        memo.set(nodeId, result2);
-        return result2;
-      }
-      const directPredecessors = predecessorIdMap.get(nodeId) || [];
-      const producers = /* @__PURE__ */ new Set();
-      for (const predId of directPredecessors) {
-        findOriginalProducers(predId).forEach((p) => producers.add(p));
-      }
-      const result = Array.from(producers);
-      memo.set(nodeId, result);
-      return result;
-    };
-    for (const targetId of nodeDataMap.keys()) {
-      const mapKey = targetId;
-      const directPredecessors = predecessorIdMap.get(targetId) || [];
-      const producers = /* @__PURE__ */ new Set();
-      for (const predId of directPredecessors)
-        findOriginalProducers(predId).forEach((p) => producers.add(p));
-      if (producers.size > 0)
-        originalPredecessorIdMap.set(mapKey, Array.from(producers));
-    }
-    return { predecessorIdMap, originalPredecessorIdMap };
-  }
-  _findBranchTerminals(branchStarts, targetId, graph) {
-    const terminals = [];
-    for (const start of branchStarts) {
-      const queue = [start];
-      const visitedInBranch = /* @__PURE__ */ new Set();
-      while (queue.length > 0) {
-        const currentId = queue.shift();
-        if (visitedInBranch.has(currentId))
-          continue;
-        visitedInBranch.add(currentId);
-        const successors = graph.edges.filter((e) => e.source === currentId).map((e) => e.target);
-        if (successors.includes(targetId)) {
-          if (!terminals.includes(currentId)) {
-            terminals.push(currentId);
-          }
-        } else {
-          for (const successorId of successors) {
-            if (!visitedInBranch.has(successorId)) {
-              queue.push(successorId);
-            }
-          }
-        }
-      }
-    }
-    return terminals;
-  }
-  _findConditionalConvergence(branchStarts, graph) {
-    if (branchStarts.length <= 1)
-      return void 0;
-    const queue = [...branchStarts];
-    const visitedBy = /* @__PURE__ */ new Map();
-    branchStarts.forEach((startId) => visitedBy.set(startId, /* @__PURE__ */ new Set([startId])));
-    let head = 0;
-    while (head < queue.length) {
-      const currentId = queue[head++];
-      const successors = graph.edges.filter((e) => e.source === currentId).map((e) => e.target);
-      for (const successorId of successors) {
-        if (!visitedBy.has(successorId))
-          visitedBy.set(successorId, /* @__PURE__ */ new Set());
-        const visitorSet = visitedBy.get(successorId);
-        const startingPointsVistingThisNode = visitedBy.get(currentId);
-        for (const startNodeId of startingPointsVistingThisNode)
-          visitorSet.add(startNodeId);
-        if (visitorSet.size === branchStarts.length)
-          return successorId;
-        if (!queue.includes(successorId))
-          queue.push(successorId);
-      }
-    }
-    return void 0;
-  }
-};
-
-// src/builder/graph/runner.ts
-var BlueprintExecutor = class {
-  constructor(blueprint, registry, nodeOptionsContext = {}) {
-    this.blueprint = blueprint;
-    this.nodeOptionsContext = nodeOptionsContext;
-    this.registry = registry instanceof Map ? registry : createNodeRegistry(registry);
-    this.nodeMap = this._createNodeMap(blueprint.nodes);
-    this._wireGraph();
-    const startNode = this.nodeMap.get(blueprint.startNodeId);
-    if (!startNode)
-      throw new Error(`Blueprint start node with ID '${blueprint.startNodeId}' not found in hydrated node map.`);
-    this.flow = new Flow(startNode);
-    this._populateContainers();
-  }
-  flow;
-  nodeMap;
-  registry;
-  _populateContainers() {
-    for (const node of this.nodeMap.values()) {
-      if (node instanceof ParallelBranchContainer)
-        node.nodesToRun = Array.from(node.successors.values()).flat();
-    }
-  }
-  /**
-   * Retrieves a hydrated node instance from the blueprint by its ID.
-   * This is useful for workers that need to execute a specific node from the graph.
-   * @param nodeId The ID of the node to retrieve.
-   * @returns The `AbstractNode` instance if found, otherwise `undefined`.
-   */
-  getNode(nodeId) {
-    return this.nodeMap.get(nodeId);
-  }
-  /**
-   * Instantiates all node objects from the blueprint's definition.
-   * @private
-   */
-  _createNodeMap(nodes) {
-    const nodeMap = /* @__PURE__ */ new Map();
-    for (const graphNode of nodes) {
-      const NodeClass = this.registry.get(graphNode.type);
-      if (!NodeClass)
-        throw new Error(`BlueprintExecutor: Node type '${graphNode.type}' not found in registry.`);
-      const nodeOptions = {
-        ...this.nodeOptionsContext,
-        data: { ...graphNode.data, nodeId: graphNode.id }
-      };
-      const executableNode = new NodeClass(nodeOptions).withId(graphNode.id).withGraphData(graphNode);
-      nodeMap.set(graphNode.id, executableNode);
-    }
-    return nodeMap;
-  }
-  /**
-   * Wires the hydrated node instances together based on the blueprint's edges.
-   * @private
-   */
-  _wireGraph() {
-    const edgeGroups = /* @__PURE__ */ new Map();
-    for (const edge of this.blueprint.edges) {
-      const sourceId = edge.source;
-      const action = edge.action || DEFAULT_ACTION;
-      const targetNode = this.nodeMap.get(edge.target);
-      if (!targetNode)
-        continue;
-      if (!edgeGroups.has(sourceId))
-        edgeGroups.set(sourceId, /* @__PURE__ */ new Map());
-      const sourceActions = edgeGroups.get(sourceId);
-      if (!sourceActions.has(action))
-        sourceActions.set(action, []);
-      sourceActions.get(action).push(targetNode);
-    }
-    for (const [sourceId, actions] of edgeGroups.entries()) {
-      const sourceNode = this.nodeMap.get(sourceId);
-      for (const [action, successors] of actions.entries()) {
-        for (const successor of successors)
-          sourceNode.next(successor, action);
-      }
-    }
-  }
-  /**
-   * Executes the flow defined by the blueprint.
-   * @param flow The flow 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.
-   */
-  async run(flow, context, options) {
-    if (flow !== this.flow) {
-      throw new Error(
-        "BlueprintExecutor is specialized and can only run the flow instance it was constructed with. To run an arbitrary flow, use an InMemoryExecutor instance."
-      );
-    }
-    const inMemoryExecutor = new InMemoryExecutor();
-    const finalOptions = { ...options, executor: this };
-    return inMemoryExecutor.run(this.flow, context, finalOptions);
-  }
-  /**
-   * Determines the next node to execute based on the action returned by the current node.
-   * For distributed systems, this logic would live on the orchestrator.
-   * @internal
-   */
-  getNextNode(curr, action) {
-    return curr.successors.get(action)?.[0];
-  }
-};
-
-export { BlueprintExecutor, GraphBuilder, createNodeRegistry };
-//# sourceMappingURL=chunk-3YMBNZ77.js.map
-//# sourceMappingURL=chunk-3YMBNZ77.js.map