@hotmeshio/hotmesh 0.0.7 → 0.0.8

package/build/esm/services/collator/index.js

@@ -1,15 +1,36 @@
 import { CollationError } from '../../modules/errors';
 import { CollationFaultType } from '../../types/collator';
 class CollatorService {
-    static getDimensionalAddress(activity) {
+    /**
+     * returns the dimensional address (dad) for the target; due
+     * to the nature of the notary system, the dad for leg 2 entry
+     * must target the `0` index while leg 2 exit must target the
+     * current index (0)
+     */
+    static getDimensionalAddress(activity, isEntry = false) {
         let dad = activity.context.metadata.dad || activity.metadata.dad;
-        //todo: unsure about this reset
-        // if (dad && activity.leg === 2) {
-        //   console.log('setting dad index back to 0=>', dad);
-        //   dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
-        // }
+        if (isEntry && dad && activity.leg === 2) {
+            dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
+        }
         return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
     }
+    /**
+     * resolves the dimensional address for the
+     * ancestor in the graph to go back to. this address
+     * is determined by trimming the last digits from
+     * the `dad` (including the target).
+     * the target activity index is then set to `0`, so that
+     * the origin node can be queried for approval/entry.
+     */
+    static resolveReentryDimension(activity) {
+        const targetActivityId = activity.config.ancestor;
+        const ancestors = activity.config.ancestors;
+        const ancestorIndex = ancestors.indexOf(targetActivityId);
+        const dimensions = activity.metadata.dad.split(','); //e.g., `,0,0,1,0`
+        dimensions.length = ancestorIndex + 1;
+        dimensions.push('0');
+        return dimensions.join(',');
+    }
     static async notarizeEntry(activity, multi) {
         //decrement by -100_000_000_000_000
         const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100000000000000, this.getDimensionalAddress(activity), multi);
@@ -24,14 +45,21 @@ class CollatorService {
         //this.verifyInteger(amount, 1, 'exit');
         return amount;
     }
+    static async notarizeEarlyExit(activity, multi) {
+        //decrement the 2nd and 3rd digits to fully deactivate (`cycle` activities use this command to fully exit after leg 1) (should result in `888000000000000`)
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -11000000000000, this.getDimensionalAddress(activity), multi);
+    }
+    ;
     static async notarizeEarlyCompletion(activity, multi) {
-        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd and 3rd digits to deactivate the activity
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - 11000000000000, this.getDimensionalAddress(activity), multi);
+        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd
+        //3rd digit is optionally kept open if the activity might be used in a cycle
+        const decrement = activity.config.cycle ? 10000000000000 : 11000000000000;
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - decrement, this.getDimensionalAddress(activity), multi);
     }
     ;
     static async notarizeReentry(activity, multi) {
         //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
-        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000000, this.getDimensionalAddress(activity), multi);
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000000, this.getDimensionalAddress(activity, true), multi);
         this.verifyInteger(amount, 2, 'enter');
         return amount;
     }
@@ -42,8 +70,10 @@ class CollatorService {
     }
     ;
     static async notarizeCompletion(activity, multi) {
-        //close out; actualize leg2 dimension (+1) and decrement the 3rd digit (-1_000_000_000_000)
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - 1000000000000, this.getDimensionalAddress(activity), multi);
+        //1) ALWAYS actualize leg2 dimension (+1)
+        //2) IF the activity is used in a cycle, don't close leg 2!
+        const decrement = activity.config.cycle ? 0 : -1000000000000;
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), multi);
     }
     ;
     static getDigitAtIndex(num, targetDigitIndex) {

package/build/esm/services/durable/factory.js

@@ -26,7 +26,12 @@ const getWorkflowYAML = (topic, version = '1') => {
           type: trigger
           stats:
             id: '{$self.input.data.workflowId}'
+
         a1:
+          type: activity
+          cycle: true
+  
+        w1:
           type: worker
           topic: ${topic}
           input:
@@ -49,9 +54,20 @@ const getWorkflowYAML = (topic, version = '1') => {
           job:
             maps:
               response: '{$self.output.data.response}'
+
+        c1:
+          type: cycle
+          ancestor: a1
       transitions:
         t1:
-          - to: a1`;
+          - to: a1
+        a1:
+          - to: w1
+        w1:
+          - to: c1
+            conditions:
+              code: 500
+`;
 };
 const getActivityYAML = (topic, version = '1') => {
     return `app:

package/build/esm/services/durable/worker.d.ts

@@ -5,6 +5,7 @@ export declare class WorkerService {
     static connection: Connection;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     workflowRunner: HotMesh;
+    activityRunner: HotMesh;
     static getHotMesh: (worflowTopic: string) => Promise<HotMesh>;
     static activateWorkflow(hotMesh: HotMesh, topic: string, factory: Function): Promise<void>;
     /**

package/build/esm/services/durable/worker.js

@@ -94,8 +94,8 @@ class WorkerService {
         const workflowTopic = `${baseTopic}`;
         //initialize supporting workflows
         const worker = new WorkerService();
-        const activityRunner = await worker.initActivityWorkflow(config, activityTopic);
-        await WorkerService.activateWorkflow(activityRunner, activityTopic, getActivityYAML);
+        worker.activityRunner = await worker.initActivityWorkflow(config, activityTopic);
+        await WorkerService.activateWorkflow(worker.activityRunner, activityTopic, getActivityYAML);
         worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
         await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, getWorkflowYAML);
         return worker;
@@ -113,12 +113,7 @@ class WorkerService {
         return [workflowFunction.name, workflowFunction];
     }
     async run() {
-        if (this.workflowRunner) {
-            this.workflowRunner.engine.logger.info('WorkerService is running');
-        }
-        else {
-            console.log('WorkerService is running');
-        }
+        this.workflowRunner.engine.logger.info('WorkerService is running');
     }
     async initActivityWorkflow(config, activityTopic) {
         const redisConfig = {
@@ -153,10 +148,11 @@ class WorkerService {
                 };
             }
             catch (err) {
-                console.error(err);
-                //todo (make retry configurable)
+                this.activityRunner.engine.logger.error('durable-worker-activity-err', err);
                 return {
-                    status: StreamStatus.PENDING,
+                    status: StreamStatus.ERROR,
+                    code: 500,
+                    message: err.message,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };
@@ -173,7 +169,7 @@ class WorkerService {
                 await hotMesh.activate(version);
             }
             catch (err) {
-                console.log('durable-worker-activity-deploy-activate-error', err);
+                hotMesh.engine.logger.error('durable-worker-activity-deploy-activate-error', err);
                 throw err;
             }
         }
@@ -229,10 +225,9 @@ class WorkerService {
                 };
             }
             catch (err) {
-                //todo: (retryable error types)
                 return {
+                    status: StreamStatus.ERROR,
                     code: 500,
-                    status: StreamStatus.PENDING,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };

package/build/esm/services/durable/workflow.js

@@ -94,7 +94,11 @@ export class WorkflowService {
             try {
                 const hmshInstance = await WorkerService.getHotMesh(activityTopic);
                 activityState = await hmshInstance.getState(activityTopic, activityJobId);
-                if (activityState.metadata.js == 1) {
+                if (activityState.metadata.err) {
+                    await hmshInstance.scrub(activityJobId);
+                    throw new Error(activityState.metadata.err);
+                }
+                else if (activityState.metadata.js === 0) {
                     //return immediately
                     return activityState.data?.response;
                 }

package/build/esm/services/mapper/index.js

@@ -47,6 +47,9 @@ class MapperService {
             return transitionRule;
         }
         if (code.toString() === (transitionRule.code || 200).toString()) {
+            if (!transitionRule.match) {
+                return true;
+            }
             const orGate = transitionRule.gate === 'or';
             let allAreTrue = true;
             let someAreTrue = false;

package/build/esm/services/signaler/stream.js

@@ -118,7 +118,6 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (err) {
-            console.error(err);
             this.logger.error(`stream-call-function-error`, { stream, id, err });
             output = this.structureUnhandledError(input, err);
         }

package/build/esm/types/activity.d.ts

@@ -1,6 +1,6 @@
 import { MetricTypes } from "./stats";
 import { StreamRetryPolicy } from "./stream";
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate';
+type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle';
 type Consumes = Record<string, string[]>;
 interface BaseActivity {
     title?: string;
@@ -15,6 +15,7 @@ interface BaseActivity {
     sleep?: number;
     expire?: number;
     retry?: StreamRetryPolicy;
+    cycle?: boolean;
     collationInt?: number;
     consumes?: Consumes;
     PRODUCES?: string[];
@@ -55,6 +56,10 @@ interface WorkerActivity extends BaseActivity {
 interface EmitActivity extends BaseActivity {
     type: 'emit';
 }
+interface CycleActivity extends BaseActivity {
+    type: 'cycle';
+    ancestor: string;
+}
 interface IterateActivity extends BaseActivity {
     type: 'iterate';
 }
@@ -84,4 +89,4 @@ type ActivityDataType = {
     hook?: Record<string, unknown>;
 };
 type ActivityLeg = 1 | 2;
-export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, BaseActivity, EmitActivity, IterateActivity, TriggerActivity, WorkerActivity };
+export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, BaseActivity, EmitActivity, IterateActivity, TriggerActivity, WorkerActivity };

package/build/esm/types/index.d.ts

@@ -1,4 +1,4 @@
-export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, EmitActivity, WorkerActivity, IterateActivity, TriggerActivity, TriggerActivityStats } from './activity';
+export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, EmitActivity, WorkerActivity, IterateActivity, TriggerActivity, TriggerActivityStats } from './activity';
 export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Durable Workflows",
   "main": "build/cjs/index.js",
   "module": "build/esm/index.js",
@@ -29,6 +29,7 @@
     "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
     "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
     "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
@@ -48,6 +49,7 @@
     "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
   },

package/services/activities/activity.ts

@@ -129,7 +129,7 @@ class Activity {
     this.leg = leg;
   }
 
-  //********  SIGNALER RE-ENTRY POINT (B)  ********//
+  //********  SIGNAL RE-ENTRY POINT  ********//
   doesHook(): boolean {
     return !!(this.config.hook?.topic || this.config.sleep);
   }
@@ -170,11 +170,6 @@ class Activity {
     return await this.processHookEvent(jobId);
   }
 
-  //todo: hooks are currently singletons. but they can support
-  //      dimensional threads like `await` and `worker` do.
-  //      Copy code from those activities to support cyclical
-  //      timehook and eventhook inputs by adding a 'pending'
-  //      flag to hooks that allows for repeated signals
   async processHookEvent(jobId: string): Promise<JobStatus | void> {
     this.logger.debug('activity-process-hook-event', { jobId });
     let telemetry: TelemetryService;
@@ -207,7 +202,6 @@ class Activity {
       telemetry.setActivityAttributes(attrs);
       return jobStatus as number;
     } catch (error) {
-      console.error('this error?', error);
       this.logger.error('engine-process-hook-event-error', error);
       telemetry.setActivityError(error.message);
       throw error;
@@ -216,6 +210,95 @@ class Activity {
     }
   }
 
+  //********  DUPLEX RE-ENTRY POINT  ********//
+  async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<void> {
+    this.setLeg(2);
+    const jid = this.context.metadata.jid;
+    const aid = this.metadata.aid;
+    this.status = status;
+    this.code = code;
+    this.logger.debug('activity-process-event', { topic: this.config.subtype, jid, aid, status, code });
+    let telemetry: TelemetryService;
+    try {
+      await this.getState();
+      const aState = await CollatorService.notarizeReentry(this);
+      this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
+
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      let isComplete = CollatorService.isActivityComplete(this.context.metadata.js);
+
+      if (isComplete) {
+        this.logger.warn('activity-process-event-duplicate', { jid, aid });
+        this.logger.debug('activity-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
+        return;
+      }
+
+      telemetry.startActivitySpan(this.leg);
+      let multiResponse: MultiResponseFlags;
+      if (status === StreamStatus.PENDING) {
+        multiResponse = await this.processPending(telemetry);
+      } else if (status === StreamStatus.SUCCESS) {
+        multiResponse = await this.processSuccess(telemetry);
+      } else {
+        multiResponse = await this.processError(telemetry);
+      }
+      this.transitionAdjacent(multiResponse, telemetry);
+    } catch (error) {
+      this.logger.error('activity-process-event-error', error);
+      telemetry.setActivityError(error.message);
+      throw error;
+    } finally {
+      telemetry.endActivitySpan();
+      this.logger.debug('activity-process-event-end', { jid, aid });
+    }
+  }
+
+  async processPending(telemetry: TelemetryService): Promise<MultiResponseFlags> {
+    this.bindActivityData('output');
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapJobData();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeContinuation(this, multi);
+
+    await this.setStatus(this.adjacencyList.length, multi);
+    return await multi.exec() as MultiResponseFlags;
+  }
+
+  async processSuccess(telemetry: TelemetryService): Promise<MultiResponseFlags> {
+    this.bindActivityData('output');
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapJobData();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    return await multi.exec() as MultiResponseFlags;
+  }
+
+  async processError(telemetry: TelemetryService): Promise<MultiResponseFlags> {
+    this.bindActivityError(this.data);
+    this.adjacencyList = await this.filterAdjacent();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    return await multi.exec() as MultiResponseFlags;
+  }
+
+  async transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void> {
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+    const messageIds = await this.transition(this.adjacencyList, jobStatus);
+    if (messageIds.length) {
+      attrs['app.activity.mids'] = messageIds.join(',')
+    }
+    telemetry.setActivityAttributes(attrs);
+  }
+
   resolveStatus(multiResponse: MultiResponseFlags): number {
     const activityStatus = multiResponse[multiResponse.length - 1];
     if (Array.isArray(activityStatus)) {

package/services/activities/await.ts

@@ -44,7 +44,7 @@ class Await extends Activity {
       this.mapInputData();
 
       const multi = this.store.getMulti();
-      //await this.registerTimeout();
+      //todo: await this.registerTimeout();
       await CollatorService.authorizeReentry(this, multi);
       await this.setState(multi);
       await this.setStatus(0, multi);
@@ -121,11 +121,11 @@ class Await extends Activity {
       if (status === StreamStatus.SUCCESS) {
         this.bindActivityData('output');
         this.adjacencyList = await this.filterAdjacent();
-        multiResponse = await this.processSuccess(this.adjacencyList);
+        multiResponse = await this.processSuccessResponse(this.adjacencyList);
       } else {
         this.bindActivityError(this.data);
         this.adjacencyList = await this.filterAdjacent();
-        multiResponse = await this.processError(this.adjacencyList);
+        multiResponse = await this.processErrorResponse(this.adjacencyList);
       }
 
       telemetry.mapActivityAttributes();
@@ -146,7 +146,7 @@ class Await extends Activity {
     }
   }
 
-  async processSuccess(adjacencyList: StreamData[]): Promise<MultiResponseFlags> {
+  async processSuccessResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags> {
     this.mapJobData();
     const multi = this.store.getMulti();
     await this.setState(multi);
@@ -156,7 +156,7 @@ class Await extends Activity {
     return await multi.exec() as MultiResponseFlags;
   }
 
-  async processError(adjacencyList: StreamData[]): Promise<MultiResponseFlags> {
+  async processErrorResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags> {
     //todo: if adjacencyList.length == 0, then map to the job output
     //      this method would be added to Base activity class 
     //this.mapJobData();

package/services/activities/cycle.ts

@@ -0,0 +1,96 @@
+import { GetStateError } from '../../modules/errors';
+import { CollatorService } from '../collator';
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import {
+  ActivityData,
+  ActivityMetadata,
+  CycleActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { MultiResponseFlags, RedisMulti } from '../../types/redis';
+import { StreamData } from '../../types/stream';
+import { TelemetryService } from '../telemetry';
+
+class Cycle extends Activity {
+  config: CycleActivity;
+
+  constructor(
+    config: ActivityType,
+    data: ActivityData,
+    metadata: ActivityMetadata,
+    hook: ActivityData | null,
+    engine: EngineService,
+    context?: JobState) {
+      super(config, data, metadata, hook, engine, context);
+  }
+
+
+  //********  LEG 1 ENTRY  ********//
+  async process(): Promise<string> {
+    this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    let telemetry: TelemetryService;
+    try {
+      //verify entry is allowed
+      this.setLeg(1);
+      await CollatorService.notarizeEntry(this);
+      await this.getState();
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      telemetry.startActivitySpan(this.leg);
+      this.mapInputData();
+
+      //set state/status
+      let multi = this.store.getMulti();
+      await this.setState(multi);
+      await this.setStatus(0, multi); //leg 1 never changes job status
+      const multiResponse = await multi.exec() as MultiResponseFlags;
+      telemetry.mapActivityAttributes();
+      const jobStatus = this.resolveStatus(multiResponse);
+
+      //cycle the target ancestor
+      multi = this.store.getMulti();
+      const messageId = await this.cycleAncestorActivity(multi);
+      telemetry.setActivityAttributes({
+        'app.activity.mid': messageId,
+        'app.job.jss': jobStatus
+      });
+
+      //exit early (`Cycle` activities only execute Leg 1)
+      await CollatorService.notarizeEarlyExit(this, multi);
+      await multi.exec() as MultiResponseFlags;
+
+      return this.context.metadata.aid;
+    } catch (error) {
+      if (error instanceof GetStateError) {
+        this.logger.error('cycle-get-state-error', error);
+      } else {
+        this.logger.error('cycle-process-error', error);
+      }
+      telemetry.setActivityError(error.message);
+      throw error;
+    } finally {
+      telemetry.endActivitySpan();
+      this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    }
+  }
+
+  /**
+   * Trigger the target ancestor to execute in a cycle,
+   * without violating the constraints of the DAG. Immutable
+   * `individual activity state` will execute in a new dimensional
+   * thread while `shared job state` can change. This
+   * pattern allows for retries without violating the DAG.
+   */
+  async cycleAncestorActivity(multi: RedisMulti): Promise<string> {
+    const streamData: StreamData = {
+      metadata: {
+        dad: CollatorService.resolveReentryDimension(this),
+        jid: this.context.metadata.jid,
+        aid: this.config.ancestor,
+      },
+      data: {} //todo: verify immutability, before enabling: `this.context.data`
+    };
+    return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi)) as string;
+  }
+}
+
+export { Cycle };

package/services/activities/index.ts

@@ -1,13 +1,15 @@
 import { Activity } from './activity';
 import { Await } from './await';
-import { Worker } from './worker';
-import { Iterate } from './iterate';
+import { Cycle } from './cycle';
 import { Emit } from './emit';
+import { Iterate } from './iterate';
 import { Trigger } from './trigger';
+import { Worker } from './worker';
 
 export default { 
   activity: Activity,
   await: Await,
+  cycle: Cycle,
   iterate: Iterate,
   emit: Emit,
   trigger: Trigger,