@hotmeshio/hotmesh 0.0.7 → 0.0.8

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

@@ -120,8 +120,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, factory_1.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, factory_1.getWorkflowYAML);
         return worker;
@@ -139,12 +139,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 = {
@@ -179,10 +174,11 @@ class WorkerService {
                 };
             }
             catch (err) {
-                console.error(err);
-                //todo (make retry configurable)
+                this.activityRunner.engine.logger.error('durable-worker-activity-err', err);
                 return {
-                    status: stream_1.StreamStatus.PENDING,
+                    status: stream_1.StreamStatus.ERROR,
+                    code: 500,
+                    message: err.message,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };
@@ -199,7 +195,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;
             }
         }
@@ -255,10 +251,9 @@ class WorkerService {
                 };
             }
             catch (err) {
-                //todo: (retryable error types)
                 return {
+                    status: stream_1.StreamStatus.ERROR,
                     code: 500,
-                    status: stream_1.StreamStatus.PENDING,
                     metadata: { ...data.metadata },
                     data: { error: err }
                 };

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

@@ -100,7 +100,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/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/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/cjs/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/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/build/esm/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/build/esm/services/activities/activity.d.ts

@@ -1,6 +1,7 @@
 import { EngineService } from '../engine';
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
+import { TelemetryService } from '../telemetry';
 import { ActivityData, ActivityLeg, ActivityMetadata, ActivityType } from '../../types/activity';
 import { JobState, JobStatus } from '../../types/job';
 import { MultiResponseFlags, RedisClient, RedisMulti } from '../../types/redis';
@@ -31,6 +32,11 @@ declare class Activity {
     processWebHookEvent(): Promise<JobStatus | void>;
     processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
     processHookEvent(jobId: string): Promise<JobStatus | void>;
+    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
+    processPending(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    processSuccess(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    processError(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;
     mapInputData(): void;

package/build/esm/services/activities/activity.js

@@ -84,7 +84,7 @@ class Activity {
     setLeg(leg) {
         this.leg = leg;
     }
-    //********  SIGNALER RE-ENTRY POINT (B)  ********//
+    //********  SIGNAL RE-ENTRY POINT  ********//
     doesHook() {
         return !!(this.config.hook?.topic || this.config.sleep);
     }
@@ -122,11 +122,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) {
         this.logger.debug('activity-process-hook-event', { jobId });
         let telemetry;
@@ -156,7 +151,6 @@ class Activity {
             return jobStatus;
         }
         catch (error) {
-            console.error('this error?', error);
             this.logger.error('engine-process-hook-event-error', error);
             telemetry.setActivityError(error.message);
             throw error;
@@ -165,6 +159,88 @@ class Activity {
             telemetry.endActivitySpan();
         }
     }
+    //********  DUPLEX RE-ENTRY POINT  ********//
+    async processEvent(status = StreamStatus.SUCCESS, code = 200) {
+        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;
+        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;
+            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) {
+        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();
+    }
+    async processSuccess(telemetry) {
+        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();
+    }
+    async processError(telemetry) {
+        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();
+    }
+    async transitionAdjacent(multiResponse, telemetry) {
+        telemetry.mapActivityAttributes();
+        const jobStatus = this.resolveStatus(multiResponse);
+        const attrs = { '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) {
         const activityStatus = multiResponse[multiResponse.length - 1];
         if (Array.isArray(activityStatus)) {

package/build/esm/services/activities/await.d.ts

@@ -10,7 +10,7 @@ declare class Await extends Activity {
     process(): Promise<string>;
     execActivity(): Promise<string>;
     processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processSuccess(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
-    processError(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    processSuccessResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    processErrorResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
 }
 export { Await };

package/build/esm/services/activities/await.js

@@ -19,7 +19,7 @@ class Await extends Activity {
             telemetry.startActivitySpan(this.leg);
             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);
@@ -92,12 +92,12 @@ 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();
             const jobStatus = this.resolveStatus(multiResponse);
@@ -118,7 +118,7 @@ class Await extends Activity {
             this.logger.debug('await-resolve-await-end', { jid, aid, status, code });
         }
     }
-    async processSuccess(adjacencyList) {
+    async processSuccessResponse(adjacencyList) {
         this.mapJobData();
         const multi = this.store.getMulti();
         await this.setState(multi);
@@ -126,7 +126,7 @@ class Await extends Activity {
         await this.setStatus(adjacencyList.length - 1, multi);
         return await multi.exec();
     }
-    async processError(adjacencyList) {
+    async processErrorResponse(adjacencyList) {
         //todo: if adjacencyList.length == 0, then map to the job output
         //      this method would be added to Base activity class 
         //this.mapJobData();

package/build/esm/services/activities/cycle.d.ts

@@ -0,0 +1,19 @@
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import { ActivityData, ActivityMetadata, CycleActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
+declare class Cycle extends Activity {
+    config: CycleActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    /**
+     * 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.
+     */
+    cycleAncestorActivity(multi: RedisMulti): Promise<string>;
+}
+export { Cycle };

package/build/esm/services/activities/cycle.js

@@ -0,0 +1,74 @@
+import { GetStateError } from '../../modules/errors';
+import { CollatorService } from '../collator';
+import { Activity } from './activity';
+import { TelemetryService } from '../telemetry';
+class Cycle extends Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  LEG 1 ENTRY  ********//
+    async process() {
+        this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        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();
+            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();
+            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) {
+        const 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));
+    }
+}
+export { Cycle };

package/build/esm/services/activities/index.d.ts

@@ -1,12 +1,14 @@
 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';
 declare const _default: {
     activity: typeof Activity;
     await: typeof Await;
+    cycle: typeof Cycle;
     iterate: typeof Iterate;
     emit: typeof Emit;
     trigger: typeof Trigger;

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

@@ -1,12 +1,14 @@
 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/build/esm/services/activities/worker.d.ts

@@ -2,18 +2,10 @@ import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, ActivityType, WorkerActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
-import { MultiResponseFlags } from '../../types/redis';
-import { StreamCode, StreamStatus } from '../../types/stream';
-import { TelemetryService } from '../telemetry';
 declare class Worker extends Activity {
     config: WorkerActivity;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
     execActivity(): Promise<string>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processPending(telemetry: TelemetryService): Promise<void>;
-    processSuccess(telemetry: TelemetryService): Promise<void>;
-    processError(telemetry: TelemetryService): Promise<void>;
-    transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
 }
 export { Worker };

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

@@ -1,7 +1,6 @@
 import { GetStateError } from '../../modules/errors';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
-import { StreamStatus } from '../../types/stream';
 import { TelemetryService } from '../telemetry';
 class Worker extends Activity {
     constructor(config, data, metadata, hook, engine, context) {
@@ -19,7 +18,7 @@ class Worker extends Activity {
             telemetry.startActivitySpan(this.leg);
             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);
@@ -31,7 +30,6 @@ 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) {
@@ -39,7 +37,6 @@ class Worker extends Activity {
                 this.logger.error('worker-get-state-error', error);
             }
             else {
-                console.error(error);
                 this.logger.error('worker-process-error', error);
             }
             telemetry.setActivityError(error.message);
@@ -69,88 +66,5 @@ class Worker extends Activity {
         }
         return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData));
     }
-    //********  SIGNAL RE-ENTRY POINT (DUPLEX LEG 2 of 2)  ********//
-    async processEvent(status = StreamStatus.SUCCESS, code = 200) {
-        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;
-        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) {
-        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();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async processSuccess(telemetry) {
-        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();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async processError(telemetry) {
-        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();
-        this.transitionAdjacent(multiResponse, telemetry);
-    }
-    async transitionAdjacent(multiResponse, telemetry) {
-        telemetry.mapActivityAttributes();
-        const jobStatus = this.resolveStatus(multiResponse);
-        const attrs = { '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/build/esm/services/collator/index.d.ts

@@ -3,11 +3,28 @@ import { CollationStage } from '../../types/collator';
 import { ActivityDuplex } from '../../types/activity';
 import { HotMeshGraph } from '../../types/hotmesh';
 import { Activity } from '../activities/activity';
+import { Cycle } from '../activities/cycle';
 declare class CollatorService {
     static targetLength: number;
-    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?: boolean): Record<string, string>;
+    /**
+     * 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): string;
     static notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number>;
     static authorizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
+    static notarizeEarlyExit(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
     static notarizeContinuation(activity: Activity, multi?: RedisMulti): Promise<number>;