@hotmeshio/hotmesh 0.0.33 → 0.0.35

package/build/services/durable/handle.js

@@ -1,15 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowHandleService = void 0;
+const enums_1 = require("../../modules/enums");
 class WorkflowHandleService {
     constructor(hotMesh, workflowTopic, workflowId) {
         this.workflowTopic = workflowTopic;
         this.workflowId = workflowId;
         this.hotMesh = hotMesh;
     }
+    /**
+     * Sends a signal to the workflow. This is a way to send
+     * a message to a workflow that is paused due to having
+     * executed a `waitForSignal` workflow extension. Awakens
+     * the workflow 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) {
@@ -17,12 +30,38 @@ 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);
+    }
+    /**
+     * Awaits for the workflow to complete and returns the result. If
+     * the workflow thows and error, this method will likewise throw
+     * an error.
+     */
     async result(loadState) {
         if (loadState) {
             const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
@@ -50,30 +89,34 @@ class WorkflowHandleService {
                 }
                 else if (!response) {
                     const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-                    if (!state.data && state.metadata.err) {
-                        return reject(JSON.parse(state.metadata.err));
+                    if (state.metadata.err) {
+                        const error = JSON.parse(state.metadata.err);
+                        if (error.code === enums_1.STATUS_CODE_INTERRUPT || !state.data) {
+                            return reject({ ...error, job_id: this.workflowId });
+                        }
                     }
                     response = state.data?.response;
                 }
                 resolve(response);
             };
             //check for done
-            if (status == 0) {
+            if (status <= 0) {
                 return complete();
             }
             //subscribe to topic
             this.hotMesh.sub(topic, async (topic, state) => {
-                if (!state.data && state.metadata.err) {
-                    await complete(null, state.metadata.err);
-                }
-                else {
-                    await complete(state.data?.response);
+                if (state.metadata.err) {
+                    const error = JSON.parse(state.metadata.err);
+                    if (error.code === enums_1.STATUS_CODE_INTERRUPT || !state.data) {
+                        return await complete(null, state.metadata.err);
+                    }
                 }
+                await complete(state.data?.response);
             });
             //resolve for race condition
             setTimeout(async () => {
                 status = await this.hotMesh.getStatus(this.workflowId);
-                if (status == 0) {
+                if (status <= 0) {
                     await complete();
                 }
             }, 0);

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

@@ -12,5 +12,10 @@ export declare const Durable: {
     MeshOS: typeof MeshOSService;
     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

@@ -7,6 +7,7 @@ const meshos_1 = require("./meshos");
 const search_1 = require("./search");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
+const hotmesh_1 = require("../hotmesh");
 exports.Durable = {
     Client: client_1.ClientService,
     Connection: connection_1.ConnectionService,
@@ -14,4 +15,13 @@ exports.Durable = {
     MeshOS: meshos_1.MeshOSService,
     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();
+        await hotmesh_1.HotMeshService.stop();
+    }
 };

package/build/services/durable/meshos.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MeshOSService = void 0;
-const nanoid_1 = require("nanoid");
 const _1 = require(".");
 const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const client_1 = require("./client");
 const search_1 = require("./search");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
-const stream_1 = require("../signaler/stream");
+const utils_1 = require("../../modules/utils");
 /**
  * The base class for running MeshOS workflows.
  * Extend this class, add your Redis config, and add functions to
@@ -32,7 +31,7 @@ class MeshOSService {
      */
     static mintGuid() {
         const my = new this();
-        return `${my.search?.prefix?.[0]}${(0, nanoid_1.nanoid)()}`;
+        return `${my.search?.prefix?.[0]}${(0, utils_1.guid)()}`;
     }
     /**
      * Creates an FT search index
@@ -47,9 +46,7 @@ class MeshOSService {
      * @returns {Promise<void>}
      */
     static async stopWorkers() {
-        await _1.Durable.Client.shutdown();
-        await _1.Durable.Worker.shutdown();
-        await stream_1.StreamSignaler.stopConsuming();
+        await _1.Durable.shutdown();
     }
     /**
      * Initializes the worker(s). This is a static

package/build/services/durable/worker.js

@@ -153,14 +153,21 @@ class WorkerService {
                 //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
+                context.set('raw', data);
                 context.set('namespace', config.namespace ?? factory_1.APP_ID);
                 context.set('counter', counter);
                 context.set('workflowId', workflowInput.workflowId);
-                if (data.data.workflowDimension) {
+                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);
+                }
+                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', data.data.workflowDimension);
+                    context.set('workflowDimension', workflowInput.workflowDimension);
                 }
                 context.set('workflowTopic', workflowTopic);
                 context.set('workflowName', workflowTopic.split('-').pop());
@@ -240,9 +247,8 @@ class WorkerService {
         };
     }
     static async shutdown() {
-        for (const [key, value] of WorkerService.instances) {
-            const hotMesh = await value;
-            await hotMesh.stop();
+        for (const [_, hotMeshInstance] of WorkerService.instances) {
+            (await hotMeshInstance).stop();
         }
     }
 }

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

@@ -1,6 +1,7 @@
 import { Search } from './search';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOptions } from "../../types/durable";
+import { JobInterruptOptions } from '../../types/job';
 export declare class WorkflowService {
     /**
      * Spawns a child workflow. await and return the result.
@@ -80,6 +81,29 @@ export declare class WorkflowService {
      * @param {HookOptions} options - the hook options
      */
     static hook(options: HookOptions): Promise<string>;
+    static getLocalState(): {
+        workflowId: any;
+        namespace: any;
+        workflowTopic: any;
+        workflowDimension: any;
+        counter: any;
+    };
+    /**
+     * Executes a function once and caches the result. If the function is called
+     * again, the cached result is returned. This is useful for wrapping
+     * expensive activity calls that should only be run once, but which might
+     * not require the configuration nuance/expense provided by proxyActivities.
+     * @template T - the result type
+     */
+    static once<T>(fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T>;
+    /**
+     * Interrupts a running job
+     *
+     * @param {string} jobId - the target job id
+     * @param {JobInterruptOptions} options - the interrupt options
+     * @returns {Promise<string>} - the stream id
+     */
+    static interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;
     /**
      * Sleeps the workflow for a duration. As the function is reentrant,
      * upon reentry, the function will traverse prior execution paths up

package/build/services/durable/workflow.js

@@ -26,6 +26,7 @@ class WorkflowService {
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
         const namespace = store.get('namespace');
         const workflowId = store.get('workflowId');
+        const originJobId = store.get('originJobId');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTrace = store.get('workflowTrace');
         const workflowSpan = store.get('workflowSpan');
@@ -49,6 +50,7 @@ class WorkflowService {
                 ...options,
                 namespace,
                 workflowId: childJobId,
+                originJobId: originJobId ?? workflowId,
                 parentWorkflowId,
                 workflowTrace,
                 workflowSpan,
@@ -261,6 +263,57 @@ class WorkflowService {
             return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
         }
     }
+    static getLocalState() {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        return {
+            workflowId: store.get('workflowId'),
+            namespace: store.get('namespace'),
+            workflowTopic: store.get('workflowTopic'),
+            workflowDimension: store.get('workflowDimension') ?? '',
+            counter: store.get('counter'),
+        };
+    }
+    /**
+     * Executes a function once and caches the result. If the function is called
+     * again, the cached result is returned. This is useful for wrapping
+     * expensive activity calls that should only be run once, but which might
+     * not require the configuration nuance/expense provided by proxyActivities.
+     * @template T - the result type
+     */
+    static async once(fn, ...args) {
+        const { workflowId, namespace, workflowTopic, workflowDimension, counter: COUNTER, } = WorkflowService.getLocalState();
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        const sessionId = `-once${workflowDimension}-${execIndex}-`;
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        const keyParams = {
+            appId: hotMeshClient.appId,
+            jobId: workflowId
+        };
+        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        const value = await hotMeshClient.engine.store.exec('HGET', workflowGuid, sessionId);
+        if (value) {
+            return JSON.parse(value);
+        }
+        const response = await fn(...args);
+        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, JSON.stringify(response));
+        return response;
+    }
+    /**
+     * Interrupts a running job
+     *
+     * @param {string} jobId - the target job id
+     * @param {JobInterruptOptions} options - the interrupt options
+     * @returns {Promise<string>} - the stream id
+     */
+    static async interrupt(jobId, options = {}) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
+        const namespace = store.get('namespace');
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {
+            return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
+        }
+    }
     /**
      * Sleeps the workflow for a duration. As the function is reentrant,
      * upon reentry, the function will traverse prior execution paths up
@@ -379,6 +432,7 @@ class WorkflowService {
             //increment by state (not value) to avoid race conditions
             const execIndex = COUNTER.counter = COUNTER.counter + 1;
             const workflowId = store.get('workflowId');
+            const originJobId = store.get('originJobId');
             const workflowDimension = store.get('workflowDimension') ?? '';
             const workflowTopic = store.get('workflowTopic');
             const trc = store.get('workflowTrace');
@@ -412,7 +466,8 @@ class WorkflowService {
                 const duration = (0, ms_1.default)(options?.startToCloseTimeout || '1 minute');
                 const payload = {
                     arguments: Array.from(arguments),
-                    //the parent id is provided to categorize this activity for later cleanup
+                    //when the origin job is removed
+                    originJobId: originJobId ?? workflowId,
                     parentWorkflowId: `${workflowId}-a`,
                     workflowId: activityJobId,
                     workflowTopic: activityTopic,

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

@@ -1,6 +1,7 @@
 import { Await } from '../activities/await';
 import { Cycle } from '../activities/cycle';
 import { Hook } from '../activities/hook';
+import { Interrupt } from '../activities/interrupt';
 import { Signal } from '../activities/signal';
 import { Worker } from '../activities/worker';
 import { Trigger } from '../activities/trigger';
@@ -14,7 +15,7 @@ import { TaskService } from '../task';
 import { AppVID } from '../../types/app';
 import { ActivityType } from '../../types/activity';
 import { CacheMode } from '../../types/cache';
-import { JobState, JobData, JobMetadata, JobOutput, JobStatus } from '../../types/job';
+import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions } from '../../types/job';
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
@@ -50,7 +51,7 @@ declare class EngineService {
     processWebHooks(): Promise<void>;
     processTimeHooks(): Promise<void>;
     throttle(delayInMillis: number): Promise<void>;
-    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Await | Cycle | Hook | Signal | Trigger | Worker>;
+    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Await | Cycle | Hook | Signal | Trigger | Worker | Interrupt>;
     getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
     getSettings(): Promise<HotMeshSettings>;
     isPrivate(topic: string): boolean;
@@ -63,9 +64,10 @@ declare class EngineService {
     execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<string>;
     hasParentJob(context: JobState): boolean;
     resolveError(metadata: JobMetadata): StreamError | undefined;
+    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
     scrub(jobId: string): Promise<void>;
     hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
-    hookTime(jobId: string, activityId: string): Promise<JobStatus | void>;
+    hookTime(jobId: string, activityId: string, type?: 'sleep' | 'expire' | 'interrupt'): Promise<string | void>;
     hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     pub(topic: string, data: JobData, context?: JobState): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
@@ -73,14 +75,20 @@ declare class EngineService {
     psub(wild: string, callback: JobMessageCallback): Promise<void>;
     punsub(wild: string): Promise<void>;
     pubsub(topic: string, data: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
-    resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    pubOneTimeSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
     getPublishesTopic(context: JobState): Promise<string>;
-    resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
     add(streamData: StreamData | StreamDataResponse): Promise<string>;
     registerJobCallback(jobId: string, jobCallback: JobMessageCallback): void;
     delistJobCallback(jobId: string): void;
     hasOneTimeSubscription(context: JobState): boolean;
-    runJobCompletionTasks(context: JobState, emit?: boolean): Promise<void>;
+    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions): Promise<string | void>;
+    /**
+     * Job hash expiration is typically reliant on the metadata field
+     * if the activity concludes normally. However, if the job is `interrupted`,
+     * it will be expired immediately.
+     */
+    resolveExpires(context: JobState, options: JobCompletionOptions): number;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;

package/build/services/engine/index.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EngineService = void 0;
 const key_1 = require("../../modules/key");
+const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
 const activities_1 = __importDefault(require("../activities"));
 const compiler_1 = require("../compiler");
@@ -20,11 +21,6 @@ const ioredis_3 = require("../sub/clients/ioredis");
 const redis_3 = require("../sub/clients/redis");
 const task_1 = require("../task");
 const stream_2 = require("../../types/stream");
-//wait time to see if a job is complete
-const OTT_WAIT_TIME = 1000;
-const STATUS_CODE_SUCCESS = 200;
-const STATUS_CODE_PENDING = 202;
-const STATUS_CODE_TIMEOUT = 504;
 class EngineService {
     constructor() {
         this.cacheMode = 'cache';
@@ -230,6 +226,7 @@ class EngineService {
             aid: streamData.metadata.aid,
             status: streamData.status || stream_2.StreamStatus.SUCCESS,
             code: streamData.code || 200,
+            type: streamData.type,
         });
         const context = {
             metadata: {
@@ -285,6 +282,7 @@ class EngineService {
             const spn = context['$self']?.output?.metadata?.l2s || context['$self']?.output?.metadata?.l1s;
             const streamData = {
                 metadata: {
+                    guid: (0, utils_1.guid)(),
                     jid: context.metadata.pj,
                     dad: context.metadata.pd,
                     aid: context.metadata.pa,
@@ -301,17 +299,16 @@ class EngineService {
             }
             else if (emit) {
                 streamData.status = stream_2.StreamStatus.PENDING;
-                streamData.code = STATUS_CODE_PENDING;
+                streamData.code = enums_1.STATUS_CODE_PENDING;
             }
             else {
                 streamData.status = stream_2.StreamStatus.SUCCESS;
-                streamData.code = STATUS_CODE_SUCCESS;
+                streamData.code = enums_1.STATUS_CODE_SUCCESS;
             }
             return (await this.streamSignaler?.publishMessage(null, streamData));
         }
     }
     hasParentJob(context) {
-        //todo: include the dimensional address (pd)
         return Boolean(context.metadata.pj && context.metadata.pa);
     }
     resolveError(metadata) {
@@ -319,8 +316,19 @@ class EngineService {
             return JSON.parse(metadata.err);
         }
     }
+    // ****************** `INTERRUPT` ACTIVE JOBS *****************
+    async interrupt(topic, jobId, options = {}) {
+        await this.store.interrupt(topic, jobId, options);
+        const context = await this.getState(topic, jobId);
+        const completionOpts = {
+            interrupt: options.descend,
+            expire: options.expire,
+        };
+        return await this.runJobCompletionTasks(context, completionOpts);
+    }
     // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     async scrub(jobId) {
+        //todo: do not allow scrubbing of non-existent or actively running job
         await this.store.scrub(jobId);
     }
     // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
@@ -332,6 +340,7 @@ class EngineService {
             status,
             code,
             metadata: {
+                guid: (0, utils_1.guid)(),
                 aid,
                 topic
             },
@@ -339,13 +348,21 @@ class EngineService {
         };
         return await this.streamSignaler.publishMessage(null, streamData);
     }
-    async hookTime(jobId, activityId) {
-        //the activityid is concatenated with its dimensional address (dad); split to resolve
+    async hookTime(jobId, activityId, type) {
+        if (type === 'interrupt') {
+            return await this.interrupt(activityId, //note: 'activityId' is the actually job topic
+            jobId, { suppress: true, expire: 1 });
+        }
+        else if (type === 'expire') {
+            return await this.store.expireJob(jobId, 1);
+        }
+        //'sleep': parse the activityId into parts
         const [aid, ...dimensions] = activityId.split(',');
         const dad = `,${dimensions.join(',')}`;
         const streamData = {
             type: stream_2.StreamDataType.TIMEHOOK,
             metadata: {
+                guid: (0, utils_1.guid)(),
                 jid: jobId,
                 aid,
                 dad,
@@ -407,7 +424,7 @@ class EngineService {
         return await this.subscribe.punsubscribe(key_1.KeyType.QUORUM, this.appId, wild);
     }
     //publish and await (returns the job and data (if ready)); throws error with jobid if not
-    async pubsub(topic, data, context, timeout = OTT_WAIT_TIME) {
+    async pubsub(topic, data, context, timeout = enums_1.OTT_WAIT_TIME) {
         context = {
             metadata: {
                 ngn: this.guid,
@@ -432,14 +449,14 @@ class EngineService {
             setTimeout(() => {
                 this.delistJobCallback(jobId);
                 reject({
-                    code: STATUS_CODE_TIMEOUT,
+                    code: enums_1.STATUS_CODE_TIMEOUT,
                     message: 'timeout',
                     job_id: jobId
                 });
             }, timeout);
         });
     }
-    async resolveOneTimeSubscription(context, jobOutput, emit = false) {
+    async pubOneTimeSubs(context, jobOutput, emit = false) {
         //todo: subscriber should query for the job...only publish minimum context needed
         if (this.hasOneTimeSubscription(context)) {
             const message = {
@@ -456,7 +473,7 @@ class EngineService {
         const schema = await this.store.getSchema(activityId, config);
         return schema.publishes;
     }
-    async resolvePersistentSubscriptions(context, jobOutput, emit = false) {
+    async pubPermSubs(context, jobOutput, emit = false) {
         const topic = await this.getPublishesTopic(context);
         if (topic) {
             const message = {
@@ -480,22 +497,30 @@ class EngineService {
         return Boolean(context.metadata.ngn);
     }
     // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
-    async runJobCompletionTasks(context, emit = false) {
-        //if 'emit' is true, the job isn't done. it's just emitting
+    async runJobCompletionTasks(context, options = {}) {
+        //'emit' indicates the job is still active
         const isAwait = this.hasParentJob(context);
-        const isOneTimeSubscription = this.hasOneTimeSubscription(context);
+        const isOneTimeSub = this.hasOneTimeSubscription(context);
         const topic = await this.getPublishesTopic(context);
-        if (isAwait || isOneTimeSubscription || topic) {
+        let msgId;
+        if (isAwait || isOneTimeSub || topic) {
             const jobOutput = await this.getState(context.metadata.tpc, context.metadata.jid);
-            //always wait for stream pub/sub
-            await this.execAdjacentParent(context, jobOutput, emit);
-            //no need to wait for standard pub/sub
-            this.resolveOneTimeSubscription(context, jobOutput, emit);
-            this.resolvePersistentSubscriptions(context, jobOutput, emit);
-        }
-        if (!emit) {
-            this.task.registerJobForCleanup(context.metadata.jid, context.metadata.expire);
-        }
+            msgId = await this.execAdjacentParent(context, jobOutput, options.emit);
+            this.pubOneTimeSubs(context, jobOutput, options.emit);
+            this.pubPermSubs(context, jobOutput, options.emit);
+        }
+        if (!options.emit) {
+            this.task.registerJobForCleanup(context.metadata.jid, this.resolveExpires(context, options), options);
+        }
+        return msgId;
+    }
+    /**
+     * Job hash expiration is typically reliant on the metadata field
+     * if the activity concludes normally. However, if the job is `interrupted`,
+     * it will be expired immediately.
+     */
+    resolveExpires(context, options) {
+        return context.metadata.expire ?? options.expire ?? enums_1.DURABLE_EXPIRE_SECONDS;
     }
     // ****** GET JOB STATE/COLLATION STATUS BY ID *********
     async getStatus(jobId) {

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

@@ -2,7 +2,7 @@ import { EngineService } from '../engine';
 import { ILogger } from '../logger';
 import { QuorumService } from '../quorum';
 import { WorkerService } from '../worker';
-import { JobState, JobData, JobOutput, JobStatus } from '../../types/job';
+import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
@@ -16,6 +16,7 @@ declare class HotMeshService {
     quorum: QuorumService | null;
     workers: WorkerService[];
     logger: ILogger;
+    static disconnecting: boolean;
     verifyAndSetNamespace(namespace?: string): void;
     verifyAndSetAppId(appId: string): void;
     static init(config: HotMeshConfig): Promise<HotMeshService>;
@@ -33,16 +34,19 @@ declare class HotMeshService {
     plan(path: string): Promise<HotMeshManifest>;
     deploy(pathOrYAML: string): Promise<HotMeshManifest>;
     activate(version: string, delay?: number): Promise<boolean>;
+    inventory(version: string, delay?: number): Promise<number>;
     getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
     getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
     resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
+    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
     scrub(jobId: string): Promise<void>;
     hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
     hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
-    stop(): Promise<void>;
+    static stop(): Promise<void>;
+    stop(): void;
     compress(terms: string[]): Promise<boolean>;
 }
 export { HotMeshService };