@hotmeshio/hotmesh 0.1.8 → 0.1.10

package/build/modules/utils.d.ts

@@ -5,6 +5,7 @@ import { RedisClient, RedisMulti } from '../types/redis';
 import { StringAnyType } from '../types/serializer';
 import { StreamCode, StreamStatus } from '../types/stream';
 import { SystemHealth } from '../types/quorum';
+export declare const hashOptions: (options: any) => string;
 export declare function getSystemHealth(): Promise<SystemHealth>;
 export declare function sleepFor(ms: number): Promise<unknown>;
 export declare function sleepImmediate(): Promise<void>;

package/build/modules/utils.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.guid = exports.deepCopy = exports.sleepImmediate = exports.sleepFor = exports.getSystemHealth = void 0;
+exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.deterministicRandom = exports.guid = exports.deepCopy = exports.sleepImmediate = exports.sleepFor = exports.getSystemHealth = exports.hashOptions = void 0;
 const os_1 = __importDefault(require("os"));
+const crypto_1 = require("crypto");
 const nanoid_1 = require("nanoid");
 const enums_1 = require("./enums");
 async function safeExecute(operation, defaultValue) {
@@ -16,10 +17,17 @@ async function safeExecute(operation, defaultValue) {
         return defaultValue;
     }
 }
+const hashOptions = (options) => {
+    const str = JSON.stringify(options);
+    return (0, crypto_1.createHash)('sha256').update(str).digest('hex');
+};
+exports.hashOptions = hashOptions;
 async function getSystemHealth() {
     const totalMemory = os_1.default.totalmem();
     const freeMemory = os_1.default.freemem();
     const usedMemory = totalMemory - freeMemory;
+    //NOTE: enable the following if desired; for now, only
+    //      `memory` is emitted when system health is requested
     //const cpus = os.cpus();
     // CPU load calculation remains unchanged
     // const cpuLoad = cpus.map((cpu, i) => {
@@ -28,9 +36,8 @@ async function getSystemHealth() {
     //   const usage = ((total - idle) / total) * 100;
     //   return { [`CPU ${i} Usage`]: `${usage.toFixed(2)}%` };
     // });
-    // Wrap each systeminformation call with safeExecute
+    // Wrap each systeminformation call with safeExecute (systeminformation npm package)
     //const networkStats = await safeExecute(si.networkStats(), []);
-    // Construct the system health object with error handling in mind
     const systemHealth = {
         TotalMemoryGB: `${(totalMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
         FreeMemoryGB: `${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.1.8",
+    "version": "0.1.10",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -84,7 +84,6 @@
         "js-yaml": "^4.1.0",
         "ms": "^2.1.3",
         "nanoid": "^3.3.6",
-        "systeminformation": "^5.22.2",
         "winston": "^3.8.2"
     },
     "devDependencies": {

package/build/services/activities/activity.d.ts

@@ -27,19 +27,23 @@ declare class Activity {
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     setLeg(leg: ActivityLeg): void;
     /**
-     * Upon entering leg 1 of a duplexed activty, verify
-     * all aspects of the entry including job and activty state
+     * A job is assumed to be complete when its status (a semaphore)
+     * reaches `0`. A different threshold can be set in the
+     * activity YAML, in support of Dynamic Activation Control.
+     */
+    mapStatusThreshold(): number;
+    /**
+     * Upon entering leg 1 of a duplexed activity
      */
     verifyEntry(): Promise<void>;
     /**
-     * Upon entering leg 2 of a duplexed activty, verify
-     * all aspects of the re-entry including job and activty state
+     * Upon entering leg 2 of a duplexed activity
      */
     verifyReentry(): Promise<number>;
     processEvent(status?: StreamStatus, code?: StreamCode, type?: 'hook' | 'output'): Promise<void>;
-    processPending(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
-    processSuccess(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
-    processError(telemetry: TelemetryService, type: string): Promise<MultiResponseFlags>;
+    processPending(type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processSuccess(type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processError(): Promise<MultiResponseFlags>;
     transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;
@@ -57,7 +61,7 @@ declare class Activity {
     bindJobError(data: Record<string, unknown>): void;
     getTriggerConfig(): Promise<ActivityType>;
     getJobStatus(): null | number;
-    setStatus(amount: number, multi?: RedisMulti): Promise<void>;
+    setStatus(amount: number, multi?: RedisMulti): Promise<void | any>;
     authorizeEntry(state: StringAnyType): string[];
     bindDimensionalAddress(state: StringAnyType): void;
     setState(multi?: RedisMulti): Promise<string>;

package/build/services/activities/activity.js

@@ -31,18 +31,47 @@ class Activity {
         this.leg = leg;
     }
     /**
-     * Upon entering leg 1 of a duplexed activty, verify
-     * all aspects of the entry including job and activty state
+     * A job is assumed to be complete when its status (a semaphore)
+     * reaches `0`. A different threshold can be set in the
+     * activity YAML, in support of Dynamic Activation Control.
+     */
+    mapStatusThreshold() {
+        if (this.config.statusThreshold !== undefined) {
+            const threshold = pipe_1.Pipe.resolve(this.config.statusThreshold, this.context);
+            if (threshold !== undefined && !isNaN(Number(threshold))) {
+                return threshold;
+            }
+        }
+        return 0;
+    }
+    /**
+     * Upon entering leg 1 of a duplexed activity
      */
     async verifyEntry() {
         this.setLeg(1);
         await this.getState();
-        collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+        const threshold = this.mapStatusThreshold();
+        try {
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid, threshold);
+        }
+        catch (error) {
+            if (threshold > 0) {
+                if (this.context.metadata.js === threshold) {
+                    //conclude job EXACTLY ONCE
+                    const status = await this.setStatus(-threshold);
+                    if (Number(status) === 0) {
+                        await this.engine.runJobCompletionTasks(this.context);
+                    }
+                }
+            }
+            else {
+                throw error;
+            }
+        }
         await collator_1.CollatorService.notarizeEntry(this);
     }
     /**
-     * Upon entering leg 2 of a duplexed activty, verify
-     * all aspects of the re-entry including job and activty state
+     * Upon entering leg 2 of a duplexed activity
      */
     async verifyReentry() {
         const guid = this.context.metadata.guid;
@@ -79,13 +108,13 @@ class Activity {
             telemetry.startActivitySpan(this.leg);
             let multiResponse;
             if (status === stream_1.StreamStatus.PENDING) {
-                multiResponse = await this.processPending(telemetry, type);
+                multiResponse = await this.processPending(type);
             }
             else if (status === stream_1.StreamStatus.SUCCESS) {
-                multiResponse = await this.processSuccess(telemetry, type);
+                multiResponse = await this.processSuccess(type);
             }
             else {
-                multiResponse = await this.processError(telemetry, type);
+                multiResponse = await this.processError();
             }
             this.transitionAdjacent(multiResponse, telemetry);
         }
@@ -120,7 +149,7 @@ class Activity {
             this.logger.debug('activity-process-event-end', { jid, aid });
         }
     }
-    async processPending(telemetry, type) {
+    async processPending(type) {
         this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
@@ -130,7 +159,7 @@ class Activity {
         await this.setStatus(this.adjacencyList.length, multi);
         return (await multi.exec());
     }
-    async processSuccess(telemetry, type) {
+    async processSuccess(type) {
         this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
@@ -140,7 +169,7 @@ class Activity {
         await this.setStatus(this.adjacencyList.length - 1, multi);
         return (await multi.exec());
     }
-    async processError(telemetry, type) {
+    async processError() {
         this.bindActivityError(this.data);
         this.adjacencyList = await this.filterAdjacent();
         if (!this.adjacencyList.length) {
@@ -249,7 +278,7 @@ class Activity {
     }
     async setStatus(amount, multi) {
         const { id: appId } = await this.engine.getVID();
-        await this.store.setStatus(amount, this.context.metadata.jid, appId, multi);
+        return await this.store.setStatus(amount, this.context.metadata.jid, appId, multi);
     }
     authorizeEntry(state) {
         //pre-authorize activity state to allow entry for adjacent activities

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

@@ -9,7 +9,7 @@ declare class CollatorService {
     /**
      * Upon re/entry, verify that the job status is active
      */
-    static assertJobActive(status: number, jobId: string, activityId: string): void;
+    static assertJobActive(status: number, jobId: string, activityId: string, threshold?: number): void;
     /**
      * returns the dimensional address (dad) for the target; due
      * to the nature of the notary system, the dad for leg 2 entry

package/build/services/collator/index.js

@@ -7,8 +7,8 @@ class CollatorService {
     /**
      * Upon re/entry, verify that the job status is active
      */
-    static assertJobActive(status, jobId, activityId) {
-        if (status <= 0) {
+    static assertJobActive(status, jobId, activityId, threshold = 0) {
+        if (status <= threshold) {
             throw new errors_1.InactiveJobError(jobId, status, activityId);
         }
     }

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

@@ -20,7 +20,7 @@ export declare class ClientService {
      * creating the stream. This method will verify that the stream
      * exists and if not, create it.
      */
-    static verifyStream: (workflowTopic: string, namespace?: string) => Promise<HotMesh>;
+    verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
     search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
     workflow: {
         start: (options: WorkflowOptions) => Promise<WorkflowHandleService>;

package/build/services/durable/client.js

@@ -17,15 +17,14 @@ const factory_1 = require("./schemas/factory");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (workflowTopic, namespace) => {
+            //namespace isolation requires the connection options to be hashed
+            //as multiple intersecting databases can be used by the same service
+            const optionsHash = (0, utils_1.hashOptions)(this.connection.options);
             const targetNS = namespace ?? factory_1.APP_ID;
-            if (ClientService.instances.has(targetNS)) {
-                const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
-                const hotMeshClient = await ClientService.instances.get(targetNS);
+            const connectionNS = `${optionsHash}.${targetNS}`;
+            if (ClientService.instances.has(connectionNS)) {
+                const hotMeshClient = await ClientService.instances.get(connectionNS);
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
-                if (!ClientService.topics.includes(targetTopic)) {
-                    ClientService.topics.push(targetTopic);
-                    await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
-                }
                 return hotMeshClient;
             }
             //create and cache an instance
@@ -39,11 +38,24 @@ class ClientService {
                     },
                 },
             });
-            ClientService.instances.set(targetNS, hotMeshClient);
-            await ClientService.createStream(await hotMeshClient, workflowTopic, namespace);
+            ClientService.instances.set(connectionNS, hotMeshClient);
             await this.activateWorkflow(await hotMeshClient, targetNS);
             return hotMeshClient;
         };
+        /**
+         * It is possible for a client to invoke a workflow without first
+         * creating the stream. This method will verify that the stream
+         * exists and if not, create it.
+         */
+        this.verifyStream = async (hotMeshClient, workflowTopic, namespace) => {
+            const optionsHash = (0, utils_1.hashOptions)(this.connection.options);
+            const targetNS = namespace ?? factory_1.APP_ID;
+            const targetTopic = `${optionsHash}.${targetNS}.${workflowTopic}`;
+            if (!ClientService.topics.includes(targetTopic)) {
+                ClientService.topics.push(targetTopic);
+                await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
+            }
+        };
         this.search = async (hotMeshClient, index, query) => {
             const store = hotMeshClient.engine.store;
             if (query[0]?.startsWith('FT.')) {
@@ -57,14 +69,16 @@ class ClientService {
                 const workflowName = options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
-                //NOTE: HotMesh 'workflowTopic' is a created by concatenating
-                //     the taskQueue and workflowName used by the Durable module
+                //hotmesh topic is a combination of the durable queue+workflowname
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+                //verify that the stream channel exists before enqueueing
+                await this.verifyStream(hotMeshClient, workflowTopic, options.namespace);
                 const payload = {
                     arguments: [...options.args],
                     originJobId: options.originJobId,
                     expire: options.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS,
+                    signalIn: options.signalIn,
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMeshService.guid(),
                     workflowTopic: workflowTopic,
@@ -200,21 +214,4 @@ ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) =>
         //ignore if already exists
     }
 };
-/**
- * It is possible for a client to invoke a workflow without first
- * creating the stream. This method will verify that the stream
- * exists and if not, create it.
- */
-ClientService.verifyStream = async (workflowTopic, namespace) => {
-    const targetTopic = `${namespace ?? factory_1.APP_ID}.${workflowTopic}`;
-    const targetNS = namespace ?? factory_1.APP_ID;
-    if (ClientService.instances.has(targetNS)) {
-        const hotMeshClient = await ClientService.instances.get(targetNS);
-        if (!ClientService.topics.includes(targetTopic)) {
-            ClientService.topics.push(targetTopic);
-            await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
-        }
-        return hotMeshClient;
-    }
-};
 exports.ClientService = ClientService;

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

@@ -21,7 +21,7 @@
  * * Service Meshes
  * * Master Data Management systems
  */
-declare const APP_VERSION = "1";
+declare const APP_VERSION = "2";
 declare const APP_ID = "durable";
 /**
  * returns a new durable workflow schema

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

@@ -24,7 +24,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
-const APP_VERSION = '1';
+const APP_VERSION = '2';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
@@ -81,6 +81,9 @@ const getWorkflowYAML = (app, version) => {
             expire:
               description: the time in seconds to expire the workflow in Redis once it completes
               type: number
+            signalIn:
+              description: if false, the job will not support subordinated hooks
+              type: boolean
 
       output:
         schema:
@@ -806,6 +809,7 @@ const getWorkflowYAML = (app, version) => {
         signaler:
           title: Signal-In Reentry point for subordinated hook flows
           type: hook
+          statusThreshold: 1
           hook:
             type: object
             properties:
@@ -1462,6 +1466,13 @@ const getWorkflowYAML = (app, version) => {
         trigger:
           - to: cycle_hook
           - to: signaler
+            conditions:
+              match:
+                - expected: true
+                  actual: 
+                    '@pipe':
+                      - ['{$self.output.data.signalIn}', true]
+                      - ['{@conditional.nullish}']
         ## MAIN PROCESS TRANSITIONS ##
         cycle_hook:
           - to: throttler

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

@@ -1,13 +1,11 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
+import { Registry, WorkerConfig, WorkerOptions } from '../../types/durable';
 export declare class WorkerService {
     static activityRegistry: Registry;
-    static connections: Map<string, import("../../types/durable").ConnectionConfig>;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     workflowRunner: HotMesh;
     activityRunner: HotMesh;
     static getHotMesh: (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => Promise<HotMesh>;
-    static findConnectionByNamespace: (namespace: string) => Connection;
     static activateWorkflow(hotMesh: HotMesh): Promise<void>;
     static registerActivities<ACT>(activities: ACT): Registry;
     static create(config: WorkerConfig): Promise<WorkerService>;

package/build/services/durable/worker.js

@@ -58,8 +58,6 @@ class WorkerService {
         return WorkerService.activityRegistry;
     }
     static async create(config) {
-        const targetNamespace = config.namespace ?? factory_1.APP_ID;
-        WorkerService.connections.set(targetNamespace, config.connection);
         const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
@@ -94,9 +92,12 @@ class WorkerService {
             class: config.connection.class,
             options: config.connection.options,
         };
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
-            appId: config.namespace ?? factory_1.APP_ID,
+            appId: targetNamespace,
             engine: { redis: redisConfig },
             workers: [
                 {
@@ -106,10 +107,9 @@ class WorkerService {
                 },
             ],
         });
-        WorkerService.instances.set(activityTopic, hotMeshWorker);
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
         return hotMeshWorker;
     }
-    //this is the linked worker function in the reentrant workflow test
     wrapActivityFunctions() {
         return async (data) => {
             try {
@@ -172,6 +172,9 @@ class WorkerService {
             class: config.connection.class,
             options: config.connection.options,
         };
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMeshService.init({
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
@@ -184,7 +187,7 @@ class WorkerService {
                 },
             ],
         });
-        WorkerService.instances.set(workflowTopic, hotMeshWorker);
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
         return hotMeshWorker;
     }
     wrapWorkflowFunction(workflowFunction, workflowTopic, config) {
@@ -199,6 +202,7 @@ class WorkerService {
                 context.set('canRetry', workflowInput.canRetry);
                 context.set('counter', counter);
                 context.set('interruptionRegistry', interruptionRegistry);
+                context.set('connection', config.connection);
                 context.set('namespace', config.namespace ?? factory_1.APP_ID);
                 context.set('raw', data);
                 context.set('workflowId', workflowInput.workflowId);
@@ -372,11 +376,11 @@ class WorkerService {
 }
 _a = WorkerService;
 WorkerService.activityRegistry = {}; //user's activities
-WorkerService.connections = new Map();
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     const targetNamespace = config?.namespace ?? factory_1.APP_ID;
-    const targetTopic = `${targetNamespace}.${workflowTopic}`;
+    const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
+    const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
     if (WorkerService.instances.has(targetTopic)) {
         return await WorkerService.instances.get(targetTopic);
     }
@@ -384,25 +388,13 @@ WorkerService.getHotMesh = async (workflowTopic, config, options) => {
         logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
         appId: targetNamespace,
         engine: {
-            redis: { ...WorkerService.findConnectionByNamespace(targetNamespace) },
+            redis: { ...config?.connection },
         },
     });
     WorkerService.instances.set(targetTopic, hotMeshClient);
     await WorkerService.activateWorkflow(await hotMeshClient);
     return hotMeshClient;
 };
-WorkerService.findConnectionByNamespace = (namespace) => {
-    let defaultConnection;
-    for (const [ns, value] of WorkerService.connections) {
-        if (ns === namespace) {
-            return value;
-        }
-        else if (!defaultConnection) {
-            defaultConnection = value;
-        }
-    }
-    return defaultConnection;
-};
 WorkerService.Context = {
     info: () => {
         return {

package/build/services/durable/workflow.js

@@ -69,6 +69,7 @@ class WorkflowService {
         const interruptionRegistry = store.get('interruptionRegistry');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const originJobId = store.get('originJobId');
         const workflowTrace = store.get('workflowTrace');
@@ -82,6 +83,7 @@ class WorkflowService {
             counter: COUNTER.counter,
             cursor,
             interruptionRegistry,
+            connection,
             namespace,
             originJobId,
             raw,
@@ -100,8 +102,9 @@ class WorkflowService {
     static async getHotMesh() {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
-        return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        return await worker_1.WorkerService.getHotMesh(workflowTopic, { connection, namespace });
     }
     /**
      * Spawns a child workflow and awaits the return.
@@ -315,10 +318,12 @@ class WorkflowService {
         const workflowId = store.get('workflowId');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         //this ID is used as a item key with a hash (dash prefix ensures no collision)
@@ -347,8 +352,10 @@ class WorkflowService {
     static async signal(signalId, data) {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
         const namespace = store.get('namespace');
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
@@ -365,8 +372,9 @@ class WorkflowService {
      * @param {HookOptions} options - the hook options
      */
     static async hook(options) {
-        const { workflowId, namespace, workflowTopic } = WorkflowService.getContext();
+        const { workflowId, connection, namespace, workflowTopic } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
@@ -395,13 +403,14 @@ class WorkflowService {
      * @template T - the result type
      */
     static async once(fn, ...args) {
-        const { COUNTER, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
+        const { COUNTER, connection, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const sessionId = `-once${workflowDimension}-${execIndex}-`;
         if (sessionId in replay) {
             return serializer_1.SerializerService.fromString(replay[sessionId]).data;
         }
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         const keyParams = {
@@ -424,8 +433,9 @@ class WorkflowService {
      * Interrupts a running job
      */
     static async interrupt(jobId, options = {}) {
-        const { workflowTopic, namespace } = WorkflowService.getContext();
+        const { workflowTopic, connection, namespace, } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
             namespace,
         });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {

package/build/services/pipe/functions/conditional.d.ts

@@ -2,6 +2,8 @@ declare class ConditionalHandler {
     ternary(condition: boolean, valueIfTrue: any, valueIfFalse: any): any;
     equality(value1: any, value2: any): boolean;
     strict_equality(value1: any, value2: any): boolean;
+    inequality(value1: any, value2: any): boolean;
+    strict_inequality(value1: any, value2: any): boolean;
     greater_than(value1: number, value2: number): boolean;
     less_than(value1: number, value2: number): boolean;
     greater_than_or_equal(value1: number, value2: number): boolean;

package/build/services/pipe/functions/conditional.js

@@ -11,6 +11,12 @@ class ConditionalHandler {
     strict_equality(value1, value2) {
         return value1 === value2;
     }
+    inequality(value1, value2) {
+        return value1 != value2;
+    }
+    strict_inequality(value1, value2) {
+        return value1 !== value2;
+    }
     greater_than(value1, value2) {
         return value1 > value2;
     }

package/build/types/activity.d.ts

@@ -6,6 +6,8 @@ interface BaseActivity {
     title?: string;
     type?: ActivityExecutionType;
     subtype?: string;
+    statusThreshold?: number;
+    statusThresholdType?: 'stop' | 'throw' | 'stall';
     input?: Record<string, any>;
     output?: Record<string, any>;
     settings?: Record<string, any>;

package/build/types/durable.d.ts

@@ -88,6 +88,10 @@ type WorkflowContext = {
      * the native HotMesh message that encapsulates the arguments, metadata, and raw data for the workflow
      */
     raw: StreamData;
+    /**
+     * the HotMesh connection configuration (io/redis NPM package reference and login credentials)
+     */
+    connection: Connection;
 };
 /**
  * The schema for the full-text-search (RediSearch) index.
@@ -256,6 +260,10 @@ type WorkflowOptions = {
      * sets the number of seconds a workflow may exist after completion. As the process engine is an in-memory cache, the default policy is to expire and scrub the job hash as soon as it completes.
      */
     expire?: number;
+    /**
+     * default is true; set to false to optimize workflows that do not require a `signal in`
+     */
+    signalIn?: boolean;
     /**
      * default is true; if false, will not await the execution
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -84,7 +84,6 @@
     "js-yaml": "^4.1.0",
     "ms": "^2.1.3",
     "nanoid": "^3.3.6",
-    "systeminformation": "^5.22.2",
     "winston": "^3.8.2"
   },
   "devDependencies": {

package/types/activity.ts

@@ -18,6 +18,8 @@ interface BaseActivity {
   title?: string;
   type?: ActivityExecutionType;
   subtype?: string;
+  statusThreshold?: number; //default is 0; set to 1 to ensure not last standing; message will be ignored as if too late to process
+  statusThresholdType?: 'stop' | 'throw' | 'stall'; //default is stop; must explicitly set to throw to throw an error or stall to stall
   input?: Record<string, any>;
   output?: Record<string, any>;
   settings?: Record<string, any>;

package/types/durable.ts

@@ -106,6 +106,11 @@ type WorkflowContext = {
    * the native HotMesh message that encapsulates the arguments, metadata, and raw data for the workflow
    */
   raw: StreamData;
+
+  /**
+   * the HotMesh connection configuration (io/redis NPM package reference and login credentials)
+   */
+  connection: Connection;
 };
 
 /**
@@ -309,6 +314,11 @@ type WorkflowOptions = {
    */
   expire?: number;
 
+  /**
+   * default is true; set to false to optimize workflows that do not require a `signal in`
+   */
+  signalIn?: boolean;
+
   /**
    * default is true; if false, will not await the execution
    */