@hotmeshio/hotmesh 0.0.7 → 0.0.9

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,

package/services/activities/worker.ts

@@ -43,7 +43,7 @@ class Worker 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);
@@ -56,13 +56,12 @@ class Worker extends Activity {
         'app.activity.mid': messageId,
         'app.job.jss': jobStatus
       });
-      //TODO: UPDATE ACTIVITY STATE (LEG 1 EXIT)
+
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof GetStateError) {
         this.logger.error('worker-get-state-error', error);
       } else {
-        console.error(error);
         this.logger.error('worker-process-error', error);
       }
       telemetry.setActivityError(error.message);
@@ -92,96 +91,6 @@ class Worker extends Activity {
     }
     return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData)) as string;
   }
-
-
-  //********  SIGNAL RE-ENTRY POINT (DUPLEX LEG 2 of 2)  ********//
-  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('worker-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('worker-process-event-duplicate', { jid, aid });
-        this.logger.debug('worker-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
-        return;
-      }
-      telemetry.startActivitySpan(this.leg);
-      if (status === StreamStatus.PENDING) {
-        await this.processPending(telemetry);
-      } else if (status === StreamStatus.SUCCESS) {
-        await this.processSuccess(telemetry);
-      } else {
-        await this.processError(telemetry);
-      }
-    } catch (error) {
-      this.logger.error('worker-process-event-error', error);
-      telemetry.setActivityError(error.message);
-      throw error;
-    } finally {
-      telemetry.endActivitySpan();
-      this.logger.debug('worker-process-event-end', { jid, aid });
-    }
-  }
-
-  async processPending(telemetry: TelemetryService): Promise<void> {
-    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);
-    const multiResponse = await multi.exec() as MultiResponseFlags;
-    this.transitionAdjacent(multiResponse, telemetry);
-  }
-
-  async processSuccess(telemetry: TelemetryService): Promise<void> {
-    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);
-    const multiResponse = await multi.exec() as MultiResponseFlags;
-    this.transitionAdjacent(multiResponse, telemetry);
-  }
-
-  async processError(telemetry: TelemetryService): Promise<void> {
-    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);
-    const multiResponse = await multi.exec() as MultiResponseFlags;
-    this.transitionAdjacent(multiResponse, telemetry);
-  }
-
-  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);
-  }
 }
 
 export { Worker };

package/services/collator/index.ts

@@ -4,22 +4,45 @@ import { CollationFaultType, CollationStage } from '../../types/collator';
 import { ActivityDuplex } from '../../types/activity';
 import { HotMeshGraph } from '../../types/hotmesh';
 import { Activity } from '../activities/activity';
+import { Cycle } from '../activities/cycle';
 
 class CollatorService {
 
   //max int digit count that supports `hincrby`
   static targetLength = 15;
 
-  static getDimensionalAddress(activity: Activity): Record<string, string> {
+  /**
+   * 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: Activity, isEntry = false): Record<string, string> {
     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: Cycle) {
+    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: Activity, multi?: RedisMulti): Promise<number> {
     //decrement by -100_000_000_000_000
     const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100_000_000_000_000, this.getDimensionalAddress(activity), multi);
@@ -35,14 +58,21 @@ class CollatorService {
     return amount;
   }
 
+  static async notarizeEarlyExit(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //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, -11_000_000_000_000, this.getDimensionalAddress(activity), multi);
+  };
+
   static async notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
-    //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, 1_000_001 - 11_000_000_000_000, 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 ? 10_000_000_000_000 : 11_000_000_000_000;
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_001 - decrement, this.getDimensionalAddress(activity), multi);
   };
 
   static async notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number> {
     //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, 1_000_000, this.getDimensionalAddress(activity), multi);
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_000, this.getDimensionalAddress(activity, true), multi);
     this.verifyInteger(amount, 2, 'enter');
     return amount;
   };
@@ -53,8 +83,10 @@ class CollatorService {
   };
 
   static async notarizeCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
-    //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 - 1_000_000_000_000, 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 : -1_000_000_000_000;
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), multi);
   };
 
   static getDigitAtIndex(num: number, targetDigitIndex: number): number | null {

package/services/durable/factory.ts

@@ -26,7 +26,12 @@ const getWorkflowYAML = (topic: string, 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: string, 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: string, version = '1') => {

package/services/durable/native.ts

@@ -9,7 +9,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -23,7 +23,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/services/durable/worker.ts

@@ -13,7 +13,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -27,7 +27,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -44,6 +44,7 @@ export class WorkerService {
   static connection: Connection;
   static instances = new Map<string, HotMesh | Promise<HotMesh>>();
   workflowRunner: HotMesh;
+  activityRunner: HotMesh;
 
   static getHotMesh = async (worflowTopic: string) => {
     if (WorkerService.instances.has(worflowTopic)) {
@@ -85,18 +86,18 @@ export class WorkerService {
    * dynamically importing the user's workflow module. That file
    * contains a call, `proxyActivities`, which needs this info.
    * 
-   * NOTE: The `worker` and `client` both call `proxyActivities`,
-   * as a natural result of importing worflows.ts. However,
-   * because the worker imports the workflows dynamically AFTER
+   * NOTE: Because the worker imports the workflows dynamically AFTER
    * the activities are loaded, there will be items in the registry,
    * allowing proxyActivities to succeed.
    */
   static registerActivities<ACT>(activities: ACT): Registry  {
-    if (typeof activities === 'function') {
+    if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
       WorkerService.activityRegistry[activities.name] = activities as Function;
     } else {
       Object.keys(activities).forEach(key => {
-        WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+          WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        }
       });
     }
     return WorkerService.activityRegistry;
@@ -105,8 +106,8 @@ export class WorkerService {
   static async create(config: WorkerConfig) {
     //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
-    WorkerService.registerActivities<typeof config.activities>(config.activities);
-    const workflow = await import(config.workflowsPath);
+    //user can provide the workflow file directly
+    const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
     const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
     const activityTopic = `${baseTopic}-activity`;
@@ -114,8 +115,8 @@ export class WorkerService {
 
     //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;
@@ -134,11 +135,7 @@ export class WorkerService {
   }
 
   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: WorkerConfig, activityTopic: string): Promise<HotMesh> {
@@ -175,10 +172,11 @@ export class WorkerService {
           data: { response: pojoResponse }
         };
       } 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 }
         } as StreamDataResponse;
@@ -195,7 +193,7 @@ export class WorkerService {
         await hotMesh.deploy(getActivityYAML(activityTopic, version));
         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;
       }
     } else if(app && !app.active) {
@@ -260,10 +258,9 @@ export class WorkerService {
           data: { response: workflowResponse }
         };
       } catch (err) {
-        //todo: (retryable error types)
         return {
+          status: StreamStatus.ERROR,
           code: 500,
-          status: StreamStatus.PENDING,
           metadata: { ...data.metadata },
           data: { error: err }
         } as StreamDataResponse;

package/services/durable/workflow.ts

@@ -31,8 +31,10 @@ Here is an example of how the methods in this file are used:
 ./workflows.ts
 
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+import * as activities from './activities';
+
 const { greet } = Durable.workflow.proxyActivities<typeof activities>({
+  activities: activities,
   startToCloseTimeout: '1 minute',
   retryPolicy: {
     initialInterval: '5 seconds',  // Initial delay between retries
@@ -72,6 +74,10 @@ export class WorkflowService {
   }
 
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
+    if (options.activities) {
+      WorkerService.registerActivities(options.activities)
+    }
+
     const proxy: any = {};
     const keys = Object.keys(WorkerService.activityRegistry);
     if (keys.length) {
@@ -103,7 +109,10 @@ 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 as T;
         }

package/services/mapper/index.ts

@@ -60,6 +60,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/services/signaler/stream.ts

@@ -150,7 +150,6 @@ class StreamSignaler {
     try {
       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/types/activity.ts

@@ -1,7 +1,7 @@
 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[]>;
 
@@ -18,6 +18,7 @@ interface BaseActivity {
   sleep?: number;                      //@pipe /in seconds
   expire?: number;                     //-1 forever (15 seconds default); todo: make globally configurable
   retry?: StreamRetryPolicy
+  cycle?: boolean;                     //if true, the `notary` will leave leg 2 open, so it can be re/cycled
   collationInt?: number;               //compiler
   consumes?: Consumes;                 //compiler
   PRODUCES?: string[];                 //compiler
@@ -61,6 +62,11 @@ interface EmitActivity extends BaseActivity {
   type: 'emit';
 }
 
+interface CycleActivity extends BaseActivity {
+  type: 'cycle';
+  ancestor: string; //ancestor activity id
+}
+
 interface IterateActivity extends BaseActivity {
   type: 'iterate';
 }
@@ -108,6 +114,7 @@ export {
   Consumes,
   TriggerActivityStats,
   AwaitActivity,
+  CycleActivity,
   BaseActivity,
   EmitActivity,
   IterateActivity,

package/types/durable.ts

@@ -41,8 +41,7 @@ type WorkerConfig = {
   connection: Connection;
   namespace: string; //`appid` in the YAML (e.g, 'default')
   taskQueue: string; //`subscribes` in the YAML (e.g, 'hello-world')
-  workflowsPath: string; //resolved abs path to dyn import()
-  activities: { [key: string]: Function }; //vanilla activity exports
+  workflow: Function //target function to run
 }
 
 type ContextType = {
@@ -56,8 +55,9 @@ type ProxyType<ACT> = {
 };
 
 type ActivityConfig = {
-  startToCloseTimeout: string;
-  retryPolicy: {
+  startToCloseTimeout?: string;
+  activities?: any;
+  retryPolicy?: {
     initialInterval: string;
     maximumAttempts: number;
     backoffCoefficient: number;

package/types/index.ts

@@ -9,6 +9,7 @@ export {
   Consumes,
   AwaitActivity,
   BaseActivity,
+  CycleActivity,
   EmitActivity,
   WorkerActivity,
   IterateActivity,