flowcraft 1.0.0 → 2.0.0

package/dist/chunk-L5PK5VL2.js

@@ -1,178 +0,0 @@
-import { Flow } from './chunk-UY4PNPBX.js';
-import { AbortError } from './chunk-64DNBF5W.js';
-
-// src/builder/patterns.ts
-var SequenceFlow = class extends Flow {
-  /**
-   * @param nodes A sequence of `Node` or `Flow` instances to be executed in order.
-   */
-  constructor(...nodes) {
-    if (nodes.length === 0) {
-      super();
-      return;
-    }
-    super(nodes[0]);
-    let current = nodes[0];
-    for (let i = 1; i < nodes.length; i++)
-      current = current.next(nodes[i]);
-  }
-};
-var ParallelFlow = class extends Flow {
-  /**
-   * @param nodesToRun The array of nodes to execute concurrently.
-   */
-  constructor(nodesToRun = []) {
-    super();
-    this.nodesToRun = nodesToRun;
-  }
-  /** A tag to reliably identify this node type in the visualizer. */
-  isParallelContainer = true;
-  /**
-   * Orchestrates the parallel execution of all nodes.
-   * @internal
-   */
-  async exec({ ctx, params, signal, logger, executor, visitedInParallel }) {
-    if (!visitedInParallel)
-      throw new Error("ParallelFlow requires a visitedInParallel set from its executor.");
-    const branches = this.nodesToRun.length > 0 ? this.nodesToRun : Array.from(this.successors.values()).flat();
-    if (branches.length === 0) {
-      logger.debug("[ParallelFlow] No branches to execute.");
-      return;
-    }
-    const runBranch = async (startNode) => {
-      let currentNode = startNode;
-      while (currentNode) {
-        if (signal?.aborted)
-          throw new AbortError();
-        if (visitedInParallel.has(currentNode))
-          break;
-        visitedInParallel.add(currentNode);
-        const action = await currentNode._run({
-          ctx,
-          params: { ...params, ...currentNode.params },
-          signal,
-          logger,
-          executor,
-          visitedInParallel
-        });
-        currentNode = executor?.getNextNode(currentNode, action);
-      }
-    };
-    const promises = branches.map(runBranch);
-    await Promise.allSettled(promises);
-  }
-};
-var BatchFlow = class extends Flow {
-  constructor() {
-    super();
-  }
-  /**
-   * (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.
-   */
-  async prep(_args) {
-    return [];
-  }
-  /**
-   * Orchestrates the sequential execution of `nodeToRun` for each item.
-   * @internal
-   */
-  async exec(args) {
-    if (!this.nodeToRun)
-      return null;
-    const combinedParams = { ...this.params, ...args.params };
-    const batchParamsIterable = await this.prep(args) || [];
-    const batchParamsList = Array.from(batchParamsIterable);
-    for (const batchParams of batchParamsList) {
-      if (args.signal?.aborted)
-        throw new AbortError();
-      await this.nodeToRun._run({
-        ctx: args.ctx,
-        params: { ...combinedParams, ...batchParams },
-        signal: args.signal,
-        logger: args.logger,
-        executor: args.executor
-      });
-    }
-    return null;
-  }
-};
-var ParallelBatchFlow = class extends Flow {
-  constructor() {
-    super();
-  }
-  /**
-   * (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.
-   */
-  async prep(_args) {
-    return [];
-  }
-  /**
-   * Orchestrates the parallel execution of `nodeToRun` for each item.
-   * @internal
-   */
-  async exec(args) {
-    if (!this.nodeToRun)
-      return [];
-    const combinedParams = { ...this.params, ...args.params };
-    const batchParamsIterable = await this.prep(args) || [];
-    const batchParamsList = Array.from(batchParamsIterable);
-    const promises = batchParamsList.map((batchParams) => {
-      return this.nodeToRun._run({
-        ctx: args.ctx,
-        params: { ...combinedParams, ...batchParams },
-        signal: args.signal,
-        logger: args.logger,
-        executor: args.executor
-      });
-    });
-    const results = await Promise.allSettled(promises);
-    for (const result of results) {
-      if (result.status === "rejected") {
-        args.logger.error("A parallel batch item failed.", { error: result.reason });
-      }
-    }
-    return results;
-  }
-};
-function mapCollection(items, fn) {
-  return new class extends Flow {
-    async exec() {
-      const promises = items.map((item) => fn(item));
-      return Promise.all(promises);
-    }
-  }();
-}
-function filterCollection(items, predicate) {
-  return new class extends Flow {
-    async exec() {
-      const results = await Promise.all(items.map((item) => predicate(item)));
-      return items.filter((_, index) => results[index]);
-    }
-  }();
-}
-function reduceCollection(items, reducer, initialValue) {
-  return new class extends Flow {
-    async exec(_args) {
-      let accumulator = initialValue;
-      for (const item of items) {
-        if (_args.signal?.aborted) {
-          throw new AbortError();
-        }
-        accumulator = await reducer(accumulator, item);
-      }
-      return accumulator;
-    }
-  }();
-}
-
-export { BatchFlow, ParallelBatchFlow, ParallelFlow, SequenceFlow, filterCollection, mapCollection, reduceCollection };
-//# sourceMappingURL=chunk-L5PK5VL2.js.map
-//# sourceMappingURL=chunk-L5PK5VL2.js.map

package/dist/chunk-L5PK5VL2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/builder/patterns.ts"],"names":[],"mappings":"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","file":"chunk-L5PK5VL2.js","sourcesContent":["import type { Context } from '../context'\nimport type { NodeFunction } from '../functions'\nimport type { NodeArgs, Params } from '../types'\nimport type { AbstractNode } from '../workflow/index'\nimport { AbortError } from '../errors'\nimport { Flow } from '../workflow/index'\n\n/**\n * A `Flow` that creates a linear workflow from a sequence of nodes,\n * automatically chaining them in order.\n */\nexport class SequenceFlow<\n\tPrepRes = any,\n\tExecRes = any,\n\tTParams extends Params = Params,\n\tTContext extends Context = Context,\n> extends Flow<PrepRes, ExecRes, TParams, TContext> {\n\t/**\n\t * @param nodes A sequence of `Node` or `Flow` instances to be executed in order.\n\t */\n\tconstructor(...nodes: AbstractNode<any, any, TContext>[]) {\n\t\tif (nodes.length === 0) {\n\t\t\tsuper()\n\t\t\treturn\n\t\t}\n\t\tsuper(nodes[0])\n\t\tlet current = nodes[0]\n\t\tfor (let i = 1; i < nodes.length; i++)\n\t\t\tcurrent = current.next(nodes[i])\n\t}\n}\n\n/**\n * A `Flow` that executes a collection of different nodes concurrently.\n * This is the core of the \"fan-out, fan-in\" pattern for structural parallelism.\n * After all parallel branches complete, the flow can proceed to a single successor.\n */\nexport class ParallelFlow<\n\tTContext extends Context = Context,\n> extends Flow<void, void, Params, TContext> {\n\t/** A tag to reliably identify this node type in the visualizer. */\n\tpublic readonly isParallelContainer = true\n\n\t/**\n\t * @param nodesToRun The array of nodes to execute concurrently.\n\t */\n\tconstructor(protected nodesToRun: AbstractNode<any, any, TContext>[] = []) {\n\t\tsuper()\n\t}\n\n\t/**\n\t * Orchestrates the parallel execution of all nodes.\n\t * @internal\n\t */\n\tasync exec({ ctx, params, signal, logger, executor, visitedInParallel }: NodeArgs<void, void, Params, TContext>): Promise<void> {\n\t\tif (!visitedInParallel)\n\t\t\tthrow new Error('ParallelFlow requires a visitedInParallel set from its executor.')\n\n\t\tconst branches = this.nodesToRun.length > 0\n\t\t\t? this.nodesToRun\n\t\t\t: Array.from(this.successors.values()).flat()\n\n\t\tif (branches.length === 0) {\n\t\t\tlogger.debug('[ParallelFlow] No branches to execute.')\n\t\t\treturn\n\t\t}\n\n\t\tconst runBranch = async (startNode: AbstractNode<any, any, TContext>) => {\n\t\t\tlet currentNode: AbstractNode<any, any, TContext> | undefined = startNode\n\t\t\twhile (currentNode) {\n\t\t\t\tif (signal?.aborted)\n\t\t\t\t\tthrow new AbortError()\n\n\t\t\t\tif (visitedInParallel.has(currentNode))\n\t\t\t\t\tbreak\n\t\t\t\tvisitedInParallel.add(currentNode)\n\n\t\t\t\tconst action = await currentNode._run({\n\t\t\t\t\tctx,\n\t\t\t\t\tparams: { ...params, ...currentNode.params },\n\t\t\t\t\tsignal,\n\t\t\t\t\tlogger,\n\t\t\t\t\texecutor,\n\t\t\t\t\tvisitedInParallel,\n\t\t\t\t})\n\n\t\t\t\tcurrentNode = executor?.getNextNode(currentNode, action)\n\t\t\t}\n\t\t}\n\n\t\tconst promises = branches.map(runBranch)\n\t\tawait Promise.allSettled(promises)\n\t}\n}\n\n/**\n * An abstract `Flow` that processes a collection of items sequentially, one by one.\n * Subclasses must implement the `prep` method to provide the items and the\n * `nodeToRun` property to define the processing logic for each item.\n */\nexport abstract class BatchFlow<\n\tT = any,\n\tTContext extends Context = Context,\n> extends Flow<Iterable<T>, null, Params, TContext> {\n\t/**\n\t * The `Node` instance that will be executed for each item in the batch.\n\t * This must be implemented by any subclass.\n\t */\n\tprotected abstract nodeToRun: AbstractNode<any, any, TContext>\n\n\tconstructor() {\n\t\tsuper()\n\t}\n\n\t/**\n\t * (Abstract) Prepares the list of items to be processed.\n\t * This method is called once before the batch processing begins.\n\t * @param _args The arguments for the node, including `ctx` and `params`.\n\t * @returns An array or iterable of parameter objects, one for each item.\n\t * The `nodeToRun` will be executed once for each of these objects.\n\t */\n\tasync prep(_args: NodeArgs<void, void, Params, TContext>): Promise<Iterable<any>> {\n\t\treturn []\n\t}\n\n\t/**\n\t * Orchestrates the sequential execution of `nodeToRun` for each item.\n\t * @internal\n\t */\n\tasync exec(args: NodeArgs<void, void, Params, TContext>): Promise<null> {\n\t\tif (!this.nodeToRun)\n\t\t\treturn null\n\n\t\tconst combinedParams = { ...this.params, ...args.params }\n\t\tconst batchParamsIterable = (await this.prep(args)) || []\n\t\tconst batchParamsList = Array.from(batchParamsIterable)\n\n\t\tfor (const batchParams of batchParamsList) {\n\t\t\tif (args.signal?.aborted)\n\t\t\t\tthrow new AbortError()\n\n\t\t\tawait this.nodeToRun._run({\n\t\t\t\tctx: args.ctx,\n\t\t\t\tparams: { ...combinedParams, ...batchParams },\n\t\t\t\tsignal: args.signal,\n\t\t\t\tlogger: args.logger,\n\t\t\t\texecutor: args.executor,\n\t\t\t})\n\t\t}\n\t\treturn null\n\t}\n}\n\n/**\n * An abstract `Flow` that processes a collection of items concurrently.\n * Subclasses must implement the `prep` method to provide the items and the\n * `nodeToRun` property to define the processing logic for each item.\n * This provides a significant performance boost for I/O-bound tasks.\n */\nexport abstract class ParallelBatchFlow<\n\tT = any,\n\tTContext extends Context = Context,\n> extends Flow<Iterable<T>, PromiseSettledResult<any>[], Params, TContext> {\n\t/**\n\t * The `Node` instance that will be executed concurrently for each item in the batch.\n\t * This must be implemented by any subclass.\n\t */\n\tprotected abstract nodeToRun: AbstractNode<any, any, TContext>\n\n\tconstructor() {\n\t\tsuper()\n\t}\n\n\t/**\n\t * (Abstract) Prepares the list of items to be processed.\n\t * This method is called once before the batch processing begins.\n\t * @param _args The arguments for the node, including `ctx` and `params`.\n\t * @returns An array or iterable of parameter objects, one for each item.\n\t * The `nodeToRun` will be executed concurrently for each of these objects.\n\t */\n\tasync prep(_args: NodeArgs<void, void, Params, TContext>): Promise<Iterable<any>> {\n\t\treturn []\n\t}\n\n\t/**\n\t * Orchestrates the parallel execution of `nodeToRun` for each item.\n\t * @internal\n\t */\n\tasync exec(args: NodeArgs<any, void, Params, TContext>): Promise<PromiseSettledResult<any>[]> {\n\t\tif (!this.nodeToRun)\n\t\t\treturn []\n\n\t\tconst combinedParams = { ...this.params, ...args.params }\n\t\tconst batchParamsIterable = (await this.prep(args)) || []\n\t\tconst batchParamsList = Array.from(batchParamsIterable)\n\n\t\tconst promises = batchParamsList.map((batchParams) => {\n\t\t\treturn this.nodeToRun._run({\n\t\t\t\tctx: args.ctx,\n\t\t\t\tparams: { ...combinedParams, ...batchParams },\n\t\t\t\tsignal: args.signal,\n\t\t\t\tlogger: args.logger,\n\t\t\t\texecutor: args.executor,\n\t\t\t})\n\t\t})\n\n\t\tconst results = await Promise.allSettled(promises)\n\n\t\tfor (const result of results) {\n\t\t\tif (result.status === 'rejected') {\n\t\t\t\targs.logger.error('A parallel batch item failed.', { error: result.reason })\n\t\t\t}\n\t\t}\n\n\t\treturn results\n\t}\n}\n\n/**\n * Creates a flow that applies a mapping function to each item in a collection in parallel\n * and returns a new array containing the results.\n *\n * @example\n * const numbers = [1, 2, 3];\n * const double = (n: number) => n * 2;\n * const processingFlow = mapCollection(numbers, double);\n * // When run, processingFlow's result will be [2, 4, 6]\n *\n * @param items The initial array of items of type `T`.\n * @param fn An async or sync function that transforms an item from type `T` to type `U`.\n * @returns A `Flow` instance that, when run, will output an array of type `U[]`.\n */\nexport function mapCollection<T, U, TContext extends Context = Context>(items: T[], fn: NodeFunction<T, U>): Flow<void, U[], Params, TContext> {\n\treturn new class extends Flow<void, U[], Params, TContext> {\n\t\tasync exec(): Promise<U[]> {\n\t\t\tconst promises = items.map(item => fn(item))\n\t\t\treturn Promise.all(promises)\n\t\t}\n\t}()\n}\n\n/**\n * Creates a flow that filters a collection based on a predicate function,\n * returning a new array containing only the items that pass the predicate.\n * The predicate is applied to all items concurrently.\n *\n * @example\n * const users = [{ id: 1, admin: true }, { id: 2, admin: false }];\n * const isAdmin = async (user: { admin: boolean }) => user.admin;\n * const adminFilterFlow = filterCollection(users, isAdmin);\n * // When run, the result will be [{ id: 1, admin: true }]\n *\n * @param items The initial array of items of type `T`.\n * @param predicate An async or sync function that returns `true` or `false` for an item.\n * @returns A `Flow` instance that, when run, will output a filtered array of type `T[]`.\n */\nexport function filterCollection<T, TContext extends Context = Context>(items: T[], predicate: (item: T) => boolean | Promise<boolean>): Flow<void, T[], Params, TContext> {\n\treturn new class extends Flow<void, T[], Params, TContext> {\n\t\tasync exec(): Promise<T[]> {\n\t\t\tconst results = await Promise.all(items.map(item => predicate(item)))\n\t\t\treturn items.filter((_, index) => results[index])\n\t\t}\n\t}()\n}\n\n/**\n * Creates a flow that reduces a collection to a single value by executing a\n * reducer function sequentially for each item, similar to `Array.prototype.reduce()`.\n *\n * @example\n * const numbers = [1, 2, 3, 4];\n * const sumReducer = (acc: number, val: number) => acc + val;\n * const sumFlow = reduceCollection(numbers, sumReducer, 0);\n * // When run, the result will be 10.\n *\n * @param items The array of items to be reduced.\n * @param reducer An async or sync function that processes the accumulator and the current item.\n * @param initialValue The initial value for the accumulator.\n * @returns A `Flow` instance that, when run, will output the final accumulated value of type `U`.\n */\nexport function reduceCollection<T, U, TContext extends Context = Context>(\n\titems: T[],\n\treducer: (accumulator: U, item: T) => U | Promise<U>,\n\tinitialValue: U,\n): Flow<void, U, Params, TContext> {\n\treturn new class extends Flow<void, U, Params, TContext> {\n\t\tasync exec(_args: NodeArgs<void, void, Params, TContext>): Promise<U> {\n\t\t\tlet accumulator = initialValue\n\t\t\tfor (const item of items) {\n\t\t\t\tif (_args.signal?.aborted) {\n\t\t\t\t\tthrow new AbortError()\n\t\t\t\t}\n\t\t\t\taccumulator = await reducer(accumulator, item)\n\t\t\t}\n\t\t\treturn accumulator\n\t\t}\n\t}()\n}\n"]}

package/dist/chunk-P3RPDZHO.js

@@ -1,36 +0,0 @@
-import { composeContext } from './chunk-R27FIYR5.js';
-import { SequenceFlow } from './chunk-L5PK5VL2.js';
-import { Node } from './chunk-HEO3XL4Z.js';
-
-// src/functions.ts
-function mapNode(fn) {
-  return new class extends Node {
-    async exec({ params }) {
-      return fn(params);
-    }
-  }();
-}
-function contextNode(fn) {
-  return new class extends Node {
-    async exec({ ctx, params }) {
-      return await fn(ctx, params);
-    }
-  }();
-}
-function transformNode(...transforms) {
-  return new class extends Node {
-    async prep({ ctx }) {
-      await composeContext(...transforms)(ctx);
-    }
-  }();
-}
-function pipeline(...nodes) {
-  return new SequenceFlow(...nodes);
-}
-function compose(f, g) {
-  return async (input) => f(await g(input));
-}
-
-export { compose, contextNode, mapNode, pipeline, transformNode };
-//# sourceMappingURL=chunk-P3RPDZHO.js.map
-//# sourceMappingURL=chunk-P3RPDZHO.js.map

package/dist/chunk-P3RPDZHO.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/functions.ts"],"names":[],"mappings":";;;;;AAkCO,SAAS,QAId,EAAA,EAAmE;AACpE,EAAA,OAAO,IAAI,cAAc,IAAA,CAAyC;AAAA,IACjE,MAAM,IAAA,CAAK,EAAE,MAAA,EAAO,EAAuD;AAC1E,MAAA,OAAO,GAAG,MAAa,CAAA;AAAA,IACxB;AAAA,GACD,EAAE;AACH;AAeO,SAAS,YAId,EAAA,EAAgF;AACjF,EAAA,OAAO,IAAI,cAAc,IAAA,CAAyC;AAAA,IACjE,MAAM,IAAA,CAAK,EAAE,GAAA,EAAK,QAAO,EAAuD;AAC/E,MAAA,OAAO,MAAM,EAAA,CAAG,GAAA,EAAK,MAAa,CAAA;AAAA,IACnC;AAAA,GACD,EAAE;AACH;AAeO,SAAS,iBAAqD,UAAA,EAAyE;AAC7I,EAAA,OAAO,IAAI,cAAc,IAAA,CAA4C;AAAA,IACpE,MAAM,IAAA,CAAK,EAAE,GAAA,EAAI,EAA2C;AAE3D,MAAA,MAAM,cAAA,CAAe,GAAG,UAAU,CAAA,CAAE,GAAG,CAAA;AAAA,IACxC;AAAA,GACD,EAAE;AACH;AAYO,SAAS,YAAgD,KAAA,EAA+E;AAC9I,EAAA,OAAO,IAAI,YAAA,CAAyC,GAAG,KAAK,CAAA;AAC7D;AAkBO,SAAS,OAAA,CAAiB,GAAuB,CAAA,EAA2C;AAClG,EAAA,OAAO,OAAO,KAAA,KAAa,CAAA,CAAE,MAAM,CAAA,CAAE,KAAK,CAAC,CAAA;AAC5C","file":"chunk-P3RPDZHO.js","sourcesContent":["import type { Context, ContextTransform } from './context'\nimport type { NodeArgs, Params } from './types'\nimport type { Flow, Node } from './workflow/index'\nimport { SequenceFlow } from './builder/patterns'\nimport { composeContext } from './context'\nimport { Node as BaseNode } from './workflow/index'\n\n/**\n * A type for a pure function that can be executed within a `Node`,\n * typically taking the node's `params` as input.\n * @template TIn The input type, corresponding to `params`.\n * @template TOut The output type, which becomes the node's `execRes`.\n */\nexport type NodeFunction<TIn = any, TOut = any> = (input: TIn) => TOut | Promise<TOut>\n\n/**\n * A type for a function that operates on the shared `Context` in addition\n * to the node's `params`.\n * @template TIn The input type, corresponding to `params`.\n * @template TOut The output type, which becomes the node's `execRes`.\n */\nexport type ContextFunction<TIn = any, TOut = any, TContext extends Context = Context> = (ctx: TContext, input: TIn) => TOut | Promise<TOut>\n\n/**\n * Creates a `Node` from a simple, pure function that transforms an input to an output.\n * The node's `params` object is passed as the input to the function.\n *\n * @example\n * const add = (n: number) => mapNode<{ value: number }, number>(params => params.value + n)\n * const add5Node = add(5) // A reusable node that adds 5 to its input parameter.\n *\n * @param fn A function that takes an input object and returns a result.\n * @returns A new `Node` instance that wraps the function.\n */\nexport function mapNode<\n\tTIn extends Params,\n\tTOut,\n\tTContext extends Context = Context,\n>(fn: NodeFunction<TIn, TOut>): Node<void, TOut, any, TIn, TContext> {\n\treturn new class extends BaseNode<void, TOut, any, TIn, TContext> {\n\t\tasync exec({ params }: NodeArgs<void, void, TIn, TContext>): Promise<TOut> {\n\t\t\treturn fn(params as TIn)\n\t\t}\n\t}()\n}\n\n/**\n * Creates a `Node` from a function that requires access to the shared `Context`.\n * Both the `Context` and the node's `params` are passed as arguments to the function.\n *\n * @example\n * const greeter = contextNode(async (ctx, params: { name: string }) => {\n *   const language = await ctx.get(LANGUAGE_KEY) || 'en'\n *   return language === 'en' ? `Hello, ${params.name}` : `Hola, ${params.name}`\n * })\n *\n * @param fn A function that takes the context and an input object, and returns a result.\n * @returns A new `Node` instance that wraps the function.\n */\nexport function contextNode<\n\tTIn extends Params,\n\tTOut,\n\tTContext extends Context = Context,\n>(fn: ContextFunction<TIn, TOut, TContext>): Node<void, TOut, any, TIn, TContext> {\n\treturn new class extends BaseNode<void, TOut, any, TIn, TContext> {\n\t\tasync exec({ ctx, params }: NodeArgs<void, void, TIn, TContext>): Promise<TOut> {\n\t\t\treturn await fn(ctx, params as TIn)\n\t\t}\n\t}()\n}\n\n/**\n * Creates a `Node` that declaratively applies a series of transformations to the `Context`.\n * This is a \"side-effect\" node used purely for state management; its logic runs in the `prep` phase,\n * and it does not produce an `exec` output.\n *\n * @example\n * const USER_ID = contextKey<string>('user_id')\n * const userLens = lens(USER_ID)\n * const setupUserContext = (userId: string) => transformNode(userLens.set(userId))\n *\n * @param transforms A sequence of `ContextTransform` functions (e.g., from a lens) to apply.\n * @returns A new `Node` instance that will mutate the context when executed.\n */\nexport function transformNode<TContext extends Context = Context>(...transforms: ContextTransform[]): Node<void, void, any, Params, TContext> {\n\treturn new class extends BaseNode<void, void, any, Params, TContext> {\n\t\tasync prep({ ctx }: NodeArgs<void, void, Params, TContext>) {\n\t\t\t// Apply the composed transformations directly to the mutable context.\n\t\t\tawait composeContext(...transforms)(ctx)\n\t\t}\n\t}()\n}\n\n/**\n * A functional-style alias for `SequenceFlow`. It constructs a linear workflow\n * where each node executes in the order it is provided.\n *\n * @example\n * const mathPipeline = pipeline(addNode(5), multiplyNode(2))\n *\n * @param nodes A sequence of `Node` instances to chain together.\n * @returns A `Flow` instance representing the linear sequence.\n */\nexport function pipeline<TContext extends Context = Context>(...nodes: Node<any, any, any, any, TContext>[]): Flow<any, any, Params, TContext> {\n\treturn new SequenceFlow<any, any, Params, TContext>(...nodes)\n}\n\n/**\n * A classic functional composition utility. It takes two functions, `f` and `g`,\n * and returns a new function that computes `f(g(x))`.\n *\n * This is a general-purpose helper, not a `Node` builder itself, but it can be\n * used to create more complex `NodeFunction`s to pass to `mapNode`.\n *\n * @example\n * const add5 = (x: number) => x + 5\n * const multiply2 = (x: number) => x * 2\n * const add5ThenMultiply2 = compose(multiply2, add5) // equivalent to: x => (x + 5) * 2\n *\n * @param f The outer function, which receives the result of `g`.\n * @param g The inner function, which receives the initial input.\n * @returns A new `NodeFunction` that combines both operations.\n */\nexport function compose<A, B, C>(f: NodeFunction<B, C>, g: NodeFunction<A, B>): NodeFunction<A, C> {\n\treturn async (input: A) => f(await g(input))\n}\n"]}

package/dist/chunk-PNWOW52F.js

@@ -1,19 +0,0 @@
-// src/utils/middleware.ts
-function applyMiddleware(middleware, nodeToRun) {
-  const runNode = (args) => {
-    return nodeToRun._run({
-      ...args,
-      params: { ...args.params, ...nodeToRun.params }
-    });
-  };
-  if (!middleware || middleware.length === 0)
-    return runNode;
-  return middleware.reduceRight(
-    (next, mw) => (args) => mw(args, next),
-    runNode
-  );
-}
-
-export { applyMiddleware };
-//# sourceMappingURL=chunk-PNWOW52F.js.map
-//# sourceMappingURL=chunk-PNWOW52F.js.map

package/dist/chunk-PNWOW52F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/middleware.ts"],"names":[],"mappings":";AAOO,SAAS,eAAA,CAAyB,YAA6B,SAAA,EAA4C;AACjH,EAAA,MAAM,OAAA,GAA6B,CAAC,IAAA,KAAmB;AACtD,IAAA,OAAO,UAAU,IAAA,CAAK;AAAA,MACrB,GAAG,IAAA;AAAA,MACH,QAAQ,EAAE,GAAG,KAAK,MAAA,EAAQ,GAAG,UAAU,MAAA;AAAO,KAC9C,CAAA;AAAA,EACF,CAAA;AAEA,EAAA,IAAI,CAAC,UAAA,IAAc,UAAA,CAAW,MAAA,KAAW,CAAA;AACxC,IAAA,OAAO,OAAA;AAGR,EAAA,OAAO,UAAA,CAAW,WAAA;AAAA,IACjB,CAAC,IAAA,EAAM,EAAA,KAAO,CAAC,IAAA,KAAmB,EAAA,CAAG,MAAM,IAAI,CAAA;AAAA,IAC/C;AAAA,GACD;AACD","file":"chunk-PNWOW52F.js","sourcesContent":["import type { Middleware, MiddlewareNext, NodeArgs } from '../types'\nimport type { AbstractNode } from '../workflow/index'\n\n/**\n * Composes a chain of middleware functions around a node's execution.\n * @internal\n */\nexport function applyMiddleware<T = any>(middleware: Middleware<T>[], nodeToRun: AbstractNode): MiddlewareNext<T> {\n\tconst runNode: MiddlewareNext<T> = (args: NodeArgs) => {\n\t\treturn nodeToRun._run({\n\t\t\t...args,\n\t\t\tparams: { ...args.params, ...nodeToRun.params },\n\t\t})\n\t}\n\n\tif (!middleware || middleware.length === 0)\n\t\treturn runNode\n\n\t// Build the chain backwards, so the first middleware in the array is the outermost.\n\treturn middleware.reduceRight<MiddlewareNext<T>>(\n\t\t(next, mw) => (args: NodeArgs) => mw(args, next),\n\t\trunNode,\n\t)\n}\n"]}

package/dist/chunk-R27FIYR5.js

@@ -1,62 +0,0 @@
-// src/context.ts
-var contextKey = (description) => Symbol(description);
-var TypedContext = class {
-  data;
-  /**
-   * @param initialData An optional iterable (like an array of `[key, value]` pairs)
-   * to initialize the context with.
-   */
-  constructor(initialData) {
-    this.data = new Map(initialData);
-  }
-  async get(key) {
-    return this.data.get(key);
-  }
-  async set(key, value) {
-    this.data.set(key, value);
-    return this;
-  }
-  async has(key) {
-    return this.data.has(key);
-  }
-  async delete(key) {
-    return this.data.delete(key);
-  }
-  entries() {
-    return this.data.entries();
-  }
-  keys() {
-    return this.data.keys();
-  }
-  values() {
-    return this.data.values();
-  }
-};
-function lens(key) {
-  return {
-    get: async (ctx) => {
-      return await ctx.get(key);
-    },
-    set: (value) => async (ctx) => {
-      return await ctx.set(key, value);
-    },
-    update: (fn) => async (ctx) => {
-      const currentValue = await ctx.get(key);
-      const newValue = fn(currentValue);
-      return await ctx.set(key, newValue);
-    }
-  };
-}
-function composeContext(...transforms) {
-  return async (ctx) => {
-    let currentContext = ctx;
-    for (const transform of transforms) {
-      currentContext = await transform(currentContext);
-    }
-    return currentContext;
-  };
-}
-
-export { TypedContext, composeContext, contextKey, lens };
-//# sourceMappingURL=chunk-R27FIYR5.js.map
-//# sourceMappingURL=chunk-R27FIYR5.js.map

package/dist/chunk-R27FIYR5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/context.ts"],"names":[],"mappings":";AAeO,IAAM,UAAA,GAAa,CAAI,WAAA,KAAwC,MAAA,CAAO,WAAW;AA6CjF,IAAM,eAAN,MAAsC;AAAA,EACpC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAKR,YAAY,WAAA,EAAyE;AACpF,IAAA,IAAA,CAAK,IAAA,GAAO,IAAI,GAAA,CAAc,WAAW,CAAA;AAAA,EAC1C;AAAA,EACA,MAAM,IAAI,GAAA,EAA6C;AAAE,IAAA,OAAO,IAAA,CAAK,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AAAA,EAAE;AAAA,EACnF,MAAM,GAAA,CAAI,GAAA,EAA+B,KAAA,EAA2B;AAAE,IAAA,IAAA,CAAK,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AAAG,IAAA,OAAO,IAAA;AAAA,EAAK;AAAA,EAC7G,MAAM,IAAI,GAAA,EAAiD;AAAE,IAAA,OAAO,IAAA,CAAK,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AAAA,EAAE;AAAA,EACvF,MAAM,OAAO,GAAA,EAAiD;AAAE,IAAA,OAAO,IAAA,CAAK,IAAA,CAAK,MAAA,CAAO,GAAG,CAAA;AAAA,EAAE;AAAA,EAC7F,OAAA,GAAwC;AAAE,IAAA,OAAO,IAAA,CAAK,KAAK,OAAA,EAAQ;AAAA,EAAE;AAAA,EACrE,IAAA,GAA8B;AAAE,IAAA,OAAO,IAAA,CAAK,KAAK,IAAA,EAAK;AAAA,EAAE;AAAA,EACxD,MAAA,GAAgC;AAAE,IAAA,OAAO,IAAA,CAAK,KAAK,MAAA,EAAO;AAAA,EAAE;AAC7D;AAsCO,SAAS,KAAQ,GAAA,EAAoC;AAC3D,EAAA,OAAO;AAAA,IACN,GAAA,EAAK,OAAO,GAAA,KAAyC;AACpD,MAAA,OAAO,MAAM,GAAA,CAAI,GAAA,CAAI,GAAG,CAAA;AAAA,IACzB,CAAA;AAAA,IACA,GAAA,EAAK,CAAC,KAAA,KAA+B,OAAO,GAAA,KAAiB;AAC5D,MAAA,OAAO,MAAM,GAAA,CAAI,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AAAA,IAChC,CAAA;AAAA,IACA,MAAA,EAAQ,CAAC,EAAA,KAAwD,OAAO,GAAA,KAAiB;AACxF,MAAA,MAAM,YAAA,GAAe,MAAM,GAAA,CAAI,GAAA,CAAI,GAAG,CAAA;AACtC,MAAA,MAAM,QAAA,GAAW,GAAG,YAAY,CAAA;AAChC,MAAA,OAAO,MAAM,GAAA,CAAI,GAAA,CAAI,GAAA,EAAK,QAAQ,CAAA;AAAA,IACnC;AAAA,GACD;AACD;AASO,SAAS,kBAAkB,UAAA,EAAkD;AACnF,EAAA,OAAO,OAAO,GAAA,KAAiB;AAC9B,IAAA,IAAI,cAAA,GAAiB,GAAA;AACrB,IAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AACnC,MAAA,cAAA,GAAiB,MAAM,UAAU,cAAc,CAAA;AAAA,IAChD;AACA,IAAA,OAAO,cAAA;AAAA,EACR,CAAA;AACD","file":"chunk-R27FIYR5.js","sourcesContent":["/* eslint-disable style/lines-between-class-members, style/max-statements-per-line */\n\n/**\n * A type-safe, opaque key for storing and retrieving values from the Context.\n * Using a `ContextKey` provides compile-time safety for your workflow's state.\n * @template T The type of the value this key refers to.\n */\nexport type ContextKey<T> = symbol & { __type: T }\n\n/**\n * Creates a new, unique `ContextKey` for type-safe access to the `Context`.\n * @template T The type of the value this key will hold.\n * @param description An optional description for debugging purposes (e.g., in logs or test snapshots).\n * @returns A unique `ContextKey<T>`.\n */\nexport const contextKey = <T>(description?: string): ContextKey<T> => Symbol(description) as ContextKey<T>\n\n/**\n * Defines the interface for the shared context object passed through the workflow.\n * This interface is \"async-aware\", allowing for both synchronous (Map-based)\n * and asynchronous (e.g., Redis-backed) implementations.\n */\nexport interface Context {\n\t/**\n\t * Asynchronously retrieves a value from the context.\n\t * Callers should ALWAYS `await` the result of this method.\n\t */\n\tget: (<T>(key: ContextKey<T>) => Promise<T | undefined>)\n\t\t& (<T = any>(key: string) => Promise<T | undefined>)\n\t/** Asynchronously stores a value in the context. */\n\tset: (<T>(key: ContextKey<T>, value: T) => Promise<this>)\n\t\t& ((key: string, value: any) => Promise<this>)\n\t/** Asynchronously checks if a key exists in the context. */\n\thas: ((key: ContextKey<any>) => Promise<boolean>)\n\t\t& ((key: string) => Promise<boolean>)\n\t/** Asynchronously deletes a key from the context. */\n\tdelete: ((key: ContextKey<any>) => Promise<boolean>)\n\t\t& ((key: string) => Promise<boolean>)\n\t/**\n\t * Returns an iterator of all [key, value] pairs in the context.\n\t * NOTE: This may not be supported or may be inefficient in some async implementations.\n\t */\n\tentries: () => IterableIterator<[any, any]>\n\t/**\n\t * Returns an iterator of all keys in the context.\n\t * NOTE: This may not be supported or may be inefficient in some async implementations.\n\t */\n\tkeys: () => IterableIterator<any>\n\t/**\n\t * Returns an iterator of all values in the context.\n\t * NOTE: This may not be supported or may be inefficient in some async implementations.\n\t */\n\tvalues: () => IterableIterator<any>\n}\n\n/**\n * The default, `Map`-based implementation of the `Context` interface.\n * Its methods are async to satisfy the `Context` interface, but they wrap\n * synchronous operations.\n */\nexport class TypedContext implements Context {\n\tprivate data: Map<any, any>\n\t/**\n\t * @param initialData An optional iterable (like an array of `[key, value]` pairs)\n\t * to initialize the context with.\n\t */\n\tconstructor(initialData?: Iterable<readonly [ContextKey<any> | string, any]> | null) {\n\t\tthis.data = new Map<any, any>(initialData)\n\t}\n\tasync get(key: ContextKey<any> | string): Promise<any> { return this.data.get(key) }\n\tasync set(key: ContextKey<any> | string, value: any): Promise<this> { this.data.set(key, value); return this }\n\tasync has(key: ContextKey<any> | string): Promise<boolean> { return this.data.has(key) }\n\tasync delete(key: ContextKey<any> | string): Promise<boolean> { return this.data.delete(key) }\n\tentries(): IterableIterator<[any, any]> { return this.data.entries() }\n\tkeys(): IterableIterator<any> { return this.data.keys() }\n\tvalues(): IterableIterator<any> { return this.data.values() }\n}\n\n/** A function that takes a `Context` and returns a (potentially new) `Context`. */\nexport type ContextTransform = (ctx: Context) => Context | Promise<Context>\n\n/**\n * A \"lens\" provides a way to \"focus\" on a single key in the `Context`,\n * creating reusable, type-safe async functions to get, set, or update its value.\n * @template T The type of the value the lens focuses on.\n */\nexport interface ContextLens<T> {\n\t/** Asynchronously retrieves the value for the key from the context. */\n\tget: (ctx: Context) => Promise<T | undefined>\n\t/** Returns an asynchronous `ContextTransform` function that will set the key to the provided value. */\n\tset: (value: T) => ContextTransform\n\t/** Returns an asynchronous `ContextTransform` function that updates the key's value based on its current value. */\n\tupdate: (fn: (current: T | undefined) => T) => ContextTransform\n}\n\n/**\n * Creates a `ContextLens` object for a specific `ContextKey`.\n * This is the entry point for functional context manipulation.\n * All operations that read from the context are now async.\n *\n * @example\n * const NAME = contextKey<string>('name')\n * const nameLens = lens(NAME)\n *\n * // Usage in an async function:\n * async function exampleUsage(ctx: Context) {\n *   const currentName = await nameLens.get(ctx);\n *   const setNameTransform = nameLens.set('Alice');\n *   await setNameTransform(ctx);\n * }\n *\n * @param key The `ContextKey` to focus on.\n * @returns A `ContextLens<T>` object with async-aware methods.\n */\nexport function lens<T>(key: ContextKey<T>): ContextLens<T> {\n\treturn {\n\t\tget: async (ctx: Context): Promise<T | undefined> => {\n\t\t\treturn await ctx.get(key) as T | undefined\n\t\t},\n\t\tset: (value: T): ContextTransform => async (ctx: Context) => {\n\t\t\treturn await ctx.set(key, value)\n\t\t},\n\t\tupdate: (fn: (current: T | undefined) => T): ContextTransform => async (ctx: Context) => {\n\t\t\tconst currentValue = await ctx.get(key) as T | undefined\n\t\t\tconst newValue = fn(currentValue)\n\t\t\treturn await ctx.set(key, newValue)\n\t\t},\n\t}\n}\n\n/**\n * Composes multiple `ContextTransform` functions into a single `ContextTransform` function.\n * The transformations are applied in the order they are provided.\n *\n * @param transforms A sequence of `ContextTransform` functions.\n * @returns A single function that applies all transformations.\n */\nexport function composeContext(...transforms: ContextTransform[]): ContextTransform {\n\treturn async (ctx: Context) => {\n\t\tlet currentContext = ctx\n\t\tfor (const transform of transforms) {\n\t\t\tcurrentContext = await transform(currentContext)\n\t\t}\n\t\treturn currentContext\n\t}\n}\n"]}

package/dist/chunk-S4WFNGQG.js

@@ -1,17 +0,0 @@
-// src/workflow/registry.ts
-var flowConstructor;
-function registerFlow(constructor) {
-  flowConstructor = constructor;
-}
-function getFlowConstructor() {
-  if (!flowConstructor) {
-    throw new Error(
-      "Flow constructor has not been registered. This is an internal error in the framework, likely due to a module loading issue."
-    );
-  }
-  return flowConstructor;
-}
-
-export { getFlowConstructor, registerFlow };
-//# sourceMappingURL=chunk-S4WFNGQG.js.map
-//# sourceMappingURL=chunk-S4WFNGQG.js.map

package/dist/chunk-S4WFNGQG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/workflow/registry.ts"],"names":[],"mappings":";AAMA,IAAI,eAAA;AAMG,SAAS,aAAa,WAAA,EAAoC;AAChE,EAAA,eAAA,GAAkB,WAAA;AACnB;AAMO,SAAS,kBAAA,GAAsC;AACrD,EAAA,IAAI,CAAC,eAAA,EAAiB;AACrB,IAAA,MAAM,IAAI,KAAA;AAAA,MACT;AAAA,KACD;AAAA,EACD;AACA,EAAA,OAAO,eAAA;AACR","file":"chunk-S4WFNGQG.js","sourcesContent":["import type { AbstractNode } from './AbstractNode'\nimport type { Flow } from './Flow'\n\n// A type alias for the Flow class constructor.\ntype FlowConstructor = new (start?: AbstractNode) => Flow\n\nlet flowConstructor: FlowConstructor | undefined\n\n/**\n * For internal use by the Flow class to register itself, breaking the circular dependency.\n * @internal\n */\nexport function registerFlow(constructor: FlowConstructor): void {\n\tflowConstructor = constructor\n}\n\n/**\n * For internal use by the Node class to get the Flow constructor without a direct import.\n * @internal\n */\nexport function getFlowConstructor(): FlowConstructor {\n\tif (!flowConstructor) {\n\t\tthrow new Error(\n\t\t\t'Flow constructor has not been registered. This is an internal error in the framework, likely due to a module loading issue.',\n\t\t)\n\t}\n\treturn flowConstructor\n}\n"]}

package/dist/chunk-TS3M7MWA.js

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

package/dist/chunk-TS3M7MWA.js.map

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

package/dist/chunk-UY4PNPBX.js

@@ -1,156 +0,0 @@
-import { Node } from './chunk-HEO3XL4Z.js';
-import { InMemoryExecutor } from './chunk-BRFMFLR6.js';
-import { registerFlow } from './chunk-S4WFNGQG.js';
-
-// src/workflow/Flow.ts
-var Flow = class extends Node {
-  /** The first node to be executed in this flow's graph. */
-  startNode;
-  /** An array of middleware functions to be applied to every node within this flow. */
-  middleware = [];
-  /**
-   * @param start An optional node to start the flow with.
-   */
-  constructor(start) {
-    super();
-    this.startNode = start;
-  }
-  _wrapError(e, phase) {
-    if (phase === "exec") {
-      return e;
-    }
-    return super._wrapError(e, phase);
-  }
-  /**
-   * Adds a middleware function to this flow. Middleware will be executed in the
-   * order it is added, wrapping the execution of every node within this flow.
-   * @param fn The middleware function to add.
-   * @returns The `Flow` instance for chaining.
-   */
-  use(fn) {
-    this.middleware.push(fn);
-    return this;
-  }
-  /**
-   * Sets the starting node of the flow's graph.
-   * @param start The node to start with.
-   * @returns The start node instance, allowing for further chaining (`.next()`).
-   */
-  start(start) {
-    this.startNode = start;
-    return start;
-  }
-  /**
-   * (Lifecycle) Executes this flow's internal graph when it is used as a sub-flow
-   * (a node within a larger flow).
-   * @internal
-   * @param args The arguments for the node, passed down from the parent executor.
-   * @returns The final action returned by the last node in this flow's graph.
-   */
-  async exec(args) {
-    if (!(args.executor instanceof InMemoryExecutor)) {
-      throw new TypeError("Programmatic sub-flow execution is only supported by the InMemoryExecutor. For other environments, use GraphBuilder to create a single, flattened workflow.");
-    }
-    if (!this.startNode) {
-      return super.exec(args);
-    }
-    const combinedParams = { ...args.params, ...this.params };
-    const internalOptions = {
-      logger: args.logger,
-      signal: args.signal,
-      params: combinedParams,
-      executor: args.executor
-    };
-    const finalAction = await args.executor._orch(
-      this.startNode,
-      this.middleware,
-      args.ctx,
-      internalOptions
-    );
-    return finalAction;
-  }
-  /**
-   * (Lifecycle) The post-execution step for a `Flow` node. It simply passes through
-   * the final action from its internal graph execution (`execRes`).
-   * @internal
-   */
-  async post({ execRes }) {
-    return execRes;
-  }
-  /**
-   * Runs the entire flow as a top-level entry point.
-   * @param ctx The shared workflow context.
-   * @param options Runtime options like a logger, abort controller, or a custom executor.
-   * @returns The final action returned by the last node in the flow.
-   */
-  async run(ctx, options) {
-    const executor = options?.executor ?? new InMemoryExecutor();
-    return executor.run(this, ctx, options);
-  }
-  /**
-   * Finds a node within the flow's graph by its unique ID.
-   *
-   * This method performs a breadth-first search starting from the `startNode`.
-   * It is a convenient way to get a reference to a specific node instance
-   * for debugging or dynamic modifications.
-   *
-   * @remarks
-   * This performs a graph traversal on each call, which has a time complexity
-   * proportional to the number of nodes and edges in the graph (O(V+E)). For
-   * performance-critical applications or flows built with `GraphBuilder`,
-   * it is more efficient to use the `nodeMap` returned by `GraphBuilder.build()`.
-   *
-   * @param id The unique ID of the node to find (set via `.withId()` or by the `GraphBuilder`).
-   * @returns The `AbstractNode` instance if found, otherwise `undefined`.
-   */
-  getNodeById(id) {
-    if (!this.startNode)
-      return void 0;
-    const queue = [this.startNode];
-    const visited = /* @__PURE__ */ new Set([this.startNode]);
-    while (queue.length > 0) {
-      const currentNode = queue.shift();
-      if (currentNode.id === id)
-        return currentNode;
-      for (const successorArray of currentNode.successors.values()) {
-        for (const successor of successorArray) {
-          if (!visited.has(successor)) {
-            visited.add(successor);
-            queue.push(successor);
-          }
-        }
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Retrieves all unique nodes within the flow's graph.
-   * @internal
-   */
-  getAllNodes() {
-    const allNodes = /* @__PURE__ */ new Set();
-    if (!this.startNode)
-      return allNodes;
-    const queue = [this.startNode];
-    const visited = /* @__PURE__ */ new Set([this.startNode]);
-    allNodes.add(this.startNode);
-    while (queue.length > 0) {
-      const currentNode = queue.shift();
-      for (const successorArray of currentNode.successors.values()) {
-        for (const successor of successorArray) {
-          if (!visited.has(successor)) {
-            visited.add(successor);
-            queue.push(successor);
-            allNodes.add(successor);
-          }
-        }
-      }
-    }
-    return allNodes;
-  }
-};
-registerFlow(Flow);
-
-export { Flow };
-//# sourceMappingURL=chunk-UY4PNPBX.js.map
-//# sourceMappingURL=chunk-UY4PNPBX.js.map

package/dist/chunk-UY4PNPBX.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/workflow/Flow.ts"],"names":[],"mappings":"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","file":"chunk-UY4PNPBX.js","sourcesContent":["import type { Context } from '../context'\nimport type { InternalRunOptions } from '../executors/types'\nimport type { Middleware, NodeArgs, Params, RunOptions } from '../types'\nimport type { AbstractNode } from './AbstractNode'\nimport { InMemoryExecutor } from '../executors/in-memory'\nimport { Node } from './Node'\nimport { registerFlow } from './registry'\n\n/**\n * A special type of `Node` that orchestrates a graph of other nodes.\n * It can contain its own middleware and can be composed within other flows.\n *\n * @template PrepRes The type of data returned by the `prep` phase.\n * @template ExecRes The type of data returned by the `exec` phase (the final action).\n * @template TParams The type for the flow's static parameters.\n */\nexport class Flow<\n\tPrepRes = any,\n\tExecRes = any,\n\tTParams extends Params = Params,\n\tTContext extends Context = Context,\n> extends Node<PrepRes, ExecRes, ExecRes, TParams, TContext> {\n\t/** The first node to be executed in this flow's graph. */\n\tpublic startNode?: AbstractNode<any, any>\n\t/** An array of middleware functions to be applied to every node within this flow. */\n\tpublic middleware: Middleware[] = []\n\n\t/**\n\t * @param start An optional node to start the flow with.\n\t */\n\tconstructor(start?: AbstractNode<any, any, TContext>) {\n\t\tsuper()\n\t\tthis.startNode = start\n\t}\n\n\tprotected _wrapError(e: any, phase: 'prep' | 'exec' | 'post'): Error {\n\t\tif (phase === 'exec') {\n\t\t\t// Errors from a sub-flow's orchestration are already wrapped, so we pass them through.\n\t\t\treturn e\n\t\t}\n\t\treturn super._wrapError(e, phase)\n\t}\n\n\t/**\n\t * Adds a middleware function to this flow. Middleware will be executed in the\n\t * order it is added, wrapping the execution of every node within this flow.\n\t * @param fn The middleware function to add.\n\t * @returns The `Flow` instance for chaining.\n\t */\n\tpublic use(fn: Middleware): this {\n\t\tthis.middleware.push(fn)\n\t\treturn this\n\t}\n\n\t/**\n\t * Sets the starting node of the flow's graph.\n\t * @param start The node to start with.\n\t * @returns The start node instance, allowing for further chaining (`.next()`).\n\t */\n\tstart<StartNode extends AbstractNode<any, any, TContext>>(start: StartNode): StartNode {\n\t\tthis.startNode = start\n\t\treturn start\n\t}\n\n\t/**\n\t * (Lifecycle) Executes this flow's internal graph when it is used as a sub-flow\n\t * (a node within a larger flow).\n\t * @internal\n\t * @param args The arguments for the node, passed down from the parent executor.\n\t * @returns The final action returned by the last node in this flow's graph.\n\t */\n\tasync exec(args: NodeArgs<any, any, TParams, TContext>): Promise<ExecRes> {\n\t\t// For programmatic composition, a Flow node orchestrates its own graph.\n\t\t// This is a feature of the InMemoryExecutor. Distributed systems should\n\t\t// rely on pre-flattened graphs produced by the GraphBuilder.\n\t\tif (!(args.executor instanceof InMemoryExecutor)) {\n\t\t\tthrow new TypeError('Programmatic sub-flow execution is only supported by the InMemoryExecutor. For other environments, use GraphBuilder to create a single, flattened workflow.')\n\t\t}\n\n\t\tif (!this.startNode) {\n\t\t\t// This handles logic-bearing flows like BatchFlow that override exec directly.\n\t\t\treturn super.exec(args)\n\t\t}\n\n\t\tconst combinedParams = { ...args.params, ...this.params }\n\t\tconst internalOptions: InternalRunOptions = {\n\t\t\tlogger: args.logger,\n\t\t\tsignal: args.signal,\n\t\t\tparams: combinedParams,\n\t\t\texecutor: args.executor,\n\t\t}\n\n\t\tconst finalAction = await args.executor._orch<ExecRes>(\n\t\t\tthis.startNode,\n\t\t\tthis.middleware,\n\t\t\targs.ctx,\n\t\t\tinternalOptions,\n\t\t)\n\n\t\treturn finalAction as ExecRes\n\t}\n\n\t/**\n\t * (Lifecycle) The post-execution step for a `Flow` node. It simply passes through\n\t * the final action from its internal graph execution (`execRes`).\n\t * @internal\n\t */\n\tasync post({ execRes }: NodeArgs<PrepRes, ExecRes, TParams, TContext>): Promise<ExecRes> {\n\t\treturn execRes\n\t}\n\n\t/**\n\t * Runs the entire flow as a top-level entry point.\n\t * @param ctx The shared workflow context.\n\t * @param options Runtime options like a logger, abort controller, or a custom executor.\n\t * @returns The final action returned by the last node in the flow.\n\t */\n\tasync run(ctx: TContext, options?: RunOptions): Promise<ExecRes> {\n\t\tconst executor = options?.executor ?? new InMemoryExecutor()\n\t\treturn executor.run(this, ctx, options)\n\t}\n\n\t/**\n\t * Finds a node within the flow's graph by its unique ID.\n\t *\n\t * This method performs a breadth-first search starting from the `startNode`.\n\t * It is a convenient way to get a reference to a specific node instance\n\t * for debugging or dynamic modifications.\n\t *\n\t * @remarks\n\t * This performs a graph traversal on each call, which has a time complexity\n\t * proportional to the number of nodes and edges in the graph (O(V+E)). For\n\t * performance-critical applications or flows built with `GraphBuilder`,\n\t * it is more efficient to use the `nodeMap` returned by `GraphBuilder.build()`.\n\t *\n\t * @param id The unique ID of the node to find (set via `.withId()` or by the `GraphBuilder`).\n\t * @returns The `AbstractNode` instance if found, otherwise `undefined`.\n\t */\n\tpublic getNodeById(id: string | number): AbstractNode<any, any, TContext> | undefined {\n\t\tif (!this.startNode)\n\t\t\treturn undefined\n\n\t\tconst queue: AbstractNode<any, any, TContext>[] = [this.startNode]\n\t\tconst visited = new Set<AbstractNode<any, any, TContext>>([this.startNode])\n\t\twhile (queue.length > 0) {\n\t\t\tconst currentNode = queue.shift()!\n\n\t\t\tif (currentNode.id === id)\n\t\t\t\treturn currentNode\n\n\t\t\tfor (const successorArray of currentNode.successors.values()) {\n\t\t\t\tfor (const successor of successorArray) {\n\t\t\t\t\tif (!visited.has(successor)) {\n\t\t\t\t\t\tvisited.add(successor)\n\t\t\t\t\t\tqueue.push(successor)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn undefined\n\t}\n\n\t/**\n\t * Retrieves all unique nodes within the flow's graph.\n\t * @internal\n\t */\n\tpublic getAllNodes(): Set<AbstractNode> {\n\t\tconst allNodes = new Set<AbstractNode>()\n\t\tif (!this.startNode)\n\t\t\treturn allNodes\n\n\t\tconst queue: AbstractNode[] = [this.startNode]\n\t\tconst visited = new Set<AbstractNode>([this.startNode])\n\t\tallNodes.add(this.startNode)\n\n\t\twhile (queue.length > 0) {\n\t\t\tconst currentNode = queue.shift()!\n\t\t\tfor (const successorArray of currentNode.successors.values()) {\n\t\t\t\tfor (const successor of successorArray) {\n\t\t\t\t\tif (!visited.has(successor)) {\n\t\t\t\t\t\tvisited.add(successor)\n\t\t\t\t\t\tqueue.push(successor)\n\t\t\t\t\t\tallNodes.add(successor)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn allNodes\n\t}\n}\n\nregisterFlow(Flow)\n"]}