@hotmeshio/hotmesh 0.0.57 → 0.0.59

package/build/services/durable/handle.d.ts

@@ -10,11 +10,47 @@ export declare class WorkflowHandleService {
     workflowId: string;
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
     export(options?: ExportOptions): Promise<DurableJobExport>;
+    /**
+     * Sends a signal to the workflow. This is a way to send
+     * a message to a workflow that is paused due to having
+     * executed `Durable.workflow.waitFor`. The workflow
+     * will awaken if no other signals are pending.
+     */
     signal(signalId: string, data: Record<any, any>): Promise<void>;
+    /**
+     * Returns the job state of the workflow. If the workflow has completed
+     * this is also the job output. If the workflow is still running, this
+     * is the current state of the job, but it may change depending upon
+     * the activities that remain.
+     */
     state(metadata?: boolean): Promise<Record<string, any>>;
+    /**
+     * Returns the current search state of the workflow. This is
+     * different than the job state or individual activity state.
+     * Search state represents name/value pairs that were added
+     * to the workflow. As the workflow is stored in a Redis hash,
+     * this is a way to store additional data that is indexed
+     * and searchable using the RediSearch module.
+     */
     queryState(fields: string[]): Promise<Record<string, any>>;
+    /**
+     * Returns the current status of the workflow. This is a semaphore
+     * value that represents the current state of the workflow, where
+     * 0 is complete and a negative value represents that the flow was
+     * interrupted.
+     */
     status(): Promise<number>;
+    /**
+     * Interrupts a running workflow. Standard Job Completion tasks will
+     * run. Subscribers will be notified and the job hash will be expired.
+     */
     interrupt(options?: JobInterruptOptions): Promise<string>;
+    /**
+     * Waits for the workflow to complete and returns the result. If
+     * the workflow response includes an error, this method will rethrow
+     * the error, including the stack trace if available.
+     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
+     */
     result<T>(config?: {
         state?: boolean;
         throwOnError?: boolean;

package/build/services/durable/handle.js

@@ -12,9 +12,21 @@ class WorkflowHandleService {
     async export(options) {
         return this.exporter.export(this.workflowId, options);
     }
+    /**
+     * Sends a signal to the workflow. This is a way to send
+     * a message to a workflow that is paused due to having
+     * executed `Durable.workflow.waitFor`. The workflow
+     * will awaken if no other signals are pending.
+     */
     async signal(signalId, data) {
         await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, { id: signalId, data });
     }
+    /**
+     * Returns the job state of the workflow. If the workflow has completed
+     * this is also the job output. If the workflow is still running, this
+     * is the current state of the job, but it may change depending upon
+     * the activities that remain.
+     */
     async state(metadata = false) {
         const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
         if (!state.data && state.metadata.err) {
@@ -22,25 +34,56 @@ class WorkflowHandleService {
         }
         return metadata ? state : state.data;
     }
+    /**
+     * Returns the current search state of the workflow. This is
+     * different than the job state or individual activity state.
+     * Search state represents name/value pairs that were added
+     * to the workflow. As the workflow is stored in a Redis hash,
+     * this is a way to store additional data that is indexed
+     * and searchable using the RediSearch module.
+     */
     async queryState(fields) {
         return await this.hotMesh.getQueryState(this.workflowId, fields);
     }
+    /**
+     * Returns the current status of the workflow. This is a semaphore
+     * value that represents the current state of the workflow, where
+     * 0 is complete and a negative value represents that the flow was
+     * interrupted.
+     */
     async status() {
         return await this.hotMesh.getStatus(this.workflowId);
     }
+    /**
+     * Interrupts a running workflow. Standard Job Completion tasks will
+     * run. Subscribers will be notified and the job hash will be expired.
+     */
     async interrupt(options) {
         return await this.hotMesh.interrupt(`${this.hotMesh.appId}.execute`, this.workflowId, options);
     }
+    /**
+     * Waits for the workflow to complete and returns the result. If
+     * the workflow response includes an error, this method will rethrow
+     * the error, including the stack trace if available.
+     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
+     */
     async result(config) {
         const topic = `${this.hotMesh.appId}.executed.${this.workflowId}`;
         let isResolved = false;
         return new Promise(async (resolve, reject) => {
+            /**
+             * rejects/resolves the promise based on the `throwOnError`
+             * default behavior is to throw if error
+             */
             const safeReject = (err) => {
                 if (config?.throwOnError === false) {
                     return resolve(err);
                 }
                 reject(err);
             };
+            /**
+             * Common completion function that unsubscribes from the topic/returns
+             */
             const complete = async (response, err) => {
                 if (isResolved)
                     return;
@@ -63,6 +106,7 @@ class WorkflowHandleService {
                 }
                 resolve(response);
             };
+            //more expensive; fetches the entire job, not just the `status`
             if (config?.state) {
                 const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
                 if (state?.data?.done && !state.data?.$error) {
@@ -75,6 +119,7 @@ class WorkflowHandleService {
                     return complete(null, JSON.parse(state.metadata.err));
                 }
             }
+            //subscribe to 'done' topic
             this.hotMesh.sub(topic, async (_topic, state) => {
                 this.hotMesh.unsub(topic);
                 if (state.data.done && !state.data?.$error) {
@@ -88,6 +133,7 @@ class WorkflowHandleService {
                     return await complete(null, error);
                 }
             });
+            //check state in case completed during wiring
             const status = await this.hotMesh.getStatus(this.workflowId);
             if (status <= 0) {
                 await complete();

package/build/services/durable/index.d.ts

@@ -10,6 +10,10 @@ export declare const Durable: {
     Search: typeof Search;
     Worker: typeof WorkerService;
     workflow: typeof WorkflowService;
+    /**
+     * Shutdown everything. All connections, workers, and clients will be closed.
+     * Include in your signal handlers to ensure a clean shutdown.
+     */
     shutdown(): Promise<void>;
 };
 export type { ContextType };

package/build/services/durable/index.js

@@ -13,6 +13,10 @@ exports.Durable = {
     Search: search_1.Search,
     Worker: worker_1.WorkerService,
     workflow: workflow_1.WorkflowService,
+    /**
+     * Shutdown everything. All connections, workers, and clients will be closed.
+     * Include in your signal handlers to ensure a clean shutdown.
+     */
     async shutdown() {
         await client_1.ClientService.shutdown();
         await worker_1.WorkerService.shutdown();

package/build/services/durable/schemas/factory.d.ts

@@ -1,4 +1,33 @@
+/**
+ *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
+ *
+ * This HotMesh application spec uses 50 activities and 25 transitions
+ * to model and emulate the Temporal Application & Query servers using
+ * Redis as the backend.
+ *
+ * It's particularly useful for organizations with high-speed, high-volume
+ * use cases as it uses in-memory Redis Streams for transactional,
+ * workflow processing, while adhering to Temporal's developer-friendly syntax.
+ *
+ * This YAML file can also serve as a useful starting point for building
+ * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
+ * for a physical application server.
+ *
+ * Possible use cases include:
+ * * Orchestration servers
+ * * Integration servers
+ * * BPMN engines
+ * * Reentrant process servers
+ * * Service Meshes
+ * * Master Data Management systems
+ */
 declare const APP_VERSION = "1";
 declare const APP_ID = "durable";
+/**
+ * returns a new durable workflow schema
+ * @param {string} app - app name (e.g., 'durable')
+ * @param {string} version - number as string (e.g., '1')
+ * @returns {string} HotMesh App YAML
+ */
 declare const getWorkflowYAML: (app: string, version: string) => string;
 export { getWorkflowYAML, APP_VERSION, APP_ID, };

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

@@ -1,10 +1,39 @@
 "use strict";
+/**
+ *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
+ *
+ * This HotMesh application spec uses 50 activities and 25 transitions
+ * to model and emulate the Temporal Application & Query servers using
+ * Redis as the backend.
+ *
+ * It's particularly useful for organizations with high-speed, high-volume
+ * use cases as it uses in-memory Redis Streams for transactional,
+ * workflow processing, while adhering to Temporal's developer-friendly syntax.
+ *
+ * This YAML file can also serve as a useful starting point for building
+ * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
+ * for a physical application server.
+ *
+ * Possible use cases include:
+ * * Orchestration servers
+ * * Integration servers
+ * * BPMN engines
+ * * Reentrant process servers
+ * * Service Meshes
+ * * Master Data Management systems
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
 const APP_VERSION = '1';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
+/**
+ * returns a new durable workflow schema
+ * @param {string} app - app name (e.g., 'durable')
+ * @param {string} version - number as string (e.g., '1')
+ * @returns {string} HotMesh App YAML
+ */
 const getWorkflowYAML = (app, version) => {
     return `app:
   id: ${app}

package/build/services/durable/search.d.ts

@@ -10,14 +10,111 @@ export declare class Search {
     store: StoreService<RedisClient, RedisMulti> | null;
     cachedFields: Record<string, string>;
     constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string);
+    /**
+     * Prefixes the key with an underscore to keep separate from the
+     * activity and job history (and searchable via HKEYS)
+     * @param {string} key - the key to be sanitized. Wrap in quotes to avoid sanitization.
+     * @returns {string} - the sanitized key
+     * @private
+     */
     safeKey(key: string): string;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. All values are searchable via HKEYS/HSC/HGET
+     * @param {HotMesh} hotMeshClient - the hotmesh client
+     * @param {WorkflowSearchOptions} search - the search options
+     * @returns {Promise<void>}
+     * @example
+     * const search = {
+     *  index: 'my_search_index',
+     *  prefix: ['my_workflow_prefix'],
+     *  schema: {
+     *   field1: { type: 'TEXT', sortable: true },
+     *   field2: { type: 'NUMERIC', sortable: true }
+     *  }
+     * }
+     * await Search.configureSearchIndex(hotMeshClient, search);
+     */
     static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will list all search indexes.
+     *
+     * @param {HotMesh} hotMeshClient - the hotmesh client
+     * @returns {Promise<string[]>} - the list of search indexes
+     * @example
+     * const searchIndexes = await Search.listSearchIndexes(hotMeshClient);
+     */
     static listSearchIndexes(hotMeshClient: HotMesh): Promise<string[]>;
+    /**
+     * increments the index to return a unique search session guid when
+     * calling any method that produces side effects (changes the value)
+     * @private
+     */
     getSearchSessionGuid(): string;
+    /**
+     * Sets the fields listed in args. Returns the
+     * count of new fields that were set (does not
+     * count fields that were updated)
+     * @param args
+     * @returns {number}
+     * @example
+     * const search = new Search();
+     * const count = await search.set('field1', 'value1', 'field2', 'value2');
+     */
     set(...args: string[]): Promise<number>;
+    /**
+     * Returns the value of the field in the HASH stored at key.
+     * @param key
+     * @returns {string}
+     * @example
+     * const search = new Search();
+     * const value = await search.get('field1');
+     */
     get(key: string): Promise<string>;
+    /**
+     * Returns the values of all specified fields in the HASH stored at key.
+     * @param args
+     * @returns
+     */
     mget(...args: string[]): Promise<string[]>;
+    /**
+     * Deletes the fields provided as args. Returns the
+     * count of fields that were deleted.
+     *
+     * @param args
+     * @returns {number}
+     * @example
+     * sont search = new Search();
+     * const count = await search.del('field1', 'field2', 'field3');
+     */
     del(...args: string[]): Promise<number | void>;
+    /**
+     * Increments the value of a float field by the given amount. Returns the
+     * new value of the field after the increment. Pass a negative
+     * number to decrement the value.
+     *
+     * @param key - the key to increment
+     * @param val - the value to increment by
+     * @returns {number} - the new value
+     * @example
+     * const search = new Search();
+     * const count = await search.incr('field1', 1.5);
+     */
     incr(key: string, val: number): Promise<number>;
+    /**
+     * Multiplies the value of a field by the given amount. Returns the
+     * new value of the field after the multiplication. NOTE:
+     * this is exponential multiplication.
+     *
+     * @param key - the key to multiply
+     * @param val - the value to multiply by
+     * @returns {number} - the new product of the multiplication
+     * @example
+     * const search = new Search();
+     * const product = await search.mult('field1', 1.5);
+     */
     mult(key: string, val: number): Promise<number>;
 }

package/build/services/durable/search.js

@@ -16,12 +16,38 @@ class Search {
         this.hotMeshClient = hotMeshClient;
         this.store = hotMeshClient.engine.store;
     }
+    /**
+     * Prefixes the key with an underscore to keep separate from the
+     * activity and job history (and searchable via HKEYS)
+     * @param {string} key - the key to be sanitized. Wrap in quotes to avoid sanitization.
+     * @returns {string} - the sanitized key
+     * @private
+     */
     safeKey(key) {
         if (key.startsWith('"')) {
             return key.slice(1, -1);
         }
         return `_${key}`;
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. All values are searchable via HKEYS/HSC/HGET
+     * @param {HotMesh} hotMeshClient - the hotmesh client
+     * @param {WorkflowSearchOptions} search - the search options
+     * @returns {Promise<void>}
+     * @example
+     * const search = {
+     *  index: 'my_search_index',
+     *  prefix: ['my_workflow_prefix'],
+     *  schema: {
+     *   field1: { type: 'TEXT', sortable: true },
+     *   field2: { type: 'NUMERIC', sortable: true }
+     *  }
+     * }
+     * await Search.configureSearchIndex(hotMeshClient, search);
+     */
     static async configureSearchIndex(hotMeshClient, search) {
         if (search?.schema) {
             const store = hotMeshClient.engine.store;
@@ -57,6 +83,15 @@ class Search {
             }
         }
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will list all search indexes.
+     *
+     * @param {HotMesh} hotMeshClient - the hotmesh client
+     * @returns {Promise<string[]>} - the list of search indexes
+     * @example
+     * const searchIndexes = await Search.listSearchIndexes(hotMeshClient);
+     */
     static async listSearchIndexes(hotMeshClient) {
         try {
             const store = hotMeshClient.engine.store;
@@ -68,9 +103,25 @@ class Search {
             return [];
         }
     }
+    /**
+     * increments the index to return a unique search session guid when
+     * calling any method that produces side effects (changes the value)
+     * @private
+     */
     getSearchSessionGuid() {
+        //return the search session as it would exist in the search session index
         return `${this.searchSessionId}-${this.searchSessionIndex++}-`;
     }
+    /**
+     * Sets the fields listed in args. Returns the
+     * count of new fields that were set (does not
+     * count fields that were updated)
+     * @param args
+     * @returns {number}
+     * @example
+     * const search = new Search();
+     * const count = await search.set('field1', 'value1', 'field2', 'value2');
+     */
     async set(...args) {
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
@@ -87,9 +138,18 @@ class Search {
             return Number(replay[ssGuid]);
         }
         const fieldCount = await this.store.exec('HSET', this.jobId, ...safeArgs);
+        //no need to wait; set this interim value in the replay
         this.store.exec('HSET', this.jobId, ssGuid, fieldCount.toString());
         return Number(fieldCount);
     }
+    /**
+     * Returns the value of the field in the HASH stored at key.
+     * @param key
+     * @returns {string}
+     * @example
+     * const search = new Search();
+     * const value = await search.get('field1');
+     */
     async get(key) {
         try {
             if (key in this.cachedFields) {
@@ -104,6 +164,11 @@ class Search {
             return '';
         }
     }
+    /**
+     * Returns the values of all specified fields in the HASH stored at key.
+     * @param args
+     * @returns
+     */
     async mget(...args) {
         let isCached = true;
         const values = [];
@@ -134,6 +199,16 @@ class Search {
             return [];
         }
     }
+    /**
+     * Deletes the fields provided as args. Returns the
+     * count of fields that were deleted.
+     *
+     * @param args
+     * @returns {number}
+     * @example
+     * sont search = new Search();
+     * const count = await search.del('field1', 'field2', 'field3');
+     */
     async del(...args) {
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
@@ -152,6 +227,18 @@ class Search {
         this.store.exec('HSET', this.jobId, ssGuid, formattedResponse.toString());
         return formattedResponse;
     }
+    /**
+     * Increments the value of a float field by the given amount. Returns the
+     * new value of the field after the increment. Pass a negative
+     * number to decrement the value.
+     *
+     * @param key - the key to increment
+     * @param val - the value to increment by
+     * @returns {number} - the new value
+     * @example
+     * const search = new Search();
+     * const count = await search.incr('field1', 1.5);
+     */
     async incr(key, val) {
         delete this.cachedFields[key];
         const ssGuid = this.getSearchSessionGuid();
@@ -164,6 +251,18 @@ class Search {
         this.store.exec('HSET', this.jobId, ssGuid, num.toString());
         return Number(num);
     }
+    /**
+     * Multiplies the value of a field by the given amount. Returns the
+     * new value of the field after the multiplication. NOTE:
+     * this is exponential multiplication.
+     *
+     * @param key - the key to multiply
+     * @param val - the value to multiply by
+     * @returns {number} - the new product of the multiplication
+     * @example
+     * const search = new Search();
+     * const product = await search.mult('field1', 1.5);
+     */
     async mult(key, val) {
         delete this.cachedFields[key];
         const ssGuid = this.getSearchSessionGuid();

package/build/services/durable/worker.js

@@ -9,11 +9,11 @@ const ms_1 = __importDefault(require("ms"));
 const enums_1 = require("../../modules/enums");
 const errors_1 = require("../../modules/errors");
 const storage_1 = require("../../modules/storage");
+const utils_1 = require("../../modules/utils");
 const factory_1 = require("./schemas/factory");
 const hotmesh_1 = require("../hotmesh");
 const search_1 = require("./search");
 const stream_1 = require("../../types/stream");
-const utils_1 = require("../../modules/utils");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
         const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
@@ -61,6 +61,7 @@ class WorkerService {
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
         const activityTopic = `${baseTopic}-activity`;
         const workflowTopic = `${baseTopic}`;
+        //initialize supporting workflows
         const worker = new WorkerService();
         worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
         worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
@@ -103,9 +104,11 @@ class WorkerService {
         WorkerService.instances.set(activityTopic, hotMeshWorker);
         return hotMeshWorker;
     }
+    //this is the linked worker function in the reentrant workflow test
     wrapActivityFunctions() {
         return async (data) => {
             try {
+                //always run the activity function when instructed; return the response
                 const activityInput = data.data;
                 const activityName = activityInput.activityName;
                 const activityFunction = WorkerService.activityRegistry[activityName];
@@ -121,6 +124,8 @@ class WorkerService {
                 if (!(err instanceof errors_1.DurableTimeoutError) &&
                     !(err instanceof errors_1.DurableMaxedError) &&
                     !(err instanceof errors_1.DurableFatalError)) {
+                    //use code 599 as a proxy for all retryable errors
+                    // (basically anything not 596, 597, 598)
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
@@ -135,6 +140,8 @@ class WorkerService {
                     };
                 }
                 return {
+                    //always returrn success (the Durable module is just fine);
+                    //  it's the user's function that has failed
                     status: stream_1.StreamStatus.SUCCESS,
                     code: err.code,
                     stack: err.stack,
@@ -172,8 +179,10 @@ class WorkerService {
     wrapWorkflowFunction(workflowFunction, workflowTopic, config) {
         return async (data) => {
             const counter = { counter: 0 };
-            const interruptionRegistry = [];
+            const interruptionRegistry = new Array();
+            let isProcessing = false;
             try {
+                //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
                 context.set('canRetry', workflowInput.canRetry);
@@ -183,14 +192,20 @@ class WorkerService {
                 context.set('raw', data);
                 context.set('workflowId', workflowInput.workflowId);
                 if (workflowInput.originJobId) {
+                    //if present there is an origin job to which this job is subordinated; 
+                    // garbage collect (expire) this job when originJobId is expired
                     context.set('originJobId', workflowInput.originJobId);
                 }
                 let replayQuery = '';
                 if (workflowInput.workflowDimension) {
+                    //every hook function runs in an isolated dimension controlled
+                    //by the index assigned when the signal was received; even if the
+                    //hook function re-runs, its scope will always remain constant
                     context.set('workflowDimension', workflowInput.workflowDimension);
                     replayQuery = `-*${workflowInput.workflowDimension}-*`;
                 }
                 else {
+                    //last letter of words like 'hook', 'sleep', 'wait', 'signal', 'search', 'start', 'proxy', 'child', 'collator'
                     replayQuery = '-*[ehklptydr]-*';
                 }
                 context.set('workflowTopic', workflowTopic);
@@ -200,7 +215,7 @@ class WorkerService {
                 const store = this.workflowRunner.engine.store;
                 const [cursor, replay] = await store.findJobFields(workflowInput.workflowId, replayQuery, 50000, 5000);
                 context.set('replay', replay);
-                context.set('cursor', cursor);
+                context.set('cursor', cursor); // if != 0, more remain
                 const workflowResponse = await storage_1.asyncLocalStorage.run(context, async () => {
                     return await workflowFunction.apply(this, workflowInput.arguments);
                 });
@@ -212,11 +227,16 @@ class WorkerService {
                 };
             }
             catch (err) {
+                if (isProcessing) {
+                    return;
+                }
                 if (err instanceof errors_1.DurableWaitForError || interruptionRegistry.length > 1) {
+                    isProcessing = true;
+                    //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
                     const workflowInput = data.data;
                     const execIndex = counter.counter - interruptionRegistry.length + 1;
                     const { workflowId, workflowTopic, workflowDimension, originJobId } = workflowInput;
-                    const collatorFlowId = `-${workflowId}-$${workflowDimension || ''}-$${execIndex}`;
+                    const collatorFlowId = `${(0, utils_1.guid)()}$C`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: enums_1.HMSH_CODE_DURABLE_ALL,
@@ -235,6 +255,8 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableSleepError) {
+                    //return the sleep interruption
+                    isProcessing = true;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: err.code,
@@ -249,6 +271,8 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableProxyError) {
+                    //return the proxyActivity interruption
+                    isProcessing = true;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: err.code,
@@ -271,10 +295,12 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableChildError) {
+                    //return the child interruption
+                    isProcessing = true;
                     const msg = {
                         message: err.message,
                         workflowId: err.workflowId,
-                        dimension: err.workflowDimension
+                        dimension: err.workflowDimension,
                     };
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
@@ -297,6 +323,9 @@ class WorkerService {
                         }
                     };
                 }
+                // ALL other errors are actual fatal errors (598, 597, 596)
+                //  OR will be retried (599)
+                isProcessing = true;
                 return {
                     status: stream_1.StreamStatus.SUCCESS,
                     code: err.code || new errors_1.DurableRetryError(err.message).code,
@@ -321,7 +350,7 @@ class WorkerService {
     }
 }
 _a = WorkerService;
-WorkerService.activityRegistry = {};
+WorkerService.activityRegistry = {}; //user's activities
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     if (WorkerService.instances.has(workflowTopic)) {