@maxdrellin/xenocline 0.0.1

package/dist/execution/next.js

@@ -0,0 +1,116 @@
+import { executeNode } from './node.js';
+import { isConnection } from '../transition/connection.js';
+import { isDecision } from '../transition/decision.js';
+import { isTermination } from '../transition/termination.js';
+import { dispatchEvent } from './event.js';
+import { createDecisionEvent, createConnectionEvent, createTerminationEvent } from '../event/transition.js';
+
+// Helper function to handle the next step in the process
+async function handleNextStep(nodeOutput, nodeId, next, state) {
+    //console.log('[_HANDLE_NEXT_STEP_START]', { nodeId, nodeOutput, nextType: next && next.constructor ? next.constructor.name : typeof next, next });
+    if (Array.isArray(next) && next.length > 0 && next.every(isDecision)) {
+        const decisions = next;
+        // console.log('[_HANDLE_NEXT_STEP_DECISIONS]', { nodeId, count: decisions.length, decisions });
+        for (const decision of decisions){
+            // console.log('[_HANDLE_NEXT_STEP_DECISION_PROCESSING]', { nodeId, decisionId: decision.id, decision });
+            await dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'start', decision, {
+                output: nodeOutput
+            }), state.context);
+            try {
+                const decisionOutcome = await decision.decide(nodeOutput, state.context);
+                await dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'decide', decision, {
+                    output: nodeOutput,
+                    result: decisionOutcome
+                }), state.context);
+                // console.log('[_HANDLE_NEXT_STEP_DECISION_OUTCOME]', { nodeId, decisionId: decision.id, decisionOutcome });
+                await handleNextStep(nodeOutput, decision.id, decisionOutcome, state); // outcome processed, decision.id is context for next step if it's an error source. The original nodeId is implicitly the source of this decision.
+                await dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'end', decision), state.context);
+            } catch (decisionError) {
+                // eslint-disable-next-line no-console
+                console.error(`[_HANDLE_NEXT_STEP_DECISION_ERROR] Error in decision ${decision.id} from node ${nodeId}:`, {
+                    decisionError,
+                    nodeId,
+                    decisionId: decision.id
+                });
+                state.errors.push({
+                    nodeId: decision.id,
+                    message: decisionError.message
+                });
+            // Note: 'end' event for this decision path is skipped due to error.
+            }
+        }
+    } else if (Array.isArray(next) && next.length > 0 && next.every(isConnection)) {
+        //console.log('[_HANDLE_NEXT_STEP_CONNECTIONS]', { nodeId, count: next.length, connections: next });
+        const connections = next;
+        const nextPhasePromises = [];
+        for (const connection of connections){
+            let nextInput = nodeOutput;
+            let nextContext = state.context;
+            await dispatchEvent(state.eventState, createConnectionEvent(nodeId, 'start', connection, {
+                input: nextInput
+            }), state.context);
+            if (connection.transform) {
+                //console.log('[_HANDLE_NEXT_STEP_CONNECTION_TRANSFORM_START]', { nodeId, targetNodeId: connection.targetNodeId });
+                try {
+                    const context = state.context;
+                    [nextInput, nextContext] = await connection.transform(nodeOutput, context);
+                    await dispatchEvent(state.eventState, createConnectionEvent(nodeId, 'transform', connection, {
+                        input: nextInput,
+                        output: nodeOutput,
+                        context: nextContext
+                    }), state.context);
+                    state.context = nextContext;
+                //console.log('[_HANDLE_NEXT_STEP_CONNECTION_TRANSFORM_SUCCESS]', { nodeId, targetNodeId: connection.targetNodeId, nextInput, nextContext });
+                } catch (transformError) {
+                    // eslint-disable-next-line no-console
+                    console.error(`[_HANDLE_NEXT_STEP_CONNECTION_TRANSFORM_ERROR] Error in transform for connection from ${nodeId} to ${connection.targetNodeId}:`, {
+                        transformError,
+                        nodeId,
+                        targetNodeId: connection.targetNodeId
+                    });
+                    state.errors.push({
+                        nodeId: connection.targetNodeId,
+                        message: transformError.message
+                    });
+                    continue;
+                }
+            }
+            //console.log('[_HANDLE_NEXT_STEP_CONNECTION_EXECUTE_TARGET]', { nodeId, targetNodeId: connection.targetNodeId, nextInput });
+            nextPhasePromises.push(executeNode(connection.targetNodeId, nextInput, state));
+            await dispatchEvent(state.eventState, createConnectionEvent(nodeId, 'end', connection), state.context);
+        }
+    // Optional: await Promise.all(nextPhasePromises); // Current design relies on executeProcess waiting on activeExecutions
+    //console.log('[_HANDLE_NEXT_STEP_CONNECTIONS_PROMISES_PUSHED]', { nodeId, count: nextPhasePromises.length });
+    } else if (isTermination(next)) {
+        //console.log('[_HANDLE_NEXT_STEP_TERMINATION]', { nodeId, termination: next });
+        const termination = next;
+        await dispatchEvent(state.eventState, createTerminationEvent(nodeId, 'start', termination, {
+            output: nodeOutput
+        }), state.context);
+        const result = nodeOutput;
+        if (termination.terminate) {
+            //console.log('[_HANDLE_NEXT_STEP_TERMINATION_CALLING_TERMINATE_FN]', { nodeId, terminationId: termination.id });
+            termination.terminate(nodeOutput, state.context);
+            await dispatchEvent(state.eventState, createTerminationEvent(nodeId, 'terminate', termination, {
+                output: nodeOutput
+            }), state.context);
+        }
+        state.results[termination.id] = result;
+    } else if (Array.isArray(next) && next.length === 0) {
+        // Empty array, potentially from a Decision that leads to no connections or an empty Connection array.
+        // This could mean an implicit termination for this path or simply no further action from this branch.
+        // If it's considered an end state for the path, store the result.
+        const result = nodeOutput;
+        state.results[nodeId] = result; // Using nodeId as the key for this implicit termination
+    } else {
+        // If there is no next (e.g. next is undefined or null after a decision), or it's an unhandled type.
+        // Consider this an end state and store the result with the nodeId
+        //console.log('[_HANDLE_NEXT_STEP_NO_NEXT_OR_UNHANDLED]', { nodeId, next, nodeOutput });
+        const result = nodeOutput;
+        state.results[nodeId] = result;
+    }
+//console.log('[_HANDLE_NEXT_STEP_END]', { nodeId });
+}
+
+export { handleNextStep };
+//# sourceMappingURL=next.js.map

package/dist/execution/next.js.map

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

package/dist/execution/node.d.ts

@@ -0,0 +1,4 @@
+import { Input } from '../input';
+import { Output } from '../output';
+import { ExecutionState } from './process';
+export declare function executeNode(nodeId: string, input: Input, state: ExecutionState): Promise<Output>;

package/dist/execution/node.js

@@ -0,0 +1,170 @@
+import { executeAggregatorNode } from './aggregator.js';
+import { handleNextStep } from './next.js';
+import { isAggregatorNode } from '../node/aggregatornode.js';
+import { isPhaseNode } from '../node/phasenode.js';
+import { isDecision } from '../transition/decision.js';
+import { createDecisionEvent } from '../event/transition.js';
+import { dispatchEvent } from './event.js';
+import { createAggregatorNodeEvent, createPhaseNodeEvent } from '../event/node.js';
+import { createPhaseEvent } from '../event/phase.js';
+
+async function executeNode(nodeId, input, state) {
+    //console.log('[EXECUTE_NODE_RECURSIVE_START]', { nodeId, input, phaseResultsKeys: Object.keys(state.phaseResults), activeExecutionsKeys: Array.from(state.activeExecutions.keys()), aggregatorDeferredsKeys: Array.from(state.aggregatorDeferreds.keys()) });
+    // 1. Check if result is already cached in phaseResults (final output, node fully completed)
+    if (state.phaseResults[nodeId]) {
+        //console.log('[EXECUTE_NODE_RECURSIVE_CACHE_HIT_PHASERESULTS]', { nodeId, result: state.phaseResults[nodeId] });
+        return state.phaseResults[nodeId];
+    }
+    const node = state.process.phases[nodeId];
+    if (!node) {
+        const error = new Error(`Node with ID "${nodeId}" not found.`);
+        //console.error('[EXECUTE_NODE_RECURSIVE_NODE_NOT_FOUND]', { nodeId, error });
+        state.errors.push({
+            nodeId,
+            message: error.message
+        });
+        throw error;
+    }
+    //console.log('[EXECUTE_NODE_RECURSIVE_NODE_FOUND]', { nodeId, nodeType: node.constructor.name, node });
+    // 2. Handle active/pending executions
+    // If it's an aggregator that has a deferred promise, it means it's pending.
+    // We need to re-evaluate it with the current input. The IIFE below will handle this.
+    if (state.activeExecutions.has(nodeId) && !isAggregatorNode(node)) {
+        // For non-aggregators, if already active, return the promise.
+        // Aggregators will fall through to the IIFE to allow input processing.
+        // The IIFE itself handles returning a shared deferred promise if needed.
+        //console.log('[EXECUTE_NODE_RECURSIVE_ACTIVE_EXECUTION_HIT_NON_AGGREGATOR]', { nodeId });
+        return state.activeExecutions.get(nodeId);
+    }
+    // If it IS an aggregator and state.activeExecutions.has(nodeId),
+    // it means its deferred.promise might be in activeExecutions from a previous input that made it pending.
+    // The IIFE logic below will correctly retrieve this deferred (if it exists and is still relevant)
+    // from state.aggregatorDeferreds.get(nodeId) and use its promise, or process the input.
+    //console.log('[EXECUTE_NODE_RECURSIVE_CONTINUING_TO_EXECUTION_LOGIC]', { nodeId, isActive: state.activeExecutions.has(nodeId), isAggregator: isAggregatorNode(node), hasDeferred: state.aggregatorDeferreds.has(nodeId) });
+    // If it's an aggregator and it's pending (has a deferred), we fall through to re-execute its logic within the IIFE.
+    // If it's the first call to any node, we fall through.
+    // 3. Mark as active and execute (or re-evaluate pending aggregator)
+    const executionPromise = (async ()=>{
+        //console.log('[EXECUTE_NODE_RECURSIVE_IIFE_START]', { nodeId, input });
+        try {
+            let output;
+            if (isAggregatorNode(node)) {
+                dispatchEvent(state.eventState, createAggregatorNodeEvent(nodeId, 'start', node, {
+                    input
+                }), state.context);
+                output = await executeAggregatorNode(nodeId, node, input, state);
+            } else if (isPhaseNode(node)) {
+                dispatchEvent(state.eventState, createPhaseNodeEvent(nodeId, 'start', node, {
+                    input
+                }), state.context);
+                dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'start', node.phase, {
+                    input
+                }), state.context);
+                output = await node.phase.execute(input);
+                dispatchEvent(state.eventState, createPhaseEvent(nodeId, 'execute', node.phase, {
+                    input,
+                    output
+                }), state.context);
+            //console.log('[EXECUTE_NODE_RECURSIVE_PHASE_NODE_EXECUTE_END]', { nodeId, output });
+            } else {
+                const error = new Error(`Unknown or invalid node type for ID "${nodeId}". Expected PhaseNode or AggregatorNode.`);
+                //console.error('[EXECUTE_NODE_RECURSIVE_UNKNOWN_NODE_TYPE]', { nodeId, node, error });
+                throw error;
+            }
+            state.phaseResults[nodeId] = output; // Set final output once ready/executed
+            //console.log('[EXECUTE_NODE_RECURSIVE_PHASE_RESULT_CACHED]', { nodeId, output });
+            // 4. Handle next step
+            if (node.next) {
+                //console.log('[EXECUTE_NODE_RECURSIVE_HANDLING_NEXT_STEP]', { nodeId, nextType: node.next.constructor.name, next: node.next });
+                if (Array.isArray(node.next) && node.next.length > 0 && node.next.every(isDecision)) {
+                    //console.log('[EXECUTE_NODE_RECURSIVE_DECISIONS_FOUND]', { nodeId, count: node.next.length, decisions: node.next });
+                    const decisions = node.next;
+                    const decisionExecutionPromises = [];
+                    for (const decision of decisions){
+                        dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'start', decision, {
+                            output
+                        }), state.context);
+                        const decisionPromise = (async ()=>{
+                            //console.log('[EXECUTE_NODE_RECURSIVE_DECISION_EXECUTE_START]', { nodeId, decisionId: decision.id, output });
+                            try {
+                                const decisionOutcome = await decision.decide(output, state.context);
+                                dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'decide', decision, {
+                                    output,
+                                    result: decisionOutcome
+                                }), state.context);
+                                //console.log('[EXECUTE_NODE_RECURSIVE_DECISION_OUTCOME]', { nodeId, decisionId: decision.id, decisionOutcome });
+                                await handleNextStep(output, decision.id, decisionOutcome, state);
+                                dispatchEvent(state.eventState, createDecisionEvent(nodeId, 'end', decision), state.context);
+                            } catch (decisionError) {
+                                // eslint-disable-next-line no-console
+                                console.error(`[_HANDLE_NEXT_STEP_DECISION_ERROR] Error in decision ${decision.id} for node ${nodeId}:`, {
+                                    decisionError,
+                                    nodeId,
+                                    decisionId: decision.id
+                                });
+                                state.errors.push({
+                                    nodeId: decision.id,
+                                    message: decisionError.message
+                                });
+                            }
+                        })();
+                        decisionExecutionPromises.push(decisionPromise);
+                    }
+                    //console.log('[EXECUTE_NODE_RECURSIVE_WAITING_FOR_DECISIONS]', { nodeId, count: decisionExecutionPromises.length });
+                    await Promise.all(decisionExecutionPromises);
+                //console.log('[EXECUTE_NODE_RECURSIVE_DECISIONS_COMPLETE]', { nodeId });
+                } else {
+                    //console.log('[EXECUTE_NODE_RECURSIVE_CALLING_HANDLE_NEXT_STEP_FOR_NON_DECISION]', { nodeId, next: node.next });
+                    await handleNextStep(output, nodeId, node.next, state);
+                }
+            } else {
+                //console.log('[EXECUTE_NODE_RECURSIVE_NO_NEXT_NODE_IMPLICIT_TERMINATION]', { nodeId, output });
+                const result = output;
+                state.results[nodeId] = result;
+            }
+            if (isPhaseNode(node)) {
+                dispatchEvent(state.eventState, createPhaseNodeEvent(nodeId, 'end', node, {
+                    input,
+                    output
+                }), state.context);
+            } else {
+                dispatchEvent(state.eventState, createAggregatorNodeEvent(nodeId, 'end', node, {
+                    input,
+                    output
+                }), state.context);
+            }
+            //console.log('[EXECUTE_NODE_RECURSIVE_IIFE_RETURNING_OUTPUT]', { nodeId, output });
+            return output;
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(`[EXECUTE_NODE_RECURSIVE_IIFE_ERROR] Error executing node ${nodeId}:`, {
+                error,
+                nodeId
+            });
+            state.errors.push({
+                nodeId,
+                message: error.message
+            });
+            throw error;
+        } finally{
+            //console.log('[EXECUTE_NODE_RECURSIVE_IIFE_FINALLY]', { nodeId, hasAggregatorDeferred: state.aggregatorDeferreds.has(nodeId) });
+            // If a node completed (not pending via deferred mechanism) or an error occurred.
+            // An aggregator that is still pending (has a deferred) should keep its promise in activeExecutions.
+            if (!state.aggregatorDeferreds.has(nodeId)) {
+                //console.log('[EXECUTE_NODE_RECURSIVE_IIFE_FINALLY_DELETING_ACTIVE_EXECUTION]', { nodeId });
+                state.activeExecutions.delete(nodeId);
+            }
+        }
+    })();
+    // Store the promise from the IIFE.
+    // If it's an aggregator that went pending, executionPromise IS deferred.promise.
+    // If it's an aggregator that became ready, executionPromise is a promise resolving to its output.
+    // If it's a phase node, executionPromise is a promise resolving to its output.
+    //console.log('[EXECUTE_NODE_RECURSIVE_SETTING_ACTIVE_EXECUTION]', { nodeId });
+    state.activeExecutions.set(nodeId, executionPromise);
+    //console.log('[EXECUTE_NODE_RECURSIVE_END_RETURNING_PROMISE]', { nodeId });
+    return executionPromise;
+}
+
+export { executeNode };
+//# sourceMappingURL=node.js.map

package/dist/execution/node.js.map

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

package/dist/execution/process.d.ts

@@ -0,0 +1,35 @@
+import { Context } from '../context';
+import { AggregatorState } from './aggregator';
+import { Input } from '../input';
+import { Output } from '../output';
+import { Process } from '../process';
+import { Beginning } from '../transition/beginning';
+import { Event, EventHandler, EventState } from '../event';
+export interface PhaseResults {
+    [key: string]: Output;
+}
+export interface ProcessResults {
+    [key: string]: Output;
+}
+interface ProcessExecutionError {
+    message: string;
+    details?: any;
+    nodeId?: string;
+}
+export interface ProcessExecutionOptions<I extends Input = Input, C extends Context = Context> {
+    input: I;
+    context: C;
+    eventHandlers?: ReadonlyArray<EventHandler<Event, C>>;
+}
+export declare const DEFAULT_PROCESS_EXECUTION_OPTIONS: ProcessExecutionOptions<Input, Context>;
+export interface ExecutionState<C extends Context = Context> extends AggregatorState {
+    process: Readonly<Process>;
+    context: C;
+    phaseResults: Record<string, Output>;
+    results: Record<string, Output>;
+    activeExecutions: Map<string, Promise<Output>>;
+    errors: ProcessExecutionError[];
+    readonly eventState: Readonly<EventState<C>>;
+}
+export declare function executeProcess<I extends Input = Input, O extends Output = Output, C extends Context = Context>(processInstance: Readonly<Process>, beginning: Beginning<I, C>, options?: Partial<ProcessExecutionOptions<I, C>>): Promise<[Record<string, O>, Record<string, O>, C]>;
+export {};

package/dist/execution/process.js

@@ -0,0 +1,97 @@
+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
+        });
+    }
+    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 may have pending aggregators: ${pendingNodeIds}.`, {
+            processName: processInstance.name,
+            pendingNodeIds
+        });
+    }
+    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":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

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":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}