@girverket/xenocline 0.0.9

package/dist/process.js

@@ -0,0 +1,106 @@
+import { validateNode } from './node/node.js';
+import { isConnection } from './transition/connection.js';
+import { clean } from './util/general.js';
+
+//import * as ClassifyPhase from './phases/classify';
+// import * as TranscribePhase from './phases/transcribe';
+// import * as ComposePhase from './phases/compose';
+// import * as CompletePhase from './phases/complete';
+const createProcess = (name, options)=>{
+    const defaultOptions = {
+        phases: {}
+    };
+    const processOptions = {
+        ...defaultOptions,
+        ...clean(options)
+    };
+    // Removed: const eventState = createEventState<C>(processOptions.eventHandlers);
+    return {
+        name,
+        phases: processOptions.phases
+    };
+};
+const isProcess = (obj)=>{
+    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.phases === 'object';
+};
+const validateProcess = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...[],
+        'Process'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Process is undefined or null.'
+        });
+        return errors;
+    }
+    if (item.name === undefined || typeof item.name !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Process name is undefined or not a string.'
+        });
+    }
+    const processNameForPath = typeof item.name === 'string' ? item.name : 'UnnamedProcess';
+    const basePath = [
+        ...currentCoordinates,
+        `name:${processNameForPath}`
+    ];
+    if (item.phases === undefined || typeof item.phases !== 'object') {
+        errors.push({
+            coordinates: [
+                ...basePath,
+                'phases'
+            ],
+            error: 'Process phases is undefined or not an object.'
+        });
+    } else {
+        for(const phaseId in item.phases){
+            const node = item.phases[phaseId];
+            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {
+                errors.push(...validateNode(node, [
+                    ...basePath,
+                    'phases',
+                    phaseId
+                ]));
+            }
+        }
+        for(const phaseId in item.phases){
+            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {
+                const node = item.phases[phaseId];
+                if (node && typeof node === 'object' && node.next) {
+                    if (Array.isArray(node.next)) {
+                        const transitions = node.next;
+                        if (transitions.length > 0 && transitions.every((t)=>isConnection(t))) {
+                            transitions.forEach((connection, index)=>{
+                                if (connection && typeof connection.targetNodeId === 'string') {
+                                    if (!(connection.targetNodeId in item.phases)) {
+                                        errors.push({
+                                            coordinates: [
+                                                ...basePath,
+                                                'phases',
+                                                phaseId,
+                                                'next',
+                                                connection.id || `connection-at-index-${index}`
+                                            ],
+                                            error: `Node "${phaseId}" has a connection to non-existent targetNodeId "${connection.targetNodeId}".`
+                                        });
+                                    }
+                                } else if (!connection || connection.targetNodeId === undefined) ;
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { createProcess, isProcess, validateProcess };
+//# sourceMappingURL=process.js.map

package/dist/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sources":["../src/process.ts"],"sourcesContent":["//import * as ClassifyPhase from './phases/classify';\n// import * as TranscribePhase from './phases/transcribe';\n// import * as ComposePhase from './phases/compose';\n// import * as CompletePhase from './phases/complete';\nimport { AggregatorNode } from './node/aggregatornode';\nimport { validateNode } from './node/node';\nimport { PhaseNode } from './node/phasenode';\nimport { Connection, isConnection } from './transition/connection';\nimport { clean } from './util/general';\n// Removed: import { Phase } from './phase';\n// Removed: import { Event, EventHandler, EventState, createEventState } from './event';\n\nexport interface ProcessOptions {\n    phases: Record<string, PhaseNode | AggregatorNode>;\n    // Removed: eventHandlers?: ReadonlyArray<EventHandler<Event, C>>;\n}\n\nexport interface Process {\n    name: string;\n    phases: Record<string, PhaseNode | AggregatorNode>;\n    // Removed: readonly eventState: Readonly<EventState<C>>;\n}\n\nexport const createProcess = (\n    name: string,\n    options: Partial<ProcessOptions>\n): Readonly<Process> => {\n    const defaultOptions: ProcessOptions = {\n        phases: {},\n        // Removed: eventHandlers: [],\n    };\n\n    const processOptions: ProcessOptions = { ...defaultOptions, ...clean(options) };\n\n    // Removed: const eventState = createEventState<C>(processOptions.eventHandlers);\n\n    return {\n        name,\n        phases: processOptions.phases,\n        // Removed: eventState\n    };\n}\n\nexport const isProcess = (obj: any): obj is Process => {\n    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.phases === 'object';\n}\n\nexport const validateProcess = (\n    item: any,\n    coordinates?: string[]\n): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'Process'];\n\n    if (item === undefined || item === null) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Process is undefined or null.' });\n        return errors;\n    }\n\n    if (item.name === undefined || typeof item.name !== 'string') {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Process name is undefined or not a string.' });\n    }\n\n    const processNameForPath = typeof item.name === 'string' ? item.name : 'UnnamedProcess';\n    const basePath = [...currentCoordinates, `name:${processNameForPath}`];\n\n    if (item.phases === undefined || typeof item.phases !== 'object') {\n        errors.push({ coordinates: [...basePath, 'phases'], error: 'Process phases is undefined or not an object.' });\n    } else {\n        for (const phaseId in item.phases) {\n            const node = item.phases[phaseId];\n            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {\n                errors.push(...validateNode(node, [...basePath, 'phases', phaseId]));\n            }\n        }\n\n        for (const phaseId in item.phases) {\n            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {\n                const node = item.phases[phaseId];\n                if (node && typeof node === 'object' && node.next) {\n                    if (Array.isArray(node.next)) {\n                        const transitions = node.next as any[];\n                        if (transitions.length > 0 && transitions.every(t => isConnection(t))) {\n                            (transitions as Connection[]).forEach((connection, index) => {\n                                if (connection && typeof connection.targetNodeId === 'string') {\n                                    if (!(connection.targetNodeId in item.phases)) {\n                                        errors.push({\n                                            coordinates: [...basePath, 'phases', phaseId, 'next', connection.id || `connection-at-index-${index}`],\n                                            error: `Node \"${phaseId}\" has a connection to non-existent targetNodeId \"${connection.targetNodeId}\".`\n                                        });\n                                    }\n                                } else if (!connection || connection.targetNodeId === undefined) {\n                                    // This case should ideally be caught by validateConnection within validateNode's call to validateNext\n                                    // but adding a fallback or note if connection structure itself is broken at this stage.\n                                    // errors.push({\n                                    //     coordinates: [...basePath, 'phases', phaseId, 'next', `connection-at-index-${index}`],\n                                    //     error: `Connection at index ${index} for node \"${phaseId}\" is malformed or missing targetNodeId.`\n                                    // });\n                                }\n                            });\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    return errors;\n}"],"names":["createProcess","name","options","defaultOptions","phases","processOptions","clean","isProcess","obj","undefined","validateProcess","item","coordinates","errors","currentCoordinates","push","error","processNameForPath","basePath","phaseId","node","Object","prototype","hasOwnProperty","call","validateNode","next","Array","isArray","transitions","length","every","t","isConnection","forEach","connection","index","targetNodeId","id"],"mappings":"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"}

package/dist/transition/beginning.d.ts

@@ -0,0 +1,19 @@
+import { Context } from '../context';
+import { Input } from '../input';
+import { Transition } from './transition';
+export type BeginFunction<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<Input>;
+export interface Beginning<I extends Input = Input, C extends Context = Context> extends Transition {
+    type: 'beginning';
+    targetNodeId: string;
+    begin: BeginFunction<I, C>;
+}
+export interface BeginningOptions<I extends Input = Input, C extends Context = Context> {
+    begin: BeginFunction<I, C>;
+}
+export declare const DEFAULT_BEGINNING_OPTIONS: BeginningOptions<Input, Context>;
+export declare const createBeginning: <I extends Input = Input, C extends Context = Context>(id: string, targetNodeId: string, options?: Partial<BeginningOptions<I, C>>) => Readonly<Beginning<I, C>>;
+export declare const isBeginning: <I extends Input = Input, C extends Context = Context>(item: any) => item is Beginning<I, C>;
+export declare const validateBeginning: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/beginning.js

@@ -0,0 +1,31 @@
+import { clean } from '../util/general.js';
+import { createTransition, isTransition } from './transition.js';
+
+// NEW: Termination type extending Transition
+const DEFAULT_BEGINNING_OPTIONS = {
+    begin: async (input)=>{
+        return input;
+    }
+};
+const createBeginning = (id, targetNodeId, options)=>{
+    let beginningOptions = {
+        ...DEFAULT_BEGINNING_OPTIONS
+    };
+    if (options) {
+        beginningOptions = {
+            ...beginningOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('beginning', id),
+        targetNodeId,
+        begin: beginningOptions.begin
+    };
+};
+const isBeginning = (item)=>{
+    return isTransition(item) && item.type === 'beginning' && (item.begin === undefined || typeof item.begin === 'function');
+};
+
+export { DEFAULT_BEGINNING_OPTIONS, createBeginning, isBeginning };
+//# sourceMappingURL=beginning.js.map

package/dist/transition/beginning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beginning.js","sources":["../../src/transition/beginning.ts"],"sourcesContent":["// NEW: Termination type extending Transition\n/**\n * Represents a termination point in the process flow, consuming a phase's output.\n */\n\nimport { clean } from '../util/general';\nimport { Context } from '../context';\nimport { Input } from '../input';\nimport { createTransition, isTransition, Transition, validateTransition } from './transition';\n\nexport type BeginFunction<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<Input>;\n\nexport interface Beginning<\n    I extends Input = Input,\n    C extends Context = Context,\n> extends Transition {\n    type: 'beginning';\n    targetNodeId: string;\n    // Currently, Termination is a marker type.\n    // Future properties could include:\n    // reason?: string; // To describe why termination occurred\n    begin: BeginFunction<I, C>; // A function to execute upon beginning\n}\n\nexport interface BeginningOptions<I extends Input = Input, C extends Context = Context> {\n    begin: BeginFunction<I, C>;\n}\n\nexport const DEFAULT_BEGINNING_OPTIONS: BeginningOptions<Input, Context> = {\n    begin: async (input) => {\n        return input;\n    }\n};\n\nexport const createBeginning = <I extends Input = Input, C extends Context = Context>(\n    id: string,\n    targetNodeId: string,\n    options?: Partial<BeginningOptions<I, C>>\n): Readonly<Beginning<I, C>> => {\n    let beginningOptions: BeginningOptions<I, C> = { ...DEFAULT_BEGINNING_OPTIONS };\n    if (options) {\n        beginningOptions = { ...beginningOptions, ...clean(options) };\n    }\n\n    return {\n        ...createTransition('beginning', id),\n        targetNodeId,\n        begin: beginningOptions.begin,\n    } as Beginning<I, C>;\n};\n\nexport const isBeginning = <I extends Input = Input, C extends Context = Context>(item: any): item is Beginning<I, C> => {\n    return isTransition(item) &&\n        item.type === 'beginning' &&\n        ((item as Beginning<I, C>).begin === undefined || typeof (item as Beginning<I, C>).begin === 'function');\n};\n\nexport const validateBeginning = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'Beginning'];\n\n    errors.push(...validateTransition(item, currentCoordinates));\n\n    if (errors.length === 0) {\n        currentCoordinates.push(`Beginning: ${item.id}`);\n\n        if (item.begin !== undefined && typeof item.begin !== 'function') {\n            errors.push({ coordinates: [...currentCoordinates], error: 'begin is not a function.' });\n        }\n    }\n\n    return errors;\n};\n"],"names":["DEFAULT_BEGINNING_OPTIONS","begin","input","createBeginning","id","targetNodeId","options","beginningOptions","clean","createTransition","isBeginning","item","isTransition","type","undefined"],"mappings":";;;AAAA;MA4BaA,yBAAAA,GAA8D;AACvEC,IAAAA,KAAAA,EAAO,OAAOC,KAAAA,GAAAA;QACV,OAAOA,KAAAA;AACX,IAAA;AACJ;AAEO,MAAMC,eAAAA,GAAkB,CAC3BC,EAAAA,EACAC,YAAAA,EACAC,OAAAA,GAAAA;AAEA,IAAA,IAAIC,gBAAAA,GAA2C;AAAE,QAAA,GAAGP;AAA0B,KAAA;AAC9E,IAAA,IAAIM,OAAAA,EAAS;QACTC,gBAAAA,GAAmB;AAAE,YAAA,GAAGA,gBAAgB;AAAE,YAAA,GAAGC,MAAMF,OAAAA;AAAS,SAAA;AAChE,IAAA;IAEA,OAAO;QACH,GAAGG,gBAAAA,CAAiB,aAAaL,EAAAA,CAAG;AACpCC,QAAAA,YAAAA;AACAJ,QAAAA,KAAAA,EAAOM,iBAAiBN;AAC5B,KAAA;AACJ;AAEO,MAAMS,cAAc,CAAuDC,IAAAA,GAAAA;AAC9E,IAAA,OAAOC,aAAaD,IAAAA,CAAAA,IAChBA,IAAAA,CAAKE,IAAI,KAAK,gBACZF,IAAAA,CAAyBV,KAAK,KAAKa,SAAAA,IAAa,OAAO,IAACH,CAAyBV,KAAK,KAAK,UAAS,CAAA;AAC9G;;;;"}

package/dist/transition/connection.d.ts

@@ -0,0 +1,55 @@
+import { Input } from '../input';
+import { Context } from '../context';
+import { Output } from '../output';
+import { Transition } from './transition';
+/**
+ * Transform function for connections between nodes.
+ * Takes the output from the source node and the current context,
+ * and returns the input for the target node along with an updated context.
+ *
+ * CONCURRENCY WARNING: In parallel execution scenarios (fan-out from one node
+ * to multiple target nodes), each connection's transform receives the same
+ * source context. Context mutations from one connection may be overwritten
+ * by another. The last transform to complete will have its context changes
+ * reflected in the process state.
+ *
+ * Best practice: Minimize context mutations in transforms, or use unique
+ * context keys per connection path to avoid conflicts.
+ */
+export type TransformFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[Input, C]>;
+export interface Connection<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'connection';
+    targetNodeId: string;
+    /**
+     * Optional function to transform the output of the current phase
+     * to the input of the target phase.
+     * If not provided, the output is assumed to be compatible directly.
+     *
+     * See TransformFunction documentation for concurrency considerations.
+     */
+    transform: TransformFunction<O, C>;
+}
+export interface ConnectionOptions<O extends Output = Output, C extends Context = Context> {
+    transform: TransformFunction<O, C>;
+}
+/**
+ * Default connection options with a pass-through transform.
+ * WARNING: The default transform uses a type assertion (output as Input) which provides
+ * no runtime validation. Users should provide their own transform function if the output
+ * type does not structurally match the expected input type of the target node.
+ * The type assertion is used here to maintain backward compatibility and allow simple
+ * pass-through scenarios where Output and Input have compatible shapes.
+ */
+export declare const DEFAULT_CONNECTION_OPTIONS: ConnectionOptions;
+export declare const createConnection: <O extends Output = Output, C extends Context = Context>(id: string, targetNodeId: string, options?: Partial<ConnectionOptions<O, C>>) => Readonly<Connection<O, C>>;
+export declare const isConnection: <O extends Output = Output, C extends Context = Context>(item: any) => item is Connection<O, C>;
+export declare const validateConnection: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;
+/**
+ * Event emitted specifically for connection transitions.
+ */
+export interface ConnectionEvent extends TransitionEvent {
+    transitionType: 'connection';
+}

package/dist/transition/connection.js

@@ -0,0 +1,90 @@
+import { createTransition, isTransition, validateTransition } from './transition.js';
+import { clean } from '../util/general.js';
+
+/**
+ * Default connection options with a pass-through transform.
+ * WARNING: The default transform uses a type assertion (output as Input) which provides
+ * no runtime validation. Users should provide their own transform function if the output
+ * type does not structurally match the expected input type of the target node.
+ * The type assertion is used here to maintain backward compatibility and allow simple
+ * pass-through scenarios where Output and Input have compatible shapes.
+ */ const DEFAULT_CONNECTION_OPTIONS = {
+    transform: async (output, context)=>{
+        // Type assertion used here - Output and Input are both extensible objects
+        // so this is safe for pass-through scenarios, but users should validate
+        // or transform data if types don't align
+        return [
+            output,
+            context
+        ];
+    }
+};
+const createConnection = (id, targetNodeId, options)=>{
+    let connectionOptions = {
+        ...DEFAULT_CONNECTION_OPTIONS
+    };
+    if (options) {
+        connectionOptions = {
+            ...connectionOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('connection', id),
+        targetNodeId,
+        transform: connectionOptions.transform
+    };
+};
+const isConnection = (item)=>{
+    return isTransition(item) && item.type === 'connection' && item.targetNodeId !== undefined;
+};
+const validateConnection = (item, coordinates)=>{
+    const errors = [];
+    const connectionBaseCoordinates = [
+        ...coordinates || [],
+        'Connection'
+    ];
+    errors.push(...validateTransition(item, coordinates));
+    if (errors.length === 0) {
+        if (item && typeof item === 'object') {
+            const connectionSpecificErrorPath = [
+                ...connectionBaseCoordinates,
+                `Connection: ${item.id}`
+            ];
+            if (item.type === 'connection') {
+                if (typeof item.targetNodeId !== 'string') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "targetNodeId" must be a string when type is "connection".'
+                    });
+                }
+                // transform is optional, but if present, must be a function.
+                if (item.transform !== undefined && typeof item.transform !== 'function') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Optional property "transform" must be a function if present.'
+                    });
+                }
+            } else {
+                // If type is not 'connection', but these properties exist and are malformed.
+                // This primarily helps catch if a non-connection object has these fields incorrectly defined.
+                if (item.targetNodeId !== undefined && typeof item.targetNodeId !== 'string') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "targetNodeId" is present but is not a string.'
+                    });
+                }
+                if (item.transform !== undefined && typeof item.transform !== 'function') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "transform" is present but is not a function.'
+                    });
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { DEFAULT_CONNECTION_OPTIONS, createConnection, isConnection, validateConnection };
+//# sourceMappingURL=connection.js.map

package/dist/transition/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","sources":["../../src/transition/connection.ts"],"sourcesContent":["import { Input } from '../input';\nimport { Context } from '../context';\nimport { Output } from '../output';\nimport { createTransition, isTransition, Transition, validateTransition } from './transition';\nimport { clean } from '../util/general';\n\n/**\n * Transform function for connections between nodes.\n * Takes the output from the source node and the current context,\n * and returns the input for the target node along with an updated context.\n *\n * CONCURRENCY WARNING: In parallel execution scenarios (fan-out from one node\n * to multiple target nodes), each connection's transform receives the same\n * source context. Context mutations from one connection may be overwritten\n * by another. The last transform to complete will have its context changes\n * reflected in the process state.\n *\n * Best practice: Minimize context mutations in transforms, or use unique\n * context keys per connection path to avoid conflicts.\n */\nexport type TransformFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[Input, C]>;\n\n// MODIFIED: Connection to extend Transition\nexport interface Connection<\n    O extends Output = Output,\n    C extends Context = Context,\n> extends Transition {\n    type: 'connection';\n    targetNodeId: string; // ID of the target PhaseNode in the process's phases collection\n    /**\n     * Optional function to transform the output of the current phase\n     * to the input of the target phase.\n     * If not provided, the output is assumed to be compatible directly.\n     *\n     * See TransformFunction documentation for concurrency considerations.\n     */\n    transform: TransformFunction<O, C>;\n}\n\nexport interface ConnectionOptions<O extends Output = Output, C extends Context = Context> {\n    transform: TransformFunction<O, C>;\n}\n\n/**\n * Default connection options with a pass-through transform.\n * WARNING: The default transform uses a type assertion (output as Input) which provides\n * no runtime validation. Users should provide their own transform function if the output\n * type does not structurally match the expected input type of the target node.\n * The type assertion is used here to maintain backward compatibility and allow simple\n * pass-through scenarios where Output and Input have compatible shapes.\n */\nexport const DEFAULT_CONNECTION_OPTIONS: ConnectionOptions = {\n    transform: async (output, context) => {\n        // Type assertion used here - Output and Input are both extensible objects\n        // so this is safe for pass-through scenarios, but users should validate\n        // or transform data if types don't align\n        return [output as Input, context];\n    }\n};\n\nexport const createConnection = <O extends Output = Output, C extends Context = Context>(\n    id: string,\n    targetNodeId: string,\n    options?: Partial<ConnectionOptions<O, C>>\n): Readonly<Connection<O, C>> => {\n\n    let connectionOptions: ConnectionOptions<O, C> = { ...DEFAULT_CONNECTION_OPTIONS } as unknown as ConnectionOptions<O, C>;\n\n    if (options) {\n        connectionOptions = { ...connectionOptions, ...clean(options) };\n    }\n\n    return {\n        ...createTransition('connection', id),\n        targetNodeId,\n        transform: connectionOptions.transform,\n    } as Connection<O, C>;\n};\n\nexport const isConnection = <O extends Output = Output, C extends Context = Context>(item: any): item is Connection<O, C> => {\n    return isTransition(item) && item.type === 'connection' && (item as Connection<O, C>).targetNodeId !== undefined;\n};\n\nexport const validateConnection = (\n    item: any,\n    coordinates?: string[]\n): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const connectionBaseCoordinates = [...(coordinates || []), 'Connection'];\n\n    errors.push(...validateTransition(item, coordinates));\n\n    if (errors.length === 0) {\n        if (item && typeof item === 'object') {\n            const connectionSpecificErrorPath = [...connectionBaseCoordinates, `Connection: ${item.id}`];\n\n            if (item.type === 'connection') {\n                if (typeof item.targetNodeId !== 'string') {\n                    errors.push({ coordinates: connectionSpecificErrorPath, error: 'Property \"targetNodeId\" must be a string when type is \"connection\".' });\n                }\n                // transform is optional, but if present, must be a function.\n                if (item.transform !== undefined && typeof item.transform !== 'function') {\n                    errors.push({ coordinates: connectionSpecificErrorPath, error: 'Optional property \"transform\" must be a function if present.' });\n                }\n            } else {\n                // If type is not 'connection', but these properties exist and are malformed.\n                // This primarily helps catch if a non-connection object has these fields incorrectly defined.\n                if (item.targetNodeId !== undefined && typeof item.targetNodeId !== 'string') {\n                    errors.push({ coordinates: connectionSpecificErrorPath, error: 'Property \"targetNodeId\" is present but is not a string.' });\n                }\n                if (item.transform !== undefined && typeof item.transform !== 'function') {\n                    errors.push({ coordinates: connectionSpecificErrorPath, error: 'Property \"transform\" is present but is not a function.' });\n                }\n            }\n        }\n    }\n    return errors;\n};\n\n/**\n * Event emitted specifically for connection transitions.\n */\nexport interface ConnectionEvent extends TransitionEvent {\n    transitionType: 'connection';\n}\n"],"names":["DEFAULT_CONNECTION_OPTIONS","transform","output","context","createConnection","id","targetNodeId","options","connectionOptions","clean","createTransition","isConnection","item","isTransition","type","undefined","validateConnection","coordinates","errors","connectionBaseCoordinates","push","validateTransition","length","connectionSpecificErrorPath","error"],"mappings":";;;AA2CA;;;;;;;UAQaA,0BAAAA,GAAgD;AACzDC,IAAAA,SAAAA,EAAW,OAAOC,MAAAA,EAAQC,OAAAA,GAAAA;;;;QAItB,OAAO;AAACD,YAAAA,MAAAA;AAAiBC,YAAAA;AAAQ,SAAA;AACrC,IAAA;AACJ;AAEO,MAAMC,gBAAAA,GAAmB,CAC5BC,EAAAA,EACAC,YAAAA,EACAC,OAAAA,GAAAA;AAGA,IAAA,IAAIC,iBAAAA,GAA6C;AAAE,QAAA,GAAGR;AAA2B,KAAA;AAEjF,IAAA,IAAIO,OAAAA,EAAS;QACTC,iBAAAA,GAAoB;AAAE,YAAA,GAAGA,iBAAiB;AAAE,YAAA,GAAGC,MAAMF,OAAAA;AAAS,SAAA;AAClE,IAAA;IAEA,OAAO;QACH,GAAGG,gBAAAA,CAAiB,cAAcL,EAAAA,CAAG;AACrCC,QAAAA,YAAAA;AACAL,QAAAA,SAAAA,EAAWO,kBAAkBP;AACjC,KAAA;AACJ;AAEO,MAAMU,eAAe,CAAyDC,IAAAA,GAAAA;IACjF,OAAOC,YAAAA,CAAaD,SAASA,IAAAA,CAAKE,IAAI,KAAK,YAAA,IAAiBF,IAAAA,CAA0BN,YAAY,KAAKS,SAAAA;AAC3G;AAEO,MAAMC,kBAAAA,GAAqB,CAC9BJ,IAAAA,EACAK,WAAAA,GAAAA;AAEA,IAAA,MAAMC,SAA0D,EAAE;AAClE,IAAA,MAAMC,yBAAAA,GAA4B;AAAKF,QAAAA,GAAAA,WAAAA,IAAe,EAAE;AAAG,QAAA;AAAa,KAAA;IAExEC,MAAAA,CAAOE,IAAI,CAAA,GAAIC,kBAAAA,CAAmBT,IAAAA,EAAMK,WAAAA,CAAAA,CAAAA;IAExC,IAAIC,MAAAA,CAAOI,MAAM,KAAK,CAAA,EAAG;QACrB,IAAIV,IAAAA,IAAQ,OAAOA,IAAAA,KAAS,QAAA,EAAU;AAClC,YAAA,MAAMW,2BAAAA,GAA8B;AAAIJ,gBAAAA,GAAAA,yBAAAA;AAA2B,gBAAA,CAAC,YAAY,EAAEP,IAAAA,CAAKP,EAAE,CAAA;AAAG,aAAA;YAE5F,IAAIO,IAAAA,CAAKE,IAAI,KAAK,YAAA,EAAc;AAC5B,gBAAA,IAAI,OAAOF,IAAAA,CAAKN,YAAY,KAAK,QAAA,EAAU;AACvCY,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,2BAAAA;wBAA6BC,KAAAA,EAAO;AAAsE,qBAAA,CAAA;AACzI,gBAAA;;gBAEA,IAAIZ,IAAAA,CAAKX,SAAS,KAAKc,SAAAA,IAAa,OAAOH,IAAAA,CAAKX,SAAS,KAAK,UAAA,EAAY;AACtEiB,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,2BAAAA;wBAA6BC,KAAAA,EAAO;AAA+D,qBAAA,CAAA;AAClI,gBAAA;YACJ,CAAA,MAAO;;;gBAGH,IAAIZ,IAAAA,CAAKN,YAAY,KAAKS,SAAAA,IAAa,OAAOH,IAAAA,CAAKN,YAAY,KAAK,QAAA,EAAU;AAC1EY,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,2BAAAA;wBAA6BC,KAAAA,EAAO;AAA0D,qBAAA,CAAA;AAC7H,gBAAA;gBACA,IAAIZ,IAAAA,CAAKX,SAAS,KAAKc,SAAAA,IAAa,OAAOH,IAAAA,CAAKX,SAAS,KAAK,UAAA,EAAY;AACtEiB,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,2BAAAA;wBAA6BC,KAAAA,EAAO;AAAyD,qBAAA,CAAA;AAC5H,gBAAA;AACJ,YAAA;AACJ,QAAA;AACJ,IAAA;IACA,OAAON,MAAAA;AACX;;;;"}

package/dist/transition/decision.d.ts

@@ -0,0 +1,20 @@
+import { Termination } from '../xenocline';
+import { Context } from '../context';
+import { Output } from '../output';
+import { Connection } from './connection';
+import { Transition } from './transition';
+export type DecideFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Termination<O, C> | Connection<O, C>[]>;
+/**
+ * Represents a decision point in the process flow, taking a phase's output and context
+ * to determine the next step.
+ */
+export interface Decision<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'decision';
+    decide: DecideFunction<O, C>;
+}
+export declare const createDecision: <O extends Output = Output, C extends Context = Context>(id: string, decide: DecideFunction<O, C>) => Readonly<Decision<O, C>>;
+export declare const isDecision: <O extends Output = Output, C extends Context = Context>(item: any) => item is Decision<O, C>;
+export declare const validateDecision: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/decision.js

@@ -0,0 +1,47 @@
+import { createTransition, isTransition, validateTransition } from './transition.js';
+
+const createDecision = (id, decide)=>{
+    return {
+        ...createTransition('decision', id),
+        decide
+    };
+};
+const isDecision = (item)=>{
+    return isTransition(item) && item.type === 'decision' && typeof item.decide === 'function';
+};
+const validateDecision = (item, coordinates)=>{
+    const errors = [];
+    const decisionBaseCoordinates = [
+        ...coordinates || [],
+        'Decision'
+    ];
+    errors.push(...validateTransition(item, coordinates));
+    if (errors.length === 0) {
+        if (item && typeof item === 'object') {
+            const decisionSpecificErrorPath = [
+                ...decisionBaseCoordinates,
+                `Decision: ${item.id}`
+            ];
+            if (item.type === 'decision') {
+                if (typeof item.decide !== 'function') {
+                    errors.push({
+                        coordinates: decisionSpecificErrorPath,
+                        error: 'Property "decide" must be a function when type is "decision".'
+                    });
+                }
+            } else {
+                // If type is not 'decision', but 'decide' property exists and is malformed.
+                if (item.decide !== undefined && typeof item.decide !== 'function') {
+                    errors.push({
+                        coordinates: decisionSpecificErrorPath,
+                        error: 'Property "decide" is present but is not a function.'
+                    });
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { createDecision, isDecision, validateDecision };
+//# sourceMappingURL=decision.js.map

package/dist/transition/decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.js","sources":["../../src/transition/decision.ts"],"sourcesContent":["import { Termination } from '../xenocline';\nimport { Context } from '../context';\nimport { Output } from '../output';\nimport { Connection } from './connection';\nimport { createTransition, isTransition, Transition, validateTransition } from './transition';\n\nexport type DecideFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Termination<O, C> | Connection<O, C>[]>;\n\n/**\n * Represents a decision point in the process flow, taking a phase's output and context\n * to determine the next step.\n */\nexport interface Decision<\n    O extends Output = Output,\n    C extends Context = Context,\n> extends Transition {\n    type: 'decision';\n    decide: DecideFunction<O, C>;\n}\n\n\nexport const createDecision = <O extends Output = Output, C extends Context = Context>(\n    id: string,\n    decide: DecideFunction<O, C>\n): Readonly<Decision<O, C>> => {\n\n    return {\n        ...createTransition('decision', id),\n        decide,\n    } as Decision<O, C>;\n};\n\nexport const isDecision = <O extends Output = Output, C extends Context = Context>(item: any): item is Decision<O, C> => {\n    return isTransition(item) && item.type === 'decision' && typeof (item as Decision<O, C>).decide === 'function';\n};\n\nexport const validateDecision = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const decisionBaseCoordinates = [...(coordinates || []), 'Decision'];\n\n    errors.push(...validateTransition(item, coordinates));\n\n    if (errors.length === 0) {\n        if (item && typeof item === 'object') {\n            const decisionSpecificErrorPath = [...decisionBaseCoordinates, `Decision: ${item.id}`];\n\n            if (item.type === 'decision') {\n                if (typeof item.decide !== 'function') {\n                    errors.push({ coordinates: decisionSpecificErrorPath, error: 'Property \"decide\" must be a function when type is \"decision\".' });\n                }\n            } else {\n                // If type is not 'decision', but 'decide' property exists and is malformed.\n                if (item.decide !== undefined && typeof item.decide !== 'function') {\n                    errors.push({ coordinates: decisionSpecificErrorPath, error: 'Property \"decide\" is present but is not a function.' });\n                }\n            }\n        }\n    }\n    return errors;\n};"],"names":["createDecision","id","decide","createTransition","isDecision","item","isTransition","type","validateDecision","coordinates","errors","decisionBaseCoordinates","push","validateTransition","length","decisionSpecificErrorPath","error","undefined"],"mappings":";;AAqBO,MAAMA,cAAAA,GAAiB,CAC1BC,EAAAA,EACAC,MAAAA,GAAAA;IAGA,OAAO;QACH,GAAGC,gBAAAA,CAAiB,YAAYF,EAAAA,CAAG;AACnCC,QAAAA;AACJ,KAAA;AACJ;AAEO,MAAME,aAAa,CAAyDC,IAAAA,GAAAA;IAC/E,OAAOC,YAAAA,CAAaD,IAAAA,CAAAA,IAASA,IAAAA,CAAKE,IAAI,KAAK,cAAc,OAAQF,IAAAA,CAAwBH,MAAM,KAAK,UAAA;AACxG;AAEO,MAAMM,gBAAAA,GAAmB,CAACH,IAAAA,EAAWI,WAAAA,GAAAA;AACxC,IAAA,MAAMC,SAA0D,EAAE;AAClE,IAAA,MAAMC,uBAAAA,GAA0B;AAAKF,QAAAA,GAAAA,WAAAA,IAAe,EAAE;AAAG,QAAA;AAAW,KAAA;IAEpEC,MAAAA,CAAOE,IAAI,CAAA,GAAIC,kBAAAA,CAAmBR,IAAAA,EAAMI,WAAAA,CAAAA,CAAAA;IAExC,IAAIC,MAAAA,CAAOI,MAAM,KAAK,CAAA,EAAG;QACrB,IAAIT,IAAAA,IAAQ,OAAOA,IAAAA,KAAS,QAAA,EAAU;AAClC,YAAA,MAAMU,yBAAAA,GAA4B;AAAIJ,gBAAAA,GAAAA,uBAAAA;AAAyB,gBAAA,CAAC,UAAU,EAAEN,IAAAA,CAAKJ,EAAE,CAAA;AAAG,aAAA;YAEtF,IAAII,IAAAA,CAAKE,IAAI,KAAK,UAAA,EAAY;AAC1B,gBAAA,IAAI,OAAOF,IAAAA,CAAKH,MAAM,KAAK,UAAA,EAAY;AACnCQ,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,yBAAAA;wBAA2BC,KAAAA,EAAO;AAAgE,qBAAA,CAAA;AACjI,gBAAA;YACJ,CAAA,MAAO;;gBAEH,IAAIX,IAAAA,CAAKH,MAAM,KAAKe,SAAAA,IAAa,OAAOZ,IAAAA,CAAKH,MAAM,KAAK,UAAA,EAAY;AAChEQ,oBAAAA,MAAAA,CAAOE,IAAI,CAAC;wBAAEH,WAAAA,EAAaM,yBAAAA;wBAA2BC,KAAAA,EAAO;AAAsD,qBAAA,CAAA;AACvH,gBAAA;AACJ,YAAA;AACJ,QAAA;AACJ,IAAA;IACA,OAAON,MAAAA;AACX;;;;"}

package/dist/transition/next.d.ts

@@ -0,0 +1,13 @@
+import { Output } from '../output';
+import { Context } from '../context';
+import { Termination } from './termination';
+import { Connection } from './connection';
+import { Decision } from './decision';
+type NonEmptyArray<T> = [T, ...T[]];
+export type Next<O extends Output = Output, C extends Context = Context> = Termination<O, C> | Readonly<NonEmptyArray<Connection<O, C>>> | Readonly<NonEmptyArray<Decision<O, C>>>;
+export declare const isNext: <O extends Output = Output, C extends Context = Context>(item: any) => item is Next<O, C>;
+export declare const validateNext: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;
+export {};

package/dist/transition/next.js

@@ -0,0 +1,81 @@
+import { validateTermination, isTermination } from './termination.js';
+import { isConnection, validateConnection } from './connection.js';
+import { isDecision, validateDecision } from './decision.js';
+
+const isNext = (item)=>{
+    if (isTermination(item)) {
+        return true;
+    }
+    if (!Array.isArray(item)) {
+        return false;
+    }
+    if (item.length === 0) {
+        return true;
+    }
+    const firstElement = item[0];
+    if (isConnection(firstElement)) {
+        return item.every((el)=>isConnection(el));
+    }
+    if (isDecision(firstElement)) {
+        return item.every((el)=>isDecision(el));
+    }
+    return false;
+};
+const validateDecisionOrConnectionArray = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || []
+    ];
+    if (item.length === 0) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next Array is empty.'
+        });
+        return errors;
+    }
+    const firstElement = item[0];
+    if (isConnection(firstElement)) {
+        for (const element of item){
+            errors.push(...validateConnection(element, currentCoordinates));
+        }
+    } else if (isDecision(firstElement)) {
+        for (const element of item){
+            errors.push(...validateDecision(element, currentCoordinates));
+        }
+    } else {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next Array contains invalid element types. Expected all Connections or all Decisions.'
+        });
+    }
+    return errors;
+};
+const validateNext = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Next'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next is undefined or null.'
+        });
+        return errors;
+    }
+    if (Array.isArray(item)) {
+        errors.push(...validateDecisionOrConnectionArray(item, currentCoordinates));
+    } else {
+        errors.push(...validateTermination(item, currentCoordinates));
+    }
+    return errors;
+};
+
+export { isNext, validateNext };
+//# sourceMappingURL=next.js.map

package/dist/transition/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sources":["../../src/transition/next.ts"],"sourcesContent":["import { Output } from '../output';\nimport { Context } from '../context';\nimport { isTermination, Termination, validateTermination } from './termination';\nimport { Connection, isConnection, validateConnection } from './connection';\nimport { Decision, isDecision, validateDecision } from './decision';\n\ntype NonEmptyArray<T> = [T, ...T[]];\n\nexport type Next<O extends Output = Output, C extends Context = Context> = Termination<O, C> | Readonly<NonEmptyArray<Connection<O, C>>> | Readonly<NonEmptyArray<Decision<O, C>>>;\n\nexport const isNext = <O extends Output = Output, C extends Context = Context>(item: any): item is Next<O, C> => {\n    if (isTermination<O, C>(item)) {\n        return true;\n    }\n\n    if (!Array.isArray(item)) {\n        return false;\n    }\n\n    if (item.length === 0) {\n        return true;\n    }\n\n    const firstElement = item[0];\n    if (isConnection<O, C>(firstElement)) {\n        return item.every((el: any) => isConnection<O, C>(el));\n    }\n    if (isDecision<O, C>(firstElement)) {\n        return item.every((el: any) => isDecision<O, C>(el));\n    }\n\n    return false;\n};\n\nconst validateDecisionOrConnectionArray = <O extends Output = Output, C extends Context = Context>(item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || [])];\n\n    if (item.length === 0) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Next Array is empty.' });\n        return errors;\n    }\n\n    const firstElement = item[0];\n    if (isConnection<O, C>(firstElement)) {\n        for (const element of item) {\n            errors.push(...validateConnection(element, currentCoordinates));\n        }\n    } else if (isDecision<O, C>(firstElement)) {\n        for (const element of item) {\n            errors.push(...validateDecision(element, currentCoordinates));\n        }\n    } else {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Next Array contains invalid element types. Expected all Connections or all Decisions.' });\n    }\n\n    return errors;\n}\n\nexport const validateNext = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n\n    const currentCoordinates = [...(coordinates || []), 'Next'];\n\n    if (item === undefined || item === null) {\n        errors.push({ coordinates: [...currentCoordinates], error: 'Next is undefined or null.' });\n        return errors;\n    }\n\n    if (Array.isArray(item)) {\n        errors.push(...validateDecisionOrConnectionArray(item, currentCoordinates));\n    } else {\n        errors.push(...validateTermination(item, currentCoordinates));\n    }\n\n    return errors;\n}"],"names":["isNext","item","isTermination","Array","isArray","length","firstElement","isConnection","every","el","isDecision","validateDecisionOrConnectionArray","coordinates","errors","currentCoordinates","push","error","element","validateConnection","validateDecision","validateNext","undefined","validateTermination"],"mappings":"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"}

package/dist/transition/termination.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+import { Output } from '../output';
+import { Transition } from './transition';
+export type TerminateFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Output>;
+export interface Termination<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'termination';
+    terminate: TerminateFunction<O, C>;
+}
+export interface TerminationOptions<O extends Output = Output, C extends Context = Context> {
+    terminate: TerminateFunction<O, C>;
+}
+export declare const createTermination: <O extends Output = Output, C extends Context = Context>(id: string, options?: Partial<TerminationOptions<O, C>>) => Readonly<Termination<O, C>>;
+export declare const isTermination: <O extends Output = Output, C extends Context = Context>(item: any) => item is Termination<O, C>;
+export declare const validateTermination: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/termination.js

@@ -0,0 +1,50 @@
+import { clean } from '../util/general.js';
+import { createTransition, isTransition, validateTransition } from './transition.js';
+
+// NEW: Termination type extending Transition
+const createTermination = (id, options)=>{
+    const defaultOptions = {
+        terminate: async (output)=>{
+            return output;
+        }
+    };
+    let terminationOptions = {
+        ...defaultOptions
+    };
+    if (options) {
+        terminationOptions = {
+            ...terminationOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('termination', id),
+        terminate: terminationOptions.terminate
+    };
+};
+const isTermination = (item)=>{
+    return isTransition(item) && item.type === 'termination' && (item.terminate === undefined || typeof item.terminate === 'function');
+};
+const validateTermination = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Termination'
+    ];
+    errors.push(...validateTransition(item, currentCoordinates));
+    if (errors.length === 0) {
+        currentCoordinates.push(`Termination: ${item.id}`);
+        if (item.terminate !== undefined && typeof item.terminate !== 'function') {
+            errors.push({
+                coordinates: [
+                    ...currentCoordinates
+                ],
+                error: 'terminate is not a function.'
+            });
+        }
+    }
+    return errors;
+};
+
+export { createTermination, isTermination, validateTermination };
+//# sourceMappingURL=termination.js.map

package/dist/transition/termination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"termination.js","sources":["../../src/transition/termination.ts"],"sourcesContent":["// NEW: Termination type extending Transition\n/**\n * Represents a termination point in the process flow, consuming a phase's output.\n */\n\nimport { clean } from '../util/general';\nimport { Context } from '../context';\nimport { Output } from '../output';\nimport { createTransition, isTransition, Transition, validateTransition } from './transition';\n\nexport type TerminateFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Output>;\n\nexport interface Termination<\n    O extends Output = Output,\n    C extends Context = Context,\n> extends Transition {\n    type: 'termination';\n    // Currently, Termination is a marker type.\n    // Future properties could include:\n    // reason?: string; // To describe why termination occurred\n    terminate: TerminateFunction<O, C>; // A function to execute upon termination\n}\n\nexport interface TerminationOptions<O extends Output = Output, C extends Context = Context> {\n    terminate: TerminateFunction<O, C>;\n}\n\nexport const createTermination = <O extends Output = Output, C extends Context = Context>(\n    id: string,\n    options?: Partial<TerminationOptions<O, C>>\n): Readonly<Termination<O, C>> => {\n\n    const defaultOptions: TerminationOptions<O, C> = {\n        terminate: async (output) => {\n            return output;\n        }\n    };\n\n    let terminationOptions: TerminationOptions<O, C> = { ...defaultOptions };\n    if (options) {\n        terminationOptions = { ...terminationOptions, ...clean(options) };\n    }\n\n    return {\n        ...createTransition('termination', id),\n        terminate: terminationOptions.terminate,\n    } as Termination<O, C>;\n};\n\nexport const isTermination = <O extends Output = Output, C extends Context = Context>(item: any): item is Termination<O, C> => {\n    return isTransition(item) &&\n        item.type === 'termination' &&\n        ((item as Termination<O, C>).terminate === undefined || typeof (item as Termination<O, C>).terminate === 'function');\n};\n\nexport const validateTermination = (item: any, coordinates?: string[]): Array<{ coordinates: string[], error: string }> => {\n    const errors: Array<{ coordinates: string[], error: string }> = [];\n    const currentCoordinates = [...(coordinates || []), 'Termination'];\n\n    errors.push(...validateTransition(item, currentCoordinates));\n\n    if (errors.length === 0) {\n        currentCoordinates.push(`Termination: ${item.id}`);\n\n        if (item.terminate !== undefined && typeof item.terminate !== 'function') {\n            errors.push({ coordinates: [...currentCoordinates], error: 'terminate is not a function.' });\n        }\n    }\n\n    return errors;\n};\n"],"names":["createTermination","id","options","defaultOptions","terminate","output","terminationOptions","clean","createTransition","isTermination","item","isTransition","type","undefined","validateTermination","coordinates","errors","currentCoordinates","push","validateTransition","length","error"],"mappings":";;;AAAA;AA2BO,MAAMA,iBAAAA,GAAoB,CAC7BC,EAAAA,EACAC,OAAAA,GAAAA;AAGA,IAAA,MAAMC,cAAAA,GAA2C;AAC7CC,QAAAA,SAAAA,EAAW,OAAOC,MAAAA,GAAAA;YACd,OAAOA,MAAAA;AACX,QAAA;AACJ,KAAA;AAEA,IAAA,IAAIC,kBAAAA,GAA+C;AAAE,QAAA,GAAGH;AAAe,KAAA;AACvE,IAAA,IAAID,OAAAA,EAAS;QACTI,kBAAAA,GAAqB;AAAE,YAAA,GAAGA,kBAAkB;AAAE,YAAA,GAAGC,MAAML,OAAAA;AAAS,SAAA;AACpE,IAAA;IAEA,OAAO;QACH,GAAGM,gBAAAA,CAAiB,eAAeP,EAAAA,CAAG;AACtCG,QAAAA,SAAAA,EAAWE,mBAAmBF;AAClC,KAAA;AACJ;AAEO,MAAMK,gBAAgB,CAAyDC,IAAAA,GAAAA;AAClF,IAAA,OAAOC,aAAaD,IAAAA,CAAAA,IAChBA,IAAAA,CAAKE,IAAI,KAAK,kBACZF,IAAAA,CAA2BN,SAAS,KAAKS,SAAAA,IAAa,OAAO,IAACH,CAA2BN,SAAS,KAAK,UAAS,CAAA;AAC1H;AAEO,MAAMU,mBAAAA,GAAsB,CAACJ,IAAAA,EAAWK,WAAAA,GAAAA;AAC3C,IAAA,MAAMC,SAA0D,EAAE;AAClE,IAAA,MAAMC,kBAAAA,GAAqB;AAAKF,QAAAA,GAAAA,WAAAA,IAAe,EAAE;AAAG,QAAA;AAAc,KAAA;IAElEC,MAAAA,CAAOE,IAAI,CAAA,GAAIC,kBAAAA,CAAmBT,IAAAA,EAAMO,kBAAAA,CAAAA,CAAAA;IAExC,IAAID,MAAAA,CAAOI,MAAM,KAAK,CAAA,EAAG;AACrBH,QAAAA,kBAAAA,CAAmBC,IAAI,CAAC,CAAC,aAAa,EAAER,IAAAA,CAAKT,EAAE,CAAA,CAAE,CAAA;QAEjD,IAAIS,IAAAA,CAAKN,SAAS,KAAKS,SAAAA,IAAa,OAAOH,IAAAA,CAAKN,SAAS,KAAK,UAAA,EAAY;AACtEY,YAAAA,MAAAA,CAAOE,IAAI,CAAC;gBAAEH,WAAAA,EAAa;AAAIE,oBAAAA,GAAAA;AAAmB,iBAAA;gBAAEI,KAAAA,EAAO;AAA+B,aAAA,CAAA;AAC9F,QAAA;AACJ,IAAA;IAEA,OAAOL,MAAAA;AACX;;;;"}