@hotmeshio/hotmesh 0.0.7 → 0.0.9

package/build/{cjs/services → services}/collator/index.js

@@ -4,15 +4,36 @@ exports.CollatorService = void 0;
 const errors_1 = require("../../modules/errors");
 const collator_1 = require("../../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);
@@ -27,14 +48,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;
     }
@@ -45,8 +73,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/{cjs/services → services}/durable/factory.js

@@ -29,7 +29,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:
@@ -52,9 +57,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
+`;
 };
 exports.getWorkflowYAML = getWorkflowYAML;
 const getActivityYAML = (topic, version = '1') => {

package/build/{cjs/services → services}/durable/native.js

@@ -10,7 +10,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({
@@ -24,7 +24,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/build/{cjs/services → 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>;
     /**
@@ -12,9 +13,7 @@ export declare 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.
      */

package/build/{esm/services → services}/durable/worker.js

@@ -1,8 +1,11 @@
+"use strict";
 var _a;
-import { asyncLocalStorage } from './asyncLocalStorage';
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { StreamStatus } from '../../types/stream';
-import { getWorkflowYAML, getActivityYAML } from './factory';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerService = void 0;
+const asyncLocalStorage_1 = require("./asyncLocalStorage");
+const hotmesh_1 = require("../hotmesh");
+const stream_1 = require("../../types/stream");
+const factory_1 = require("./factory");
 /*
 Here is an example of how the methods in this file are used:
 
@@ -11,7 +14,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({
@@ -25,7 +28,7 @@ async function run() {
     connection,
     namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -66,19 +69,19 @@ 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(activities) {
-        if (typeof activities === 'function') {
+        if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
             WorkerService.activityRegistry[activities.name] = activities;
         }
         else {
             Object.keys(activities).forEach(key => {
-                WorkerService.activityRegistry[activities[key].name] = activities[key];
+                if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+                    WorkerService.activityRegistry[activities[key].name] = activities[key];
+                }
             });
         }
         return WorkerService.activityRegistry;
@@ -86,18 +89,18 @@ class WorkerService {
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
-        WorkerService.registerActivities(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`;
         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, factory_1.getActivityYAML);
         worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
-        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, getWorkflowYAML);
+        await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, factory_1.getWorkflowYAML);
         return worker;
     }
     static resolveWorkflowTarget(workflow) {
@@ -113,19 +116,14 @@ 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 = {
             class: config.connection.class,
             options: config.connection.options
         };
-        const hmshInstance = await HotMesh.init({
+        const hmshInstance = await hotmesh_1.HotMeshService.init({
             appId: activityTopic,
             engine: { redis: redisConfig },
             workers: [
@@ -147,16 +145,17 @@ class WorkerService {
                 const activityFunction = WorkerService.activityRegistry[activityName];
                 const pojoResponse = await activityFunction.apply(this, activityInput.arguments);
                 return {
-                    status: StreamStatus.SUCCESS,
+                    status: stream_1.StreamStatus.SUCCESS,
                     metadata: { ...data.metadata },
                     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: stream_1.StreamStatus.ERROR,
+                    code: 500,
+                    message: err.message,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };
@@ -169,11 +168,11 @@ class WorkerService {
         const appVersion = app?.version;
         if (isNaN(appVersion)) {
             try {
-                await hotMesh.deploy(getActivityYAML(activityTopic, version));
+                await hotMesh.deploy((0, factory_1.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;
             }
         }
@@ -192,7 +191,7 @@ class WorkerService {
             class: config.connection.class,
             options: config.connection.options
         };
-        const hmshInstance = await HotMesh.init({
+        const hmshInstance = await hotmesh_1.HotMeshService.init({
             appId: workflowTopic,
             engine: { redis: redisConfig },
             workers: [
@@ -218,21 +217,20 @@ class WorkerService {
                 context.set('workflowName', workflowTopic.split('-').pop());
                 context.set('workflowTrace', data.metadata.trc);
                 context.set('workflowSpan', data.metadata.spn);
-                const workflowResponse = await asyncLocalStorage.run(context, async () => {
+                const workflowResponse = await asyncLocalStorage_1.asyncLocalStorage.run(context, async () => {
                     return await workflowFunction.apply(this, workflowInput.arguments);
                 });
                 return {
                     code: 200,
-                    status: StreamStatus.SUCCESS,
+                    status: stream_1.StreamStatus.SUCCESS,
                     metadata: { ...data.metadata },
                     data: { response: workflowResponse }
                 };
             }
             catch (err) {
-                //todo: (retryable error types)
                 return {
+                    status: stream_1.StreamStatus.ERROR,
                     code: 500,
-                    status: StreamStatus.PENDING,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };
@@ -253,12 +251,12 @@ WorkerService.getHotMesh = async (worflowTopic) => {
     if (WorkerService.instances.has(worflowTopic)) {
         return await WorkerService.instances.get(worflowTopic);
     }
-    const hotMesh = HotMesh.init({
+    const hotMesh = hotmesh_1.HotMeshService.init({
         appId: worflowTopic,
         engine: { redis: { ...WorkerService.connection } }
     });
     WorkerService.instances.set(worflowTopic, hotMesh);
-    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, getWorkflowYAML);
+    await WorkerService.activateWorkflow(await hotMesh, worflowTopic, factory_1.getWorkflowYAML);
     return hotMesh;
 };
 WorkerService.Context = {
@@ -269,4 +267,4 @@ WorkerService.Context = {
         };
     },
 };
-export { WorkerService };
+exports.WorkerService = WorkerService;

package/build/{cjs/services → services}/durable/workflow.js

@@ -33,8 +33,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
@@ -71,6 +73,9 @@ class WorkflowService {
         return result;
     }
     static proxyActivities(options) {
+        if (options.activities) {
+            worker_1.WorkerService.registerActivities(options.activities);
+        }
         const proxy = {};
         const keys = Object.keys(worker_1.WorkerService.activityRegistry);
         if (keys.length) {
@@ -100,7 +105,11 @@ class WorkflowService {
             try {
                 const hmshInstance = await worker_1.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/{cjs/services → services}/mapper/index.js

@@ -50,6 +50,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/{cjs/services → services}/signaler/stream.js

@@ -121,7 +121,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 → 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/{cjs/types → types}/durable.d.ts

@@ -34,10 +34,7 @@ type WorkerConfig = {
     connection: Connection;
     namespace: string;
     taskQueue: string;
-    workflowsPath: string;
-    activities: {
-        [key: string]: Function;
-    };
+    workflow: Function;
 };
 type ContextType = {
     workflowId: string;
@@ -48,8 +45,9 @@ type ProxyType<ACT> = {
     [K in keyof ACT]: FunctionSignature<ACT[K]>;
 };
 type ActivityConfig = {
-    startToCloseTimeout: string;
-    retryPolicy: {
+    startToCloseTimeout?: string;
+    activities?: any;
+    retryPolicy?: {
         initialInterval: string;
         maximumAttempts: number;
         backoffCoefficient: number;

package/build/{cjs/types → 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,14 +1,9 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Durable Workflows",
-  "main": "build/cjs/index.js",
-  "module": "build/esm/index.js",
-  "types": "build/cjs/index.d.ts",
-  "exports": {
-    "import": "./build/esm/index.js",
-    "require": "./build/cjs/index.js"
-  },
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
   },
   "scripts": {
     "clean": "rimraf ./build",
-    "build:cjs": "tsc --build tsconfig.cjs.json",
-    "build:esm": "tsc --build tsconfig.esm.json",
-    "build": "npm run build:cjs && npm run build:esm",
+    "build": "tsc --build tsconfig.json",
     "clean-build": "npm run clean && npm run build",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --fix --ext .ts",
@@ -29,6 +22,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 +42,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)) {