@maxdrellin/xenocline 0.0.1

package/__mocks__/src/execution/event.js

@@ -0,0 +1,8 @@
+// Manual mock for src/execution/event
+import { jest } from '@jest/globals';
+
+const dispatchEvent = jest.fn();
+
+module.exports = {
+    dispatchEvent
+}; 

package/dist/aggregator.d.ts

@@ -0,0 +1,28 @@
+import { Context } from './context';
+import { Input } from './input';
+import { Output } from './output';
+/**
+ * Defines the possible outcomes of an aggregation operation.
+ * It can either be 'Ready' with an output, or 'NotYetReady'.
+ */
+export type AggregationResult<U extends Output = Output> = {
+    status: 'Ready';
+    output: U;
+} | {
+    status: 'NotYetReady';
+};
+export type AggregateMethod<U extends Output = Output, C extends Context = Context> = (input: Input, context: C) => Promise<Readonly<AggregationResult<U>>>;
+export interface Aggregator<U extends Output = Output, C extends Context = Context> {
+    name: string;
+    aggregate: AggregateMethod<U, C>;
+}
+export interface AggregatorOptions<U extends Output = Output, C extends Context = Context> {
+    aggregate: AggregateMethod<U, C>;
+}
+export declare const DEFAULT_AGGREGATOR_OPTIONS: AggregatorOptions<Output, Context>;
+export declare const createAggregator: <U extends Output = Output, C extends Context = Context>(name: string, options?: Partial<AggregatorOptions<U, C>>) => Readonly<Aggregator<U, C>>;
+export declare const isAggregator: <U extends Output = Output>(obj: any) => obj is Aggregator<U>;
+export declare const validateAggregator: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/aggregator.js

@@ -0,0 +1,31 @@
+import { clean } from './util/general.js';
+
+const DEFAULT_AGGREGATOR_OPTIONS = {
+    aggregate: async (input)=>{
+        return {
+            status: 'Ready',
+            output: input
+        };
+    }
+};
+const createAggregator = (name, options)=>{
+    let aggregatorOptions = {
+        ...DEFAULT_AGGREGATOR_OPTIONS
+    };
+    if (options) {
+        aggregatorOptions = {
+            ...aggregatorOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        name,
+        aggregate: aggregatorOptions.aggregate
+    };
+};
+const isAggregator = (obj)=>{
+    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.aggregate === 'function';
+};
+
+export { DEFAULT_AGGREGATOR_OPTIONS, createAggregator, isAggregator };
+//# sourceMappingURL=aggregator.js.map

package/dist/aggregator.js.map

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

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_CHARACTER_ENCODING = "utf8";
+export declare const LIBRARY_NAME = "Xenocline";

package/dist/context.d.ts

@@ -0,0 +1,3 @@
+export interface Context {
+    [key: string]: unknown;
+}

package/dist/event/aggregator.d.ts

@@ -0,0 +1,16 @@
+import { Event, EventData } from './event';
+import { AggregationResult, Aggregator, Input, Output } from '../xenocline';
+export type AggregatorEventStage = 'start' | 'aggregate' | 'ready' | 'defer';
+export interface AggregatorEvent<A extends Aggregator = Aggregator, S extends AggregatorEventStage = AggregatorEventStage, D extends AggregatorEventData = AggregatorEventData> extends Event<D> {
+    type: 'aggregator';
+    stage: S;
+    aggregator: A;
+    data?: D;
+}
+export interface AggregatorEventData extends EventData {
+    input?: Input;
+    output?: Output;
+    result?: Readonly<AggregationResult<Output>>;
+}
+export declare function createAggregatorEvent<A extends Aggregator = Aggregator, S extends AggregatorEventStage = AggregatorEventStage, D extends AggregatorEventData = AggregatorEventData>(sourceId: string, stage: S, aggregator: A, data?: D): AggregatorEvent<A, S, D>;
+export declare function isAggregatorEvent<A extends Aggregator = Aggregator, S extends AggregatorEventStage = AggregatorEventStage, D extends AggregatorEventData = AggregatorEventData>(event: any): event is AggregatorEvent<A, S, D>;

package/dist/event/aggregator.js

@@ -0,0 +1,29 @@
+import { createEvent } from './event.js';
+
+function createAggregatorEvent(sourceId, stage, aggregator, data) {
+    const event = createEvent('aggregator', sourceId, stage, data);
+    return {
+        ...event,
+        aggregator
+    };
+}
+function isAggregatorEvent(event) {
+    if (event === null || event === undefined || typeof event !== 'object') {
+        return false;
+    }
+    const hasRequiredProperties = event.type === 'aggregator' && 'stage' in event && 'aggregator' in event && typeof event.aggregator === 'object' && event.aggregator !== null && 'name' in event.aggregator;
+    if (!hasRequiredProperties) {
+        return false;
+    }
+    const aggregatorEvent = event;
+    const isValidStage = [
+        'start',
+        'aggregate',
+        'ready',
+        'defer'
+    ].includes(aggregatorEvent.stage);
+    return isValidStage;
+}
+
+export { createAggregatorEvent, isAggregatorEvent };
+//# sourceMappingURL=aggregator.js.map

package/dist/event/aggregator.js.map

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

package/dist/event/event.d.ts

@@ -0,0 +1,14 @@
+export type EventType = 'process' | 'phase' | 'transition' | 'execution' | 'aggregator';
+export type EventStage = string;
+export interface EventData {
+    [key: string]: unknown;
+}
+export interface Event<D extends EventData = EventData> {
+    date: Date;
+    type: string;
+    stage: EventStage;
+    sourceId: string;
+    data?: D;
+}
+export declare const createEvent: <D extends EventData>(type: string, sourceId: string, stage: EventStage, data?: D) => Event<D>;
+export declare const isEvent: (item: unknown) => item is Event;

package/dist/event/event.js

@@ -0,0 +1,12 @@
+const createEvent = (type, sourceId, stage, data)=>{
+    return {
+        date: new Date(),
+        type,
+        stage,
+        sourceId,
+        data
+    };
+};
+
+export { createEvent };
+//# sourceMappingURL=event.js.map

package/dist/event/event.js.map

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

package/dist/event/handler.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '../context';
+import { Event } from './event';
+export type HandleMethod<E extends Event = Event, C extends Context = Context> = (event: E, context: C) => Promise<void>;
+export interface EventHandler<E extends Event = Event, C extends Context = Context> {
+    handle: HandleMethod<E, C>;
+}
+export declare const createEventHandler: <E extends Event = Event, C extends Context = Context>(handle: HandleMethod<E, C>) => EventHandler<E, C>;

package/dist/event/handler.js

@@ -0,0 +1,8 @@
+const createEventHandler = (handle)=>{
+    return {
+        handle
+    };
+};
+
+export { createEventHandler };
+//# sourceMappingURL=handler.js.map

package/dist/event/handler.js.map

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

package/dist/event/node.d.ts

@@ -0,0 +1,40 @@
+import { EventData, Event } from '../event/event';
+import { AggregatorNode, Input, Node, Output, PhaseNode } from '../xenocline';
+export type NodeEventStage = AggregatorNodeEventStage | PhaseNodeEventStage;
+export type NodeEventType = 'aggregator' | 'phase';
+/**
+ * Base event emitted for any node.
+ */
+export interface NodeEvent<T extends NodeEventType = NodeEventType, S extends NodeEventStage = NodeEventStage, N extends Node = Node, D extends EventData = EventData> extends Event<D> {
+    type: 'node';
+    nodeType: T;
+    node: N;
+    stage: S;
+    data?: D;
+}
+export declare const createNodeEvent: <T extends NodeEventType, S extends NodeEventStage, N extends Node, D extends EventData>(sourceId: string, nodeType: T, stage: S, node: N, data?: D) => Readonly<NodeEvent<T, S, N, D>>;
+export declare const isNodeEvent: (item: any) => item is NodeEvent;
+export type AggregatorNodeEventStage = 'start' | 'end';
+export interface AggregatorEventData extends EventData {
+    input?: Input;
+    output?: Output;
+}
+export interface AggregatorNodeEvent<A extends AggregatorNode = AggregatorNode> extends NodeEvent<'aggregator', AggregatorNodeEventStage, A, AggregatorEventData> {
+    nodeType: 'aggregator';
+    node: A;
+    data?: AggregatorEventData;
+}
+export declare const createAggregatorNodeEvent: <A extends AggregatorNode>(sourceId: string, stage: AggregatorNodeEventStage, aggregatorNode: A, data?: AggregatorEventData) => AggregatorNodeEvent<A>;
+export declare const isAggregatorNodeEvent: (item: any) => item is AggregatorNodeEvent;
+export type PhaseNodeEventStage = 'start' | 'end';
+export interface PhaseEventData extends EventData {
+    input?: Input;
+    output?: Output;
+}
+export interface PhaseNodeEvent<P extends PhaseNode = PhaseNode> extends NodeEvent<'phase', PhaseNodeEventStage, P, PhaseEventData> {
+    nodeType: 'phase';
+    node: P;
+    data?: PhaseEventData;
+}
+export declare const createPhaseNodeEvent: <P extends PhaseNode>(sourceId: string, stage: PhaseNodeEventStage, phaseNode: P, data?: PhaseEventData) => PhaseNodeEvent<P>;
+export declare const isPhaseNodeEvent: (item: any) => item is PhaseNodeEvent;

package/dist/event/node.js

@@ -0,0 +1,24 @@
+import { createEvent } from './event.js';
+
+const createNodeEvent = (sourceId, nodeType, stage, node, data)=>{
+    const event = createEvent('node', sourceId, stage, data);
+    return {
+        ...event,
+        nodeType,
+        node
+    };
+};
+const isNodeEvent = (item)=>{
+    return item !== null && item !== undefined && typeof item === 'object' && item.type === 'node' && item.node !== null && item.node !== undefined && item.stage !== null && item.stage !== undefined;
+};
+const createAggregatorNodeEvent = (sourceId, stage, aggregatorNode, data)=>createNodeEvent(sourceId, 'aggregator', stage, aggregatorNode, data);
+const isAggregatorNodeEvent = (item)=>{
+    return isNodeEvent(item) && item.nodeType === 'aggregator';
+};
+const createPhaseNodeEvent = (sourceId, stage, phaseNode, data)=>createNodeEvent(sourceId, 'phase', stage, phaseNode, data);
+const isPhaseNodeEvent = (item)=>{
+    return isNodeEvent(item) && item.nodeType === 'phase';
+};
+
+export { createAggregatorNodeEvent, createNodeEvent, createPhaseNodeEvent, isAggregatorNodeEvent, isNodeEvent, isPhaseNodeEvent };
+//# sourceMappingURL=node.js.map

package/dist/event/node.js.map

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

package/dist/event/phase.d.ts

@@ -0,0 +1,15 @@
+import { Input, Output, Phase } from '../xenocline';
+import { Event, EventData } from './event';
+export type PhaseEventStage = 'start' | 'execute';
+export interface PhaseEvent<P extends Phase = Phase, S extends PhaseEventStage = PhaseEventStage, D extends EventData = EventData> extends Event<D> {
+    type: 'phase';
+    phase: P;
+    stage: S;
+    data?: D;
+}
+export interface PhaseEventData extends EventData {
+    input?: Input;
+    output?: Output;
+}
+export declare function createPhaseEvent<P extends Phase, S extends PhaseEventStage = PhaseEventStage, D extends EventData = EventData>(sourceId: string, stage: S, phase: P, data?: D): PhaseEvent<P, S, D>;
+export declare function isPhaseEvent<P extends Phase>(event: any): event is PhaseEvent<P>;

package/dist/event/phase.js

@@ -0,0 +1,12 @@
+import { createEvent } from './event.js';
+
+function createPhaseEvent(sourceId, stage, phase, data) {
+    const event = createEvent('phase', sourceId, stage, data);
+    return {
+        ...event,
+        phase
+    };
+}
+
+export { createPhaseEvent };
+//# sourceMappingURL=phase.js.map

package/dist/event/phase.js.map

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

package/dist/event/process.d.ts

@@ -0,0 +1,14 @@
+import { EventData, Event } from './event';
+import { Process } from '../process';
+import { Context } from 'vm';
+export type ProcessEventStage = 'start' | 'end';
+export interface ProcessEvent<Proc extends Process = Process, C extends Context = Context> extends Event<ProcessEventData<C>> {
+    type: 'process';
+    process: Proc;
+    stage: ProcessEventStage;
+}
+export interface ProcessEventData<C extends Context = Context> extends EventData {
+    context?: C;
+}
+export declare const createProcessEvent: <Proc extends Process, C extends Context = Context>(sourceId: string, stage: ProcessEventStage, process: Proc, data?: ProcessEventData<C>) => Readonly<ProcessEvent<Proc, C>>;
+export declare const isProcessEvent: (item: any) => item is ProcessEvent;

package/dist/event/process.js

@@ -0,0 +1,15 @@
+import { createEvent } from './event.js';
+
+const createProcessEvent = (sourceId, stage, process, data)=>{
+    const event = createEvent('process', sourceId, stage, data);
+    return {
+        ...event,
+        process
+    };
+};
+const isProcessEvent = (item)=>{
+    return item !== null && item !== undefined && typeof item === 'object' && item.type === 'process' && item.process !== null && item.process !== undefined && item.stage !== null && item.stage !== undefined;
+};
+
+export { createProcessEvent, isProcessEvent };
+//# sourceMappingURL=process.js.map

package/dist/event/process.js.map

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

package/dist/event/transition.d.ts

@@ -0,0 +1,45 @@
+import { Beginning, Connection, Context, Decision, Input, Output, Termination, Transition } from '../xenocline';
+import { EventData, Event } from '../event/event';
+export type TransitionEventStage = DecisionEventStage | ConnectionEventStage | TerminationEventStage | BeginningEventStage;
+export type TransitionEventType = 'connection' | 'decision' | 'termination' | 'beginning';
+/**
+ * Base event emitted for any transition.
+ */
+export interface TransitionEvent<T extends TransitionEventType, S extends TransitionEventStage, P extends Transition = Transition, D extends EventData = EventData> extends Event<D> {
+    type: 'transition';
+    transitionType: T;
+    transition: P;
+    stage: S;
+}
+export declare const createTransitionEvent: <T extends TransitionEventType, S extends TransitionEventStage, P extends Transition, D extends EventData>(sourceId: string, transitionType: T, stage: S, transition: P, data?: D) => Readonly<TransitionEvent<T, S, P, D>>;
+export type ConnectionEventStage = 'start' | 'end' | 'transform';
+export interface ConnectionEventData extends EventData {
+    input?: Input;
+    output?: Output;
+    context?: Context;
+}
+export type ConnectionEvent = TransitionEvent<'connection', ConnectionEventStage, Connection, ConnectionEventData>;
+export declare const createConnectionEvent: (sourceId: string, stage: ConnectionEventStage, transition: Connection, data?: ConnectionEventData) => Readonly<ConnectionEvent>;
+export declare const isConnectionEvent: (item: any) => item is ConnectionEvent;
+export type DecisionEventStage = 'start' | 'end' | 'decide';
+export interface DecisionEventData extends EventData {
+    output?: Output;
+    result?: any;
+}
+export type DecisionEvent = TransitionEvent<'decision', DecisionEventStage, Decision, DecisionEventData>;
+export declare const createDecisionEvent: (sourceId: string, stage: DecisionEventStage, transition: Decision, data?: DecisionEventData) => Readonly<DecisionEvent>;
+export declare const isDecisionEvent: (item: any) => item is DecisionEvent;
+export type TerminationEventStage = 'start' | 'terminate';
+export interface TerminationEventData extends EventData {
+    output?: Output;
+}
+export type TerminationEvent = TransitionEvent<'termination', TerminationEventStage, Termination, TerminationEventData>;
+export declare const createTerminationEvent: (sourceId: string, stage: TerminationEventStage, transition: Termination, data?: TerminationEventData) => Readonly<TerminationEvent>;
+export declare const isTerminationEvent: (item: any) => item is TerminationEvent;
+export type BeginningEventStage = 'start' | 'begin';
+export interface BeginningEventData extends EventData {
+    input?: Input;
+}
+export type BeginningEvent = TransitionEvent<'beginning', BeginningEventStage, Beginning, BeginningEventData>;
+export declare const createBeginningEvent: <I extends Input, C extends Context>(sourceId: string, stage: BeginningEventStage, transition: Beginning<I, C>, data?: BeginningEventData) => Readonly<BeginningEvent>;
+export declare const isBeginningEvent: (item: any) => item is BeginningEvent;

package/dist/event/transition.js

@@ -0,0 +1,35 @@
+import { createEvent } from './event.js';
+
+const createTransitionEvent = (sourceId, transitionType, stage, transition, data)=>{
+    const event = createEvent('transition', sourceId, stage, data);
+    return {
+        ...event,
+        transitionType,
+        transition
+    };
+};
+const createConnectionEvent = (sourceId, stage, transition, data)=>{
+    return createTransitionEvent(sourceId, 'connection', stage, transition, data);
+};
+const isConnectionEvent = (item)=>{
+    return typeof item === 'object' && item !== null && item.type === 'transition' && item.transitionType === 'connection' && typeof item.transitionType === 'string';
+};
+const createDecisionEvent = (sourceId, stage, transition, data)=>createTransitionEvent(sourceId, 'decision', stage, transition, data);
+const isDecisionEvent = (item)=>{
+    return typeof item === 'object' && item !== null && item.type === 'transition' && item.transitionType === 'decision' && typeof item.transitionType === 'string';
+};
+const createTerminationEvent = (sourceId, stage, transition, data)=>{
+    return createTransitionEvent(sourceId, 'termination', stage, transition, data);
+};
+const isTerminationEvent = (item)=>{
+    return typeof item === 'object' && item !== null && item.type === 'transition' && item.transitionType === 'termination' && typeof item.transitionType === 'string';
+};
+const createBeginningEvent = (sourceId, stage, transition, data)=>{
+    return createTransitionEvent(sourceId, 'beginning', stage, transition, data);
+};
+const isBeginningEvent = (item)=>{
+    return typeof item === 'object' && item !== null && item.type === 'transition' && item.transitionType === 'beginning' && typeof item.transitionType === 'string';
+};
+
+export { createBeginningEvent, createConnectionEvent, createDecisionEvent, createTerminationEvent, createTransitionEvent, isBeginningEvent, isConnectionEvent, isDecisionEvent, isTerminationEvent };
+//# sourceMappingURL=transition.js.map

package/dist/event/transition.js.map

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

package/dist/event.d.ts

@@ -0,0 +1,30 @@
+export type { Event } from './event/event';
+export type { ProcessEvent } from './event/process';
+export type { ProcessEventStage } from './event/process';
+export type { PhaseEvent } from './event/phase';
+export type { PhaseEventStage } from './event/phase';
+export type { AggregatorEvent } from './event/aggregator';
+export type { AggregatorEventStage } from './event/aggregator';
+export type { NodeEvent, NodeEventStage, AggregatorNodeEvent, PhaseNodeEvent } from './event/node';
+export type { TransitionEvent, TransitionEventStage, TransitionEventType, ConnectionEvent, DecisionEvent, TerminationEvent, BeginningEvent } from './event/transition';
+export { createAggregatorEvent } from './event/aggregator';
+export { createProcessEvent } from './event/process';
+export { createNodeEvent } from './event/node';
+export { createConnectionEvent } from './event/transition';
+export { createDecisionEvent } from './event/transition';
+export { createTerminationEvent } from './event/transition';
+export { createBeginningEvent } from './event/transition';
+export { createTransitionEvent } from './event/transition';
+export { isAggregatorEvent } from './event/aggregator';
+export { isProcessEvent } from './event/process';
+export { isNodeEvent } from './event/node';
+export { isConnectionEvent } from './event/transition';
+export { isDecisionEvent } from './event/transition';
+export { isTerminationEvent } from './event/transition';
+export { isBeginningEvent } from './event/transition';
+export { isAggregatorNodeEvent } from './event/node';
+export { isPhaseNodeEvent } from './event/node';
+export type { EventHandler } from './event/handler';
+export { createEventHandler } from './event/handler';
+export type { EventState } from './execution/event';
+export { createEventState, dispatchEvent } from './execution/event';

package/dist/execution/aggregator.d.ts

@@ -0,0 +1,23 @@
+import { Context } from 'vm';
+import { EventState } from '../event';
+import { Input } from '../input';
+import { AggregatorNode } from '../node/aggregatornode';
+import { Output } from '../output';
+export declare class Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+}
+export interface AggregatorState {
+    aggregatorDeferreds: Map<string, Deferred<Output>>;
+    registerPendingAggregator: (nodeId: string) => Deferred<Output>;
+    resolvePendingAggregator: (nodeId: string, output: Output) => void;
+    getPendingAggregator: (nodeId: string) => Deferred<Output> | undefined;
+    pendingAggregatorIds: () => string[];
+}
+export declare function createAggregatorState(): AggregatorState;
+export declare function executeAggregatorNode(nodeId: string, node: AggregatorNode, input: Input, state: AggregatorState & {
+    context: Context;
+    eventState: EventState<Context>;
+}): Promise<Output>;

package/dist/execution/aggregator.js

@@ -0,0 +1,81 @@
+import { createAggregatorEvent } from '../event/aggregator.js';
+import { dispatchEvent } from './event.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class Deferred {
+    constructor(){
+        _define_property(this, "promise", void 0);
+        _define_property(this, "resolve", void 0);
+        _define_property(this, "reject", void 0);
+        this.promise = new Promise((resolve, reject)=>{
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+function createAggregatorState() {
+    return {
+        aggregatorDeferreds: new Map(),
+        registerPendingAggregator (nodeId) {
+            let deferred = this.aggregatorDeferreds.get(nodeId);
+            if (!deferred) {
+                deferred = new Deferred();
+                this.aggregatorDeferreds.set(nodeId, deferred);
+            }
+            return deferred;
+        },
+        resolvePendingAggregator (nodeId, output) {
+            const deferred = this.aggregatorDeferreds.get(nodeId);
+            if (deferred) {
+                deferred.resolve(output);
+                this.aggregatorDeferreds.delete(nodeId);
+            }
+        },
+        getPendingAggregator (nodeId) {
+            return this.aggregatorDeferreds.get(nodeId);
+        },
+        pendingAggregatorIds () {
+            return Array.from(this.aggregatorDeferreds.keys());
+        }
+    };
+}
+async function executeAggregatorNode(nodeId, node, input, state) {
+    dispatchEvent(state.eventState, createAggregatorEvent(nodeId, 'start', node.aggregator, {
+        input
+    }), state.context);
+    let deferred = state.getPendingAggregator(nodeId);
+    const aggregationResult = await node.aggregator.aggregate(input, state.context);
+    dispatchEvent(state.eventState, createAggregatorEvent(nodeId, 'aggregate', node.aggregator, {
+        input,
+        result: aggregationResult
+    }), state.context);
+    if (aggregationResult.status === 'Ready') {
+        const output = aggregationResult.output;
+        dispatchEvent(state.eventState, createAggregatorEvent(nodeId, 'ready', node.aggregator, {
+            output
+        }), state.context);
+        state.resolvePendingAggregator(nodeId, output);
+        return output;
+    }
+    dispatchEvent(state.eventState, createAggregatorEvent(nodeId, 'defer', node.aggregator, {
+        input,
+        result: aggregationResult
+    }), state.context);
+    deferred = deferred !== null && deferred !== void 0 ? deferred : state.registerPendingAggregator(nodeId);
+    return deferred.promise;
+}
+
+export { Deferred, createAggregatorState, executeAggregatorNode };
+//# sourceMappingURL=aggregator.js.map

package/dist/execution/aggregator.js.map

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

package/dist/execution/event.d.ts

@@ -0,0 +1,26 @@
+import { Context } from '../context';
+import { Event, EventHandler } from '../event';
+/**
+ * Represents the state for managing event handlers.
+ * Event handlers are expected to handle the base `Event` type and perform
+ * specific event checking internally if needed (e.g., using type guards).
+ */
+export interface EventState<C extends Context> {
+    /** Readonly array of registered event handlers. */
+    readonly handlers: ReadonlyArray<EventHandler<Event, C>>;
+}
+/**
+ * Creates an instance of EventState.
+ * @param handlers An optional array of event handlers to initialize the state with.
+ *                 These handlers should be of type `EventHandler<Event, C>`, meaning they
+ *                 are prepared to receive any event and filter internally if necessary.
+ * @returns A new, readonly EventState object.
+ */
+export declare const createEventState: <C extends Context>(handlers?: ReadonlyArray<EventHandler<Event, C>>) => Readonly<EventState<C>>;
+/**
+ * Dispatches an event to all registered handlers.
+ * @param eventState The current event state containing the handlers.
+ * @param event The event to dispatch. This can be any specific event type that extends `Event`.
+ * @param context The current context to pass to the handlers.
+ */
+export declare const dispatchEvent: <E extends Event, C extends Context>(eventState: Readonly<EventState<C>>, event: E, context: C) => Promise<void>;

package/dist/execution/event.js

@@ -0,0 +1,29 @@
+/**
+ * Creates an instance of EventState.
+ * @param handlers An optional array of event handlers to initialize the state with.
+ *                 These handlers should be of type `EventHandler<Event, C>`, meaning they
+ *                 are prepared to receive any event and filter internally if necessary.
+ * @returns A new, readonly EventState object.
+ */ const createEventState = (handlers)=>{
+    // Store a copy of the handlers array to ensure immutability of the provided array.
+    return {
+        handlers: handlers ? [
+            ...handlers
+        ] : []
+    };
+};
+/**
+ * Dispatches an event to all registered handlers.
+ * @param eventState The current event state containing the handlers.
+ * @param event The event to dispatch. This can be any specific event type that extends `Event`.
+ * @param context The current context to pass to the handlers.
+ */ const dispatchEvent = async (eventState, event, context)=>{
+    for (const handler of eventState.handlers){
+        // Each handler is EventHandler<Event, C>, so its `handle` method expects an `Event`.
+        // Since `E` extends `Event`, passing `event` (of type `E`) is type-safe.
+        await handler.handle(event, context);
+    }
+};
+
+export { createEventState, dispatchEvent };
+//# sourceMappingURL=event.js.map

package/dist/execution/event.js.map

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

package/dist/execution/next.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionState } from './process';
+import { Output } from '../output';
+import { Connection } from '../transition/connection';
+import { Decision } from '../transition/decision';
+import { Termination } from '../transition/termination';
+export declare function handleNextStep(nodeOutput: Output, nodeId: string, next: Termination | Connection[] | Decision[], // Can be Termination, Connection[], or Decision[] - will be narrowed down
+state: ExecutionState): Promise<void>;