@girverket/xenocline 0.0.9

package/dist/execution/process.js

@@ -0,0 +1,115 @@
+import { executeNode } from './node.js';
+import { createAggregatorState } from './aggregator.js';
+import { EMPTY_INPUT } from '../input.js';
+import { validateProcess } from '../process.js';
+import { clean } from '../util/general.js';
+import { createProcessEvent } from '../event/process.js';
+import { createBeginningEvent } from '../event/transition.js';
+import { createEventState, dispatchEvent } from './event.js';
+
+const DEFAULT_PROCESS_EXECUTION_OPTIONS = {
+    input: EMPTY_INPUT,
+    context: {},
+    eventHandlers: []
+};
+async function executeProcess(processInstance, beginning, options) {
+    const processExecutionOptions = {
+        ...DEFAULT_PROCESS_EXECUTION_OPTIONS,
+        ...clean(options || {})
+    };
+    if (options && options.input) {
+        processExecutionOptions.input = options.input;
+    }
+    if (options && options.eventHandlers) {
+        processExecutionOptions.eventHandlers = options.eventHandlers;
+    }
+    const validationErrors = validateProcess(processInstance);
+    if (validationErrors.length > 0) {
+        const errorMessages = validationErrors.map((err)=>err.error).join('\n');
+        throw new Error(`Invalid process definition:\n${errorMessages}`);
+    }
+    const eventState = createEventState(processExecutionOptions.eventHandlers);
+    const state = {
+        process: processInstance,
+        context: processExecutionOptions.context,
+        results: {},
+        phaseResults: {},
+        activeExecutions: new Map(),
+        errors: [],
+        ...createAggregatorState(),
+        eventState: eventState
+    };
+    dispatchEvent(state.eventState, createProcessEvent(processInstance.name, 'start', processInstance, {
+        input: processExecutionOptions.input,
+        context: state.context
+    }), state.context);
+    dispatchEvent(state.eventState, createBeginningEvent(beginning.id, 'start', beginning, {
+        input: processExecutionOptions.input
+    }), state.context);
+    const initialInput = await beginning.begin(processExecutionOptions.input, state.context);
+    dispatchEvent(state.eventState, createBeginningEvent(beginning.id, 'begin', beginning, {
+        input: initialInput
+    }), state.context);
+    const initialNodeId = beginning.targetNodeId;
+    if (!state.process.phases[initialNodeId]) {
+        throw new Error(`Start phase ID "${initialNodeId}" not found in process phases.`);
+    }
+    try {
+        await executeNode(initialNodeId, initialInput, state);
+        const allPromises = Array.from(state.activeExecutions.values());
+        if (allPromises.length > 0) {
+            await Promise.all(allPromises);
+        }
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        state.errors.push({
+            message: "Critical error during process execution",
+            details: errorMessage,
+            nodeId: initialNodeId
+        });
+        // eslint-disable-next-line no-console
+        console.error("[EXECUTE_PROCESS_CRITICAL_ERROR]", {
+            processName: processInstance.name,
+            error: errorMessage,
+            collectedErrors: state.errors
+        });
+    }
+    // Check for and reject any pending aggregators that never completed
+    if (state.aggregatorDeferreds && state.aggregatorDeferreds.size > 0) {
+        const pendingNodeIds = state.pendingAggregatorIds ? state.pendingAggregatorIds().join(', ') : 'unknown';
+        // eslint-disable-next-line no-console
+        console.warn(`[EXECUTE_PROCESS_PENDING_AGGREGATORS] Process execution completed with pending aggregators: ${pendingNodeIds}. These will be rejected.`, {
+            processName: processInstance.name,
+            pendingNodeIds
+        });
+        // Reject all pending aggregators to prevent hanging promises
+        for (const nodeId of state.aggregatorDeferreds.keys()){
+            const deferred = state.aggregatorDeferreds.get(nodeId);
+            if (deferred) {
+                const error = new Error(`Aggregator node '${nodeId}' did not receive all expected inputs before process completion. This may indicate a process design issue where not all paths leading to the aggregator were executed.`);
+                deferred.reject(error);
+                state.errors.push({
+                    nodeId,
+                    message: error.message,
+                    details: {
+                        reason: 'incomplete_aggregation'
+                    }
+                });
+            }
+        }
+        // Clear the map after rejecting all
+        state.aggregatorDeferreds.clear();
+    }
+    dispatchEvent(state.eventState, createProcessEvent(processInstance.name, 'end', processInstance, {
+        input: processExecutionOptions.input,
+        context: state.context
+    }), state.context);
+    return [
+        state.results,
+        state.phaseResults,
+        state.context
+    ];
+}
+
+export { DEFAULT_PROCESS_EXECUTION_OPTIONS, executeProcess };
+//# sourceMappingURL=process.js.map

package/dist/execution/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sources":["../../src/execution/process.ts"],"sourcesContent":["import { executeNode } from './node';\nimport { Context } from '../context';\nimport {\n    AggregatorState,\n    createAggregatorState\n} from './aggregator';\nimport { EMPTY_INPUT, Input } from '../input';\nimport { Output } from '../output';\nimport { Process, validateProcess } from '../process';\nimport { Beginning } from '../transition/beginning';\nimport { clean } from '../util/general';\nimport { Event, EventHandler, EventState, createBeginningEvent, createEventState, createProcessEvent } from '../event';\nimport { dispatchEvent } from './event';\n\nexport interface PhaseResults {\n    [key: string]: Output;\n}\n\nexport interface ProcessResults {\n    [key: string]: Output;\n}\n\ninterface ProcessExecutionError {\n    message: string;\n    details?: any;\n    nodeId?: string;\n}\n\nexport interface ProcessExecutionOptions<I extends Input = Input, C extends Context = Context> {\n    input: I;\n    context: C;\n    eventHandlers?: ReadonlyArray<EventHandler<Event, C>>;\n}\n\nexport const DEFAULT_PROCESS_EXECUTION_OPTIONS: ProcessExecutionOptions<Input, Context> = {\n    input: EMPTY_INPUT,\n    context: {} as Context,\n    eventHandlers: [],\n}\n\nexport interface ExecutionState<C extends Context = Context> extends AggregatorState {\n    process: Readonly<Process>;\n    context: C;\n    phaseResults: Record<string, Output>;\n    results: Record<string, Output>;\n    activeExecutions: Map<string, Promise<Output>>;\n    errors: ProcessExecutionError[];\n    readonly eventState: Readonly<EventState<C>>;\n}\n\nexport async function executeProcess<I extends Input = Input, O extends Output = Output, C extends Context = Context>(\n    processInstance: Readonly<Process>,\n    beginning: Beginning<I, C>,\n    options?: Partial<ProcessExecutionOptions<I, C>>\n): Promise<[Record<string, O>, Record<string, O>, C]> {\n\n    const processExecutionOptions: ProcessExecutionOptions<I, C> = {\n        ...(DEFAULT_PROCESS_EXECUTION_OPTIONS as unknown as ProcessExecutionOptions<I, C>),\n        ...clean(options || {}),\n    };\n    if (options && options.input) {\n        processExecutionOptions.input = options.input;\n    }\n    if (options && options.eventHandlers) {\n        processExecutionOptions.eventHandlers = options.eventHandlers;\n    }\n\n    const validationErrors = validateProcess(processInstance);\n    if (validationErrors.length > 0) {\n        const errorMessages = validationErrors.map(err => err.error).join('\\n');\n        throw new Error(`Invalid process definition:\\n${errorMessages}`);\n    }\n\n    const eventState = createEventState<C>(processExecutionOptions.eventHandlers);\n\n    const state: ExecutionState<C> = {\n        process: processInstance,\n        context: processExecutionOptions.context as C,\n        results: {},\n        phaseResults: {},\n        activeExecutions: new Map<string, Promise<Output>>(),\n        errors: [],\n        ...createAggregatorState(),\n        eventState: eventState,\n    };\n\n    dispatchEvent(\n        state.eventState,\n        createProcessEvent(processInstance.name, 'start', processInstance, { input: processExecutionOptions.input, context: state.context }),\n        state.context\n    );\n\n    dispatchEvent(\n        state.eventState,\n        createBeginningEvent(beginning.id, 'start', beginning as Beginning<I, C>, { input: processExecutionOptions.input }),\n        state.context\n    );\n\n    const initialInput = await beginning.begin(processExecutionOptions.input, state.context);\n    dispatchEvent(\n        state.eventState,\n        createBeginningEvent(beginning.id, 'begin', beginning as Beginning<I, C>, { input: initialInput }),\n        state.context\n    );\n\n    const initialNodeId = beginning.targetNodeId;\n\n    if (!state.process.phases[initialNodeId]) {\n        throw new Error(`Start phase ID \"${initialNodeId}\" not found in process phases.`);\n    }\n\n    try {\n        await executeNode(initialNodeId, initialInput, state as unknown as ExecutionState<Context>);\n\n        const allPromises = Array.from(state.activeExecutions.values());\n        if (allPromises.length > 0) {\n            await Promise.all(allPromises);\n        }\n    } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        state.errors.push({ message: \"Critical error during process execution\", details: errorMessage, nodeId: initialNodeId });\n        // eslint-disable-next-line no-console\n        console.error(\"[EXECUTE_PROCESS_CRITICAL_ERROR]\", { processName: processInstance.name, error: errorMessage, collectedErrors: state.errors });\n    }\n\n    // Check for and reject any pending aggregators that never completed\n    if (state.aggregatorDeferreds && state.aggregatorDeferreds.size > 0) {\n        const pendingNodeIds = state.pendingAggregatorIds ? state.pendingAggregatorIds().join(', ') : 'unknown';\n        // eslint-disable-next-line no-console\n        console.warn(`[EXECUTE_PROCESS_PENDING_AGGREGATORS] Process execution completed with pending aggregators: ${pendingNodeIds}. These will be rejected.`, { processName: processInstance.name, pendingNodeIds });\n\n        // Reject all pending aggregators to prevent hanging promises\n        for (const nodeId of state.aggregatorDeferreds.keys()) {\n            const deferred = state.aggregatorDeferreds.get(nodeId);\n            if (deferred) {\n                const error = new Error(`Aggregator node '${nodeId}' did not receive all expected inputs before process completion. This may indicate a process design issue where not all paths leading to the aggregator were executed.`);\n                deferred.reject(error);\n                state.errors.push({\n                    nodeId,\n                    message: error.message,\n                    details: { reason: 'incomplete_aggregation' }\n                });\n            }\n        }\n        // Clear the map after rejecting all\n        state.aggregatorDeferreds.clear();\n    }\n\n    dispatchEvent(\n        state.eventState,\n        createProcessEvent(processInstance.name, 'end', processInstance, { input: processExecutionOptions.input, context: state.context }),\n        state.context\n    );\n\n    return [state.results as Record<string, O>, state.phaseResults as Record<string, O>, state.context];\n}\n\n\n"],"names":["DEFAULT_PROCESS_EXECUTION_OPTIONS","input","EMPTY_INPUT","context","eventHandlers","executeProcess","processInstance","beginning","options","processExecutionOptions","clean","validationErrors","validateProcess","length","errorMessages","map","err","error","join","Error","eventState","createEventState","state","process","results","phaseResults","activeExecutions","Map","errors","createAggregatorState","dispatchEvent","createProcessEvent","name","createBeginningEvent","id","initialInput","begin","initialNodeId","targetNodeId","phases","executeNode","allPromises","Array","from","values","Promise","all","errorMessage","message","String","push","details","nodeId","console","processName","collectedErrors","aggregatorDeferreds","size","pendingNodeIds","pendingAggregatorIds","warn","keys","deferred","get","reject","reason","clear"],"mappings":"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"}

package/dist/input.d.ts

@@ -0,0 +1,6 @@
+export interface Input {
+    [key: string]: unknown;
+}
+export declare const EMPTY_INPUT: Input;
+export declare const isInput: (input: unknown) => input is Input;
+export declare const validateInput: (input: unknown) => input is Input;

package/dist/input.js

@@ -0,0 +1,4 @@
+const EMPTY_INPUT = {};
+
+export { EMPTY_INPUT };
+//# sourceMappingURL=input.js.map

package/dist/input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sources":["../src/input.ts"],"sourcesContent":["export interface Input {\n    [key: string]: unknown;\n}\n\nexport const EMPTY_INPUT: Input = {};\n\nexport const isInput = (input: unknown): input is Input => {\n    return typeof input === 'object' && input !== null && !Array.isArray(input);\n};\n\nexport const validateInput = (input: unknown): input is Input => {\n    if (!isInput(input)) {\n        throw new Error('Input must be an object');\n    }\n    return true;\n};\n"],"names":["EMPTY_INPUT"],"mappings":"AAIO,MAAMA,WAAAA,GAAqB;;;;"}

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'verbose' | 'silly';
+export interface Logger {
+    name: string;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    verbose: (message: string, ...args: any[]) => void;
+    silly: (message: string, ...args: any[]) => void;
+}
+export declare const DEFAULT_LOGGER: Logger;
+export declare const wrapLogger: (toWrap: Logger, name?: string) => Logger;

package/dist/node/aggregatornode.d.ts

@@ -0,0 +1,40 @@
+import { Aggregator } from '../aggregator';
+import { Next } from '../transition/next';
+import { Context } from '../context';
+import { Output } from '../output';
+import { Node } from './node';
+/**
+ * Represents a node in the process that aggregates multiple inputs of type IA
+ * into a single output of type O.
+ *
+ * @template O - The type of the output produced by this node's aggregate function. Must extend Output.
+ * @template C - The type of the context object passed to the aggregate function. Must extend Context.
+ */
+export interface AggregatorNode<O extends Output = Output, // Output from the aggregate function
+C extends Context = Context> extends Node<O, C> {
+    type: 'aggregator';
+    /**
+     * The core aggregation logic for this node.
+     * It takes an array of input items and a context, and returns a Promise resolving to the aggregated output.
+     * @param input - An input item of type Input.
+     * @param context - The context object.
+     * @returns A Promise that resolves to the aggregated output of type O.
+     */
+    aggregator: Aggregator<O, C>;
+}
+export interface AggregatorNodeOptions<O extends Output = Output, C extends Context = Context> {
+    next?: Next<O, C>;
+}
+export declare const DEFAULT_AGGREGATOR_NODE_OPTIONS: AggregatorNodeOptions<Output, Context>;
+export declare const createAggregatorNode: <O extends Output = Output, C extends Context = Context>(id: string, aggregator: Aggregator<O, C>, options?: Partial<AggregatorNodeOptions<O, C>>) => Readonly<AggregatorNode<O, C>>;
+/**
+ * Type guard to check if an object is an AggregatorNode.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is an AggregatorNode, false otherwise.
+ */
+export declare const isAggregatorNode: (obj: any) => obj is AggregatorNode<any, any>;
+export declare const validateAggregatorNode: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/node/aggregatornode.js

@@ -0,0 +1,41 @@
+import { clean } from '../util/general.js';
+import { createNode, isNode } from './node.js';
+
+const DEFAULT_AGGREGATOR_NODE_OPTIONS = {};
+const createAggregatorNode = (id, aggregator, options)=>{
+    let aggregatorNodeOptions = {
+        ...DEFAULT_AGGREGATOR_NODE_OPTIONS
+    };
+    if (options) {
+        aggregatorNodeOptions = {
+            ...aggregatorNodeOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createNode('aggregator', id, {
+            next: aggregatorNodeOptions.next
+        }),
+        aggregator
+    };
+};
+/**
+ * Type guard to check if an object is an AggregatorNode.
+ *
+ * @param obj - The object to check.
+ * @returns True if the object is an AggregatorNode, false otherwise.
+ */ const isAggregatorNode = (obj)=>{
+    if (!isNode(obj) || obj.type !== 'aggregator') {
+        return false;
+    }
+    // At this point, obj is a Node with type 'aggregator'.
+    // Now check for AggregatorNode specific properties.
+    const potentialAggNode = obj; // Cast to access specific props
+    if (!(typeof potentialAggNode.aggregator === 'object' && potentialAggNode.aggregator !== null && typeof potentialAggNode.aggregator.aggregate === 'function')) {
+        return false;
+    }
+    return true; // Not Termination and not a recognized array type for 'next'
+};
+
+export { DEFAULT_AGGREGATOR_NODE_OPTIONS, createAggregatorNode, isAggregatorNode };
+//# sourceMappingURL=aggregatornode.js.map

package/dist/node/aggregatornode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatornode.js","sources":["../../src/node/aggregatornode.ts"],"sourcesContent":["import { Aggregator, validateAggregator } from '../aggregator';\nimport { Next } from '../transition/next';\nimport { Context } from '../context';\nimport { Output } from '../output';\nimport { createNode, isNode, Node, validateNode } from './node';\nimport { clean } from '../util/general';\n\n/**\n * Represents a node in the process that aggregates multiple inputs of type IA\n * into a single output of type O.\n *\n * @template O - The type of the output produced by this node's aggregate function. Must extend Output.\n * @template C - The type of the context object passed to the aggregate function. Must extend Context.\n */\nexport interface AggregatorNode<\n    O extends Output = Output,   // Output from the aggregate function\n    C extends Context = Context, // Context object\n> extends Node<O, C> { // MODIFIED: Extends Node\n    type: 'aggregator'; // Overrides Node.type\n    // id: string; // Unique identifier for this aggregator node within the process - inherited from Node\n\n    /**\n     * The core aggregation logic for this node.\n     * It takes an array of input items and a context, and returns a Promise resolving to the aggregated output.\n     * @param input - An input item of type Input.\n     * @param context - The context object.\n     * @returns A Promise that resolves to the aggregated output of type O.\n     */\n    aggregator: Aggregator<O, C>;\n}\n\nexport interface AggregatorNodeOptions<O extends Output = Output, C extends Context = Context> {\n    next?: Next<O, C>;\n}\n\nexport const DEFAULT_AGGREGATOR_NODE_OPTIONS: AggregatorNodeOptions<Output, Context> = {\n}\n\nexport const createAggregatorNode = <O extends Output = Output, C extends Context = Context>(\n    id: string,\n    aggregator: Aggregator<O, C>,\n    options?: Partial<AggregatorNodeOptions<O, C>>\n): Readonly<AggregatorNode<O, C>> => {\n    let aggregatorNodeOptions: AggregatorNodeOptions<O, C> = { ...DEFAULT_AGGREGATOR_NODE_OPTIONS } as unknown as AggregatorNodeOptions<O, C>;\n    if (options) {\n        aggregatorNodeOptions = { ...aggregatorNodeOptions, ...clean(options) };\n    }\n\n    return {\n        ...createNode('aggregator', id, { next: aggregatorNodeOptions.next }),\n        aggregator,\n    } as AggregatorNode<O, C>;\n};\n\n\n/**\n * Type guard to check if an object is an AggregatorNode.\n *\n * @param obj - The object to check.\n * @returns True if the object is an AggregatorNode, false otherwise.\n */\nexport const isAggregatorNode = (obj: any): obj is AggregatorNode<any, any> => {\n    if (!isNode(obj) || obj.type !== 'aggregator') {\n        return false;\n    }\n\n    // At this point, obj is a Node with type 'aggregator'.\n    // Now check for AggregatorNode specific properties.\n    const potentialAggNode = obj as AggregatorNode<any, any>; // Cast to access specific props\n\n    if (!(\n        typeof potentialAggNode.aggregator === 'object' && potentialAggNode.aggregator !== null && typeof potentialAggNode.aggregator.aggregate === 'function'\n    )) {\n        return false;\n    }\n\n    return true; // Not Termination and not a recognized array type for 'next'\n};\n\nexport const validateAggregatorNode = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'AggregatorNode'];\n\n    errors.push(...validateNode(item, currentCoordinates));\n\n    currentCoordinates.push(`AggregatorNode: ${item.id}`);\n\n    if (item.aggregator === undefined) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'aggregator is undefined.' });\n    } else {\n        errors.push(...validateAggregator(item.aggregator, currentCoordinates));\n    }\n\n    return errors;\n};"],"names":["DEFAULT_AGGREGATOR_NODE_OPTIONS","createAggregatorNode","id","aggregator","options","aggregatorNodeOptions","clean","createNode","next","isAggregatorNode","obj","isNode","type","potentialAggNode","aggregate"],"mappings":";;;AAmCO,MAAMA,+BAAAA,GAA0E;AAGhF,MAAMC,oBAAAA,GAAuB,CAChCC,EAAAA,EACAC,UAAAA,EACAC,OAAAA,GAAAA;AAEA,IAAA,IAAIC,qBAAAA,GAAqD;AAAE,QAAA,GAAGL;AAAgC,KAAA;AAC9F,IAAA,IAAII,OAAAA,EAAS;QACTC,qBAAAA,GAAwB;AAAE,YAAA,GAAGA,qBAAqB;AAAE,YAAA,GAAGC,MAAMF,OAAAA;AAAS,SAAA;AAC1E,IAAA;IAEA,OAAO;QACH,GAAGG,UAAAA,CAAW,cAAcL,EAAAA,EAAI;AAAEM,YAAAA,IAAAA,EAAMH,sBAAsBG;SAAK,CAAE;AACrEL,QAAAA;AACJ,KAAA;AACJ;AAGA;;;;;IAMO,MAAMM,gBAAAA,GAAmB,CAACC,GAAAA,GAAAA;AAC7B,IAAA,IAAI,CAACC,MAAAA,CAAOD,GAAAA,CAAAA,IAAQA,GAAAA,CAAIE,IAAI,KAAK,YAAA,EAAc;QAC3C,OAAO,KAAA;AACX,IAAA;;;IAIA,MAAMC,gBAAAA,GAAmBH;AAEzB,IAAA,IAAI,EACA,OAAOG,iBAAiBV,UAAU,KAAK,YAAYU,gBAAAA,CAAiBV,UAAU,KAAK,IAAA,IAAQ,OAAOU,gBAAAA,CAAiBV,UAAU,CAACW,SAAS,KAAK,UAAS,CAAA,EACtJ;QACC,OAAO,KAAA;AACX,IAAA;AAEA,IAAA,OAAO;AACX;;;;"}

package/dist/node/node.d.ts

@@ -0,0 +1,18 @@
+import { Context } from '../context';
+import { Output } from '../output';
+import { Next } from '../transition/next';
+export interface Node<O extends Output = Output, C extends Context = Context> {
+    id: string;
+    type: 'aggregator' | 'phase';
+    next?: Next<O, C>;
+}
+export interface NodeOptions<O extends Output = Output, C extends Context = Context> {
+    next?: Next<O, C>;
+}
+export declare const DEFAULT_NODE_OPTIONS: NodeOptions<Output, Context>;
+export declare const createNode: <O extends Output = Output, C extends Context = Context>(type: "aggregator" | "phase", id: string, options?: Partial<NodeOptions<O, C>>) => Readonly<Node<O, C>>;
+export declare const isNode: (item: any) => item is Node;
+export declare const validateNode: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/node/node.js

@@ -0,0 +1,80 @@
+import { clean } from '../util/general.js';
+import { validateNext, isNext } from '../transition/next.js';
+
+const DEFAULT_NODE_OPTIONS = {};
+const createNode = (type, id, options)=>{
+    let nodeOptions = {
+        ...DEFAULT_NODE_OPTIONS
+    };
+    if (options) {
+        nodeOptions = {
+            ...nodeOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        id,
+        type,
+        next: nodeOptions.next
+    };
+};
+const isNode = (item)=>{
+    return item !== null && typeof item === 'object' && typeof item.id === 'string' && (item.type === 'aggregator' || item.type === 'phase') && (item.next === undefined || isNext(item.next));
+};
+const validateNode = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Node'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Node is undefined or null.'
+        });
+        return errors;
+    }
+    if (typeof item !== 'object') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Node is not an object.'
+        });
+        return errors;
+    }
+    if (item.id === undefined || typeof item.id !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Node id is undefined or not a string.'
+        });
+    }
+    if (item.type === undefined || typeof item.type !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Node type is undefined or not a string.'
+        });
+    }
+    if (item.type !== 'aggregator' && item.type !== 'phase') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Node type is not a valid type.'
+        });
+    }
+    currentCoordinates.push(`Node: ${item.id}`);
+    if (item.next !== undefined) {
+        errors.push(...validateNext(item.next, currentCoordinates));
+    }
+    return errors;
+};
+
+export { DEFAULT_NODE_OPTIONS, createNode, isNode, validateNode };
+//# sourceMappingURL=node.js.map

package/dist/node/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sources":["../../src/node/node.ts"],"sourcesContent":["import { clean } from \"../util/general\";\nimport { Context } from \"../context\";\nimport { Output } from \"../output\";\nimport { isNext, Next, validateNext } from \"../transition/next\";\n\nexport interface Node<O extends Output = Output, C extends Context = Context> {\n    id: string;\n    type: 'aggregator' | 'phase';\n\n    // The next step can be a direct termination, a list of connections, or a list of decisions,\n    // all based on the output O of this aggregator node.  Note that next can be undefined, when that happens \n    // a termination transition is assumed.\n    next?: Next<O, C>;\n}\n\nexport interface NodeOptions<O extends Output = Output, C extends Context = Context> {\n    next?: Next<O, C>;\n}\n\nexport const DEFAULT_NODE_OPTIONS: NodeOptions<Output, Context> = {\n}\n\nexport const createNode = <O extends Output = Output, C extends Context = Context>(type: 'aggregator' | 'phase', id: string, options?: Partial<NodeOptions<O, C>>): Readonly<Node<O, C>> => {\n    let nodeOptions: NodeOptions<O, C> = { ...DEFAULT_NODE_OPTIONS } as unknown as NodeOptions<O, C>;\n    if (options) {\n        nodeOptions = { ...nodeOptions, ...clean(options) };\n    }\n\n    return {\n        id,\n        type,\n        next: nodeOptions.next,\n    };\n};\n\nexport const isNode = (item: any): item is Node => {\n    return item !== null && typeof item === 'object' && typeof item.id === 'string' && (item.type === 'aggregator' || item.type === 'phase') && (item.next === undefined || isNext(item.next));\n};\n\nexport const validateNode = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'Node'];\n\n\n    if (item === undefined || item === null) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Node is undefined or null.' });\n        return errors;\n    }\n\n    if (typeof item !== 'object') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Node is not an object.' });\n        return errors;\n    }\n\n    if (item.id === undefined || typeof item.id !== 'string') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Node id is undefined or not a string.' });\n    }\n\n    if (item.type === undefined || typeof item.type !== 'string') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Node type is undefined or not a string.' });\n    }\n\n    if (item.type !== 'aggregator' && item.type !== 'phase') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Node type is not a valid type.' });\n    }\n\n    currentCoordinates.push(`Node: ${item.id}`);\n\n    if (item.next !== undefined) {\n        errors.push(...validateNext(item.next, currentCoordinates));\n    }\n\n    return errors;\n}"],"names":["DEFAULT_NODE_OPTIONS","createNode","type","id","options","nodeOptions","clean","next","isNode","item","undefined","isNext","validateNode","coordinates","errors","currentCoordinates","push","error","validateNext"],"mappings":"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"}

package/dist/node/phasenode.d.ts

@@ -0,0 +1,49 @@
+import { Next } from '../transition/next';
+import { Context } from '../context';
+import { Input } from '../input';
+import { Output } from '../output';
+import { Phase } from '../phase';
+import { Node } from './node';
+export type ProcessMethod<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[O, C]>;
+export type PrepareMethod<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<[I, C]>;
+export interface PhaseNode<I extends Input = Input, // Input to this phase instance
+O extends Output = Output> extends Node {
+    type: 'phase';
+    phase: Phase<I, O>;
+    /**
+     * The prepare method is called before the phase is executed.
+     * It receives the input and current context, and returns both (potentially modified).
+     * The returned context replaces the process context.
+     *
+     * CONCURRENCY WARNING: In processes with parallel execution paths (fan-out),
+     * multiple nodes may execute simultaneously. Each node's prepare method receives
+     * the shared context and can modify it. These modifications happen sequentially
+     * within each node but parallel nodes may overwrite each other's context changes.
+     *
+     * Best practice: Use unique context keys per node/path to avoid conflicts,
+     * or ensure context modifications are idempotent and merge-safe.
+     */
+    prepare?: PrepareMethod;
+    /**
+     * The process method is called after the phase is executed, but before the next node is executed.
+     * It receives the phase output and current context, and returns both (potentially modified).
+     * The returned context replaces the process context.
+     *
+     * CONCURRENCY WARNING: Same as prepare - parallel execution paths may cause
+     * context mutations to overwrite each other. Design your context updates carefully
+     * when using fan-out patterns.
+     */
+    process?: ProcessMethod;
+}
+export interface PhaseNodeOptions<I extends Input = Input, O extends Output = Output, C extends Context = Context> {
+    next?: Next<O, C>;
+    prepare?: PrepareMethod<I, C>;
+    process?: ProcessMethod<O, C>;
+}
+export declare const DEFAULT_PHASE_NODE_OPTIONS: PhaseNodeOptions<Input, Output, Context>;
+export declare const createPhaseNode: <I extends Input = Input, O extends Output = Output, C extends Context = Context>(id: string, phase: Phase<I, O>, options?: Partial<PhaseNodeOptions<I, O, C>>) => Readonly<PhaseNode<I, O>>;
+export declare const isPhaseNode: (obj: any) => obj is PhaseNode<any, any>;
+export declare const validatePhaseNode: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/node/phasenode.js

@@ -0,0 +1,37 @@
+import { isPhase } from '../phase.js';
+import { createNode, isNode } from './node.js';
+import { clean } from '../util/general.js';
+
+const DEFAULT_PHASE_NODE_OPTIONS = {};
+const createPhaseNode = (id, phase, options)=>{
+    let phaseNodeOptions = {
+        ...DEFAULT_PHASE_NODE_OPTIONS
+    };
+    if (options) {
+        phaseNodeOptions = {
+            ...phaseNodeOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createNode('phase', id, {
+            next: phaseNodeOptions.next
+        }),
+        phase,
+        prepare: phaseNodeOptions.prepare,
+        process: phaseNodeOptions.process
+    };
+};
+const isPhaseNode = (obj)=>{
+    if (!isNode(obj) || obj.type !== 'phase') {
+        return false;
+    }
+    const potentialPhaseNode = obj;
+    if (!(potentialPhaseNode.phase && typeof potentialPhaseNode.phase === 'object' && isPhase(potentialPhaseNode.phase))) {
+        return false;
+    }
+    return true;
+};
+
+export { DEFAULT_PHASE_NODE_OPTIONS, createPhaseNode, isPhaseNode };
+//# sourceMappingURL=phasenode.js.map

package/dist/node/phasenode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phasenode.js","sources":["../../src/node/phasenode.ts"],"sourcesContent":["import { Next } from '../transition/next';\nimport { Context } from '../context';\nimport { Input } from '../input';\nimport { Output } from '../output';\nimport { isPhase, Phase, validatePhase } from '../phase';\nimport { createNode, isNode, Node, validateNode } from './node';\nimport { clean } from '../util/general';\n\nexport type ProcessMethod<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[O, C]>;\nexport type PrepareMethod<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<[I, C]>;\n\nexport interface PhaseNode<\n    I extends Input = Input,        // Input to this phase instance\n    O extends Output = Output,      // Output from this phase instance\n> extends Node {\n    type: 'phase';\n    phase: Phase<I, O>; // The actual phase instance\n\n    /**\n     * The prepare method is called before the phase is executed.\n     * It receives the input and current context, and returns both (potentially modified).\n     * The returned context replaces the process context.\n     *\n     * CONCURRENCY WARNING: In processes with parallel execution paths (fan-out),\n     * multiple nodes may execute simultaneously. Each node's prepare method receives\n     * the shared context and can modify it. These modifications happen sequentially\n     * within each node but parallel nodes may overwrite each other's context changes.\n     *\n     * Best practice: Use unique context keys per node/path to avoid conflicts,\n     * or ensure context modifications are idempotent and merge-safe.\n     */\n    prepare?: PrepareMethod;\n\n    /**\n     * The process method is called after the phase is executed, but before the next node is executed.\n     * It receives the phase output and current context, and returns both (potentially modified).\n     * The returned context replaces the process context.\n     *\n     * CONCURRENCY WARNING: Same as prepare - parallel execution paths may cause\n     * context mutations to overwrite each other. Design your context updates carefully\n     * when using fan-out patterns.\n     */\n    process?: ProcessMethod;\n}\n\nexport interface PhaseNodeOptions<I extends Input = Input, O extends Output = Output, C extends Context = Context> {\n    next?: Next<O, C>;\n    prepare?: PrepareMethod<I, C>;\n    process?: ProcessMethod<O, C>;\n}\n\nexport const DEFAULT_PHASE_NODE_OPTIONS: PhaseNodeOptions<Input, Output, Context> = {\n}\n\nexport const createPhaseNode = <I extends Input = Input, O extends Output = Output, C extends Context = Context>(\n    id: string,\n    phase: Phase<I, O>,\n    options?: Partial<PhaseNodeOptions<I, O, C>>\n): Readonly<PhaseNode<I, O>> => {\n    let phaseNodeOptions: PhaseNodeOptions<I, O, C> = { ...DEFAULT_PHASE_NODE_OPTIONS } as unknown as PhaseNodeOptions<I, O, C>;\n    if (options) {\n        phaseNodeOptions = { ...phaseNodeOptions, ...clean(options) };\n    }\n\n    return {\n        ...createNode('phase', id, { next: phaseNodeOptions.next }),\n        phase,\n        prepare: phaseNodeOptions.prepare,\n        process: phaseNodeOptions.process,\n    } as PhaseNode<I, O>;\n};\n\nexport const isPhaseNode = (obj: any): obj is PhaseNode<any, any> => {\n    if (!isNode(obj) || obj.type !== 'phase') {\n        return false;\n    }\n    const potentialPhaseNode = obj as PhaseNode<any, any>;\n\n    if (!(\n        potentialPhaseNode.phase && typeof potentialPhaseNode.phase === 'object' && isPhase(potentialPhaseNode.phase)\n    )) {\n        return false;\n    }\n\n    return true;\n};\n\nexport const validatePhaseNode = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'PhaseNode'];\n\n    errors.push(...validateNode(item, currentCoordinates));\n\n    currentCoordinates.push(`PhaseNode: ${item.id}`);\n\n    if (item.phase === undefined) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'phase is undefined.' });\n    } else {\n        errors.push(...validatePhase(item.phase, currentCoordinates));\n    }\n\n    return errors;\n};\n"],"names":["DEFAULT_PHASE_NODE_OPTIONS","createPhaseNode","id","phase","options","phaseNodeOptions","clean","createNode","next","prepare","process","isPhaseNode","obj","isNode","type","potentialPhaseNode","isPhase"],"mappings":";;;;AAmDO,MAAMA,0BAAAA,GAAuE;AAG7E,MAAMC,eAAAA,GAAkB,CAC3BC,EAAAA,EACAC,KAAAA,EACAC,OAAAA,GAAAA;AAEA,IAAA,IAAIC,gBAAAA,GAA8C;AAAE,QAAA,GAAGL;AAA2B,KAAA;AAClF,IAAA,IAAII,OAAAA,EAAS;QACTC,gBAAAA,GAAmB;AAAE,YAAA,GAAGA,gBAAgB;AAAE,YAAA,GAAGC,MAAMF,OAAAA;AAAS,SAAA;AAChE,IAAA;IAEA,OAAO;QACH,GAAGG,UAAAA,CAAW,SAASL,EAAAA,EAAI;AAAEM,YAAAA,IAAAA,EAAMH,iBAAiBG;SAAK,CAAE;AAC3DL,QAAAA,KAAAA;AACAM,QAAAA,OAAAA,EAASJ,iBAAiBI,OAAO;AACjCC,QAAAA,OAAAA,EAASL,iBAAiBK;AAC9B,KAAA;AACJ;AAEO,MAAMC,cAAc,CAACC,GAAAA,GAAAA;AACxB,IAAA,IAAI,CAACC,MAAAA,CAAOD,GAAAA,CAAAA,IAAQA,GAAAA,CAAIE,IAAI,KAAK,OAAA,EAAS;QACtC,OAAO,KAAA;AACX,IAAA;AACA,IAAA,MAAMC,kBAAAA,GAAqBH,GAAAA;AAE3B,IAAA,IAAI,EACAG,kBAAAA,CAAmBZ,KAAK,IAAI,OAAOY,kBAAAA,CAAmBZ,KAAK,KAAK,QAAA,IAAYa,OAAAA,CAAQD,kBAAAA,CAAmBZ,KAAK,CAAA,CAAA,EAC7G;QACC,OAAO,KAAA;AACX,IAAA;IAEA,OAAO,IAAA;AACX;;;;"}

package/dist/output.d.ts

@@ -0,0 +1,6 @@
+export interface Output {
+    [key: string]: unknown;
+}
+export declare const EMPTY_OUTPUT: Output;
+export declare const isOutput: (output: unknown) => output is Output;
+export declare const validateOutput: (output: unknown) => output is Output;

package/dist/phase.d.ts

@@ -0,0 +1,23 @@
+import { Input } from './input';
+import { Output } from './output';
+export interface VerifyMethodResponse {
+    verified: boolean;
+    messages: string[];
+}
+export type VerifyMethod<I extends Input = Input> = (input: I) => Promise<VerifyMethodResponse>;
+export type ExecuteMethod<T extends Input = Input, U extends Output = Output> = (input: T) => Promise<U>;
+export interface Phase<T extends Input = Input, U extends Output = Output> {
+    name: string;
+    verify?: VerifyMethod<T>;
+    execute: (input: T) => Promise<U>;
+}
+export interface PhaseOptions<T extends Input = Input, U extends Output = Output> {
+    execute: ExecuteMethod<T, U>;
+    verify?: VerifyMethod<T>;
+}
+export declare const createPhase: <T extends Input = Input, U extends Output = Output>(name: string, options: Partial<PhaseOptions<T, U>>) => Readonly<Phase<T, U>>;
+export declare const isPhase: <T extends Input = Input, U extends Output = Output>(obj: any) => obj is Phase<T, U>;
+export declare const validatePhase: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/phase.js

@@ -0,0 +1,24 @@
+import { clean } from './util/general.js';
+
+const createPhase = (name, options)=>{
+    const defaultOptions = {
+        execute: async (input)=>{
+            return input;
+        }
+    };
+    const phaseOptions = {
+        ...defaultOptions,
+        ...clean(options)
+    };
+    return {
+        name,
+        execute: phaseOptions.execute,
+        verify: phaseOptions.verify
+    };
+};
+const isPhase = (obj)=>{
+    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.execute === 'function';
+};
+
+export { createPhase, isPhase };
+//# sourceMappingURL=phase.js.map

package/dist/phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase.js","sources":["../src/phase.ts"],"sourcesContent":["import { clean } from \"./util/general\";\nimport { Input } from \"./input\";\nimport { Output } from \"./output\";\n\nexport interface VerifyMethodResponse {\n    verified: boolean;\n    messages: string[];\n}\n\nexport type VerifyMethod<I extends Input = Input> = (input: I) => Promise<VerifyMethodResponse>;\n\nexport type ExecuteMethod<T extends Input = Input, U extends Output = Output> = (input: T) => Promise<U>;\n\nexport interface Phase<T extends Input = Input, U extends Output = Output> {\n    name: string;\n    verify?: VerifyMethod<T>;\n    execute: (input: T) => Promise<U>;\n}\n\nexport interface PhaseOptions<T extends Input = Input, U extends Output = Output> {\n    execute: ExecuteMethod<T, U>;\n    verify?: VerifyMethod<T>;\n}\n\n\nexport const createPhase = <T extends Input = Input, U extends Output = Output>(\n    name: string,\n    options: Partial<PhaseOptions<T, U>>\n): Readonly<Phase<T, U>> => {\n\n    const defaultOptions: PhaseOptions<T, U> = {\n        execute: async (input: T) => {\n            return input as unknown as U;\n        }\n    };\n\n    const phaseOptions: PhaseOptions<T, U> = { ...defaultOptions, ...clean(options) };\n\n    return {\n        name,\n        execute: phaseOptions.execute,\n        verify: phaseOptions.verify,\n    };\n}\n\nexport const isPhase = <T extends Input = Input, U extends Output = Output>(obj: any): obj is Phase<T, U> => {\n    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.execute === 'function';\n}\n\nexport const validatePhase = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'Phase'];\n\n    if (item === undefined || item === null) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Phase is undefined or null.' });\n        return errors;\n    }\n\n    if (item.name === undefined || typeof item.name !== 'string') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Phase name is undefined or not a string.' });\n    }\n\n    currentCoordinates.push(`Phase: ${item.name}`);\n\n    if (item.execute === undefined || typeof item.execute !== 'function') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Phase execute is undefined or not a function.' });\n    }\n\n    return errors;\n}"],"names":["createPhase","name","options","defaultOptions","execute","input","phaseOptions","clean","verify","isPhase","obj","undefined"],"mappings":";;AAyBO,MAAMA,WAAAA,GAAc,CACvBC,IAAAA,EACAC,OAAAA,GAAAA;AAGA,IAAA,MAAMC,cAAAA,GAAqC;AACvCC,QAAAA,OAAAA,EAAS,OAAOC,KAAAA,GAAAA;YACZ,OAAOA,KAAAA;AACX,QAAA;AACJ,KAAA;AAEA,IAAA,MAAMC,YAAAA,GAAmC;AAAE,QAAA,GAAGH,cAAc;AAAE,QAAA,GAAGI,MAAML,OAAAA;AAAS,KAAA;IAEhF,OAAO;AACHD,QAAAA,IAAAA;AACAG,QAAAA,OAAAA,EAASE,aAAaF,OAAO;AAC7BI,QAAAA,MAAAA,EAAQF,aAAaE;AACzB,KAAA;AACJ;AAEO,MAAMC,UAAU,CAAqDC,GAAAA,GAAAA;AACxE,IAAA,OAAOA,GAAAA,KAAQC,SAAAA,IAAaD,GAAAA,KAAQ,IAAA,IAAQ,OAAOA,GAAAA,KAAQ,QAAA,IAAY,OAAOA,GAAAA,CAAIT,IAAI,KAAK,QAAA,IAAY,OAAOS,GAAAA,CAAIN,OAAO,KAAK,UAAA;AAClI;;;;"}

package/dist/process.d.ts

@@ -0,0 +1,15 @@
+import { AggregatorNode } from './node/aggregatornode';
+import { PhaseNode } from './node/phasenode';
+export interface ProcessOptions {
+    phases: Record<string, PhaseNode | AggregatorNode>;
+}
+export interface Process {
+    name: string;
+    phases: Record<string, PhaseNode | AggregatorNode>;
+}
+export declare const createProcess: (name: string, options: Partial<ProcessOptions>) => Readonly<Process>;
+export declare const isProcess: (obj: any) => obj is Process;
+export declare const validateProcess: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;