@hotmeshio/hotmesh 0.0.54 → 0.0.56

package/build/services/durable/worker.js

@@ -61,7 +61,6 @@ 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);
@@ -104,11 +103,9 @@ 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];
@@ -124,8 +121,6 @@ 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,
@@ -140,8 +135,6 @@ 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,
@@ -181,7 +174,6 @@ class WorkerService {
             const counter = { counter: 0 };
             const interruptionRegistry = [];
             try {
-                //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
                 context.set('canRetry', workflowInput.canRetry);
@@ -191,20 +183,14 @@ 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);
@@ -214,7 +200,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); // if != 0, more remain
+                context.set('cursor', cursor);
                 const workflowResponse = await storage_1.asyncLocalStorage.run(context, async () => {
                     return await workflowFunction.apply(this, workflowInput.arguments);
                 });
@@ -227,7 +213,6 @@ class WorkerService {
             }
             catch (err) {
                 if (err instanceof errors_1.DurableWaitForError || interruptionRegistry.length > 1) {
-                    //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;
@@ -250,7 +235,6 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableSleepError) {
-                    //return the sleep interruption
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: err.code,
@@ -265,7 +249,6 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableProxyError) {
-                    //return the proxyActivity interruption
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: err.code,
@@ -288,7 +271,6 @@ class WorkerService {
                     };
                 }
                 else if (err instanceof errors_1.DurableChildError) {
-                    //return the child interruption
                     const msg = {
                         message: err.message,
                         workflowId: err.workflowId,
@@ -315,8 +297,6 @@ class WorkerService {
                         }
                     };
                 }
-                // ALL other errors are actual fatal errors (598, 597, 596)
-                //  OR will be retried (599)
                 return {
                     status: stream_1.StreamStatus.SUCCESS,
                     code: err.code || new errors_1.DurableRetryError(err.message).code,
@@ -341,7 +321,7 @@ class WorkerService {
     }
 }
 _a = WorkerService;
-WorkerService.activityRegistry = {}; //user's activities
+WorkerService.activityRegistry = {};
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     if (WorkerService.instances.has(workflowTopic)) {

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

@@ -4,136 +4,22 @@ import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOption
 import { JobInterruptOptions } from '../../types/job';
 import { DurableChildErrorType, DurableProxyErrorType } from '../../types/error';
 export declare class WorkflowService {
-    /**
-     * Returns the synchronous output from the activity (replay)
-     * if available locally, revealing whether or not the activity already
-     * ran during a prior execution cycle
-     * @param {string} prefix - one of: proxy, child, start, wait etc
-     * @returns
-     */
     static didRun(prefix: string): Promise<[boolean, number, any]>;
-    /**
-     * Those methods that may only be called once must be protected by flagging
-     * their execution with a unique key (the key is stored in the HASH alongside
-     * process state and job state)
-     * @private
-     */
     static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
-    /**
-     * Returns the current workflow context restored
-     * from Redis
-     */
     static getContext(): WorkflowContext;
-    /**
-     * Return a handle to the hotmesh client hosting the workflow execution
-     * @returns {Promise<HotMesh>} - a hotmesh client
-     */
     static getHotMesh(): Promise<HotMesh>;
-    /**
-     * Spawns a child workflow and awaits the return.
-     * @template T - the result type
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<T>} - the result of the child workflow
-     * @example
-     * const result = await Durable.workflow.execChild<typeof resultType>({ ...options });
-     */
     static execChild<T>(options: WorkflowOptions): Promise<T>;
-    /**
-     * constructs the payload necessary to spawn a child job
-     * @private
-     */
     static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): DurableChildErrorType;
-    /**
-     * Spawns a child workflow and returns the child Job ID.
-     * This method guarantees the spawned child has reserved the Job ID,
-     * returning a 'DuplicateJobError' error if not. Otherwise,
-     * this is a fire-and-forget method.
-     *
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<string>} - the childJobId
-     * @example
-     * const childJobId = await Durable.workflow.startChild({ ...options });
-     */
     static startChild(options: WorkflowOptions): Promise<string>;
-    /**
-     * Wraps activities in a proxy that durably runs/re-runs them to completion.
-     * TODO: verify that activities do not collide if named same on same server but bound to different workflows
-     *
-     * @param {ActivityConfig} options - the activity configuration
-     * that will be used to wrap the activities.
-     * @returns {ProxyType<ACT>} - a proxy object with the same keys as the
-     * activities object, but with the values replaced by a wrapped function
-     *
-     * @example
-     * // import the activities
-     * import * as activities from './activities';
-     * const proxy = WorkflowService.proxyActivities<typeof activities>({ activities });
-     *
-     * //or destructure the proxy object, as the function names are the keys
-     * const { activity1, activity2 } = WorkflowService.proxyActivities<typeof activities>({ activities });
-     */
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
     static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
-    /**
-      * constructs the payload necessary to spawn a proxyActivity job
-      * @private
-      */
     static getProxyInterruptPayload(context: WorkflowContext, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): DurableProxyErrorType;
-    /**
-     * Returns a search session for use when reading/writing to the workflow HASH.
-     * The search session provides access to methods like `get`, `mget`, `set`, `del`, and `incr`.
-     * @returns {Promise<Search>} - a search session
-     */
     static search(): Promise<Search>;
-    /**
-     * Returns a random number between 0 and 1. This number is deterministic
-     * and will never vary for a given seed. This is useful for randomizing
-     * pathways in a workflow that can be safely replayed.
-     * @returns {number} - a random number between 0 and 1
-     */
     static random(): number;
-    /**
-     * Sends signal data into any other paused thread (which is currently
-     * awaiting the signal)
-     * @param {string} signalId - the signal id
-     * @param {Record<any, any>} data - the signal data
-     * @returns {Promise<string>} - the stream id
-     */
     static signal(signalId: string, data: Record<any, any>): Promise<string>;
-    /**
-     * Spawns a hook from either the main thread or a hook thread with
-     * the provided options; worflowId/TaskQueue/Name are optional and will
-     * default to the current workflowId/WorkflowTopic if not provided
-     * @param {HookOptions} options - the hook options
-     */
     static hook(options: HookOptions): Promise<string>;
-    /**
-     * 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 cost and safety provided by proxyActivities.
-     * @template T - the result type
-     */
     static once<T>(fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T>;
-    /**
-     * Interrupts a running job
-     */
     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
-     * until the sleep command and then resume execution thereafter.
-     * @param {string} duration - See the `ms` package for syntax examples: '1 minute', '2 hours', '3 days'
-     * @returns {Promise<number>} - resolved duration in seconds
-     */
     static sleepFor(duration: string): Promise<number>;
-    /**
-     * Pauses the workflow until `signalId` is received.
-     * @template T - the result type
-     * @param {string} signalId - a unique, shareable guid (e.g, 'abc123')
-     * @returns {Promise<T>}
-     * @example
-     * const result = await Durable.workflow.waitFor<typeof resultType>('abc123');
-     */
     static waitFor<T>(signalId: string): Promise<T>;
 }

package/build/services/durable/workflow.js

@@ -15,13 +15,6 @@ const serializer_1 = require("../serializer");
 const stream_1 = require("../../types/stream");
 const enums_1 = require("../../modules/enums");
 class WorkflowService {
-    /**
-     * Returns the synchronous output from the activity (replay)
-     * if available locally, revealing whether or not the activity already
-     * ran during a prior execution cycle
-     * @param {string} prefix - one of: proxy, child, start, wait etc
-     * @returns
-     */
     static async didRun(prefix) {
         const { COUNTER, replay, workflowDimension, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
@@ -32,12 +25,6 @@ class WorkflowService {
         }
         return [false, execIndex, null];
     }
-    /**
-     * Those methods that may only be called once must be protected by flagging
-     * their execution with a unique key (the key is stored in the HASH alongside
-     * process state and job state)
-     * @private
-     */
     static async isSideEffectAllowed(hotMeshClient, prefix) {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowId = store.get('workflowId');
@@ -57,10 +44,6 @@ class WorkflowService {
         const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
         return guidValue === 1;
     }
-    /**
-     * Returns the current workflow context restored
-     * from Redis
-     */
     static getContext() {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowId = store.get('workflowId');
@@ -93,36 +76,21 @@ class WorkflowService {
             workflowSpan,
         };
     }
-    /**
-     * Return a handle to the hotmesh client hosting the workflow execution
-     * @returns {Promise<HotMesh>} - a hotmesh client
-     */
     static async getHotMesh() {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
         const namespace = store.get('namespace');
         return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
     }
-    /**
-     * Spawns a child workflow and awaits the return.
-     * @template T - the result type
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<T>} - the result of the child workflow
-     * @example
-     * const result = await Durable.workflow.execChild<typeof resultType>({ ...options });
-     */
     static async execChild(options) {
-        //SYNC
-        //check if the activity already ran (check $error/done)
         const isStartChild = options.await === false;
         const prefix = isStartChild ? 'start' : 'child';
         const [didRun, execIndex, result] = await WorkflowService.didRun(prefix);
-        const context = this.getContext();
+        const context = WorkflowService.getContext();
         const { canRetry, interruptionRegistry } = context;
         if (didRun) {
             if (result?.$error && (!result.$error.is_stream_error || (result.$error.is_stream_error && !canRetry))) {
                 if (options?.config?.throwOnError !== false) {
-                    //rethrow remote execution error (simulates local failure)
                     const code = result.$error.code;
                     const message = result.$error.message;
                     const stack = result.$error.stack;
@@ -145,21 +113,14 @@ class WorkflowService {
                 return result.data;
             }
         }
-        const interruptionMessage = this.getChildInterruptPayload(context, options, execIndex);
-        //push the packaged inputs to the registry
+        const interruptionMessage = WorkflowService.getChildInterruptPayload(context, options, execIndex);
         interruptionRegistry.push({
             code: enums_1.HMSH_CODE_DURABLE_CHILD,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep (allow others to be packaged / registered) and throw the error
         await (0, utils_1.sleepFor)(0);
         throw new errors_1.DurableChildError(interruptionMessage);
     }
-    /**
-     * constructs the payload necessary to spawn a child job
-     * @private
-     */
     static getChildInterruptPayload(context, options, execIndex) {
         const { workflowId, originJobId, workflowDimension } = context;
         let childJobId;
@@ -190,37 +151,9 @@ class WorkflowService {
             workflowTopic,
         };
     }
-    /**
-     * Spawns a child workflow and returns the child Job ID.
-     * This method guarantees the spawned child has reserved the Job ID,
-     * returning a 'DuplicateJobError' error if not. Otherwise,
-     * this is a fire-and-forget method.
-     *
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<string>} - the childJobId
-     * @example
-     * const childJobId = await Durable.workflow.startChild({ ...options });
-     */
     static async startChild(options) {
-        return this.execChild({ ...options, await: false });
+        return WorkflowService.execChild({ ...options, await: false });
     }
-    /**
-     * Wraps activities in a proxy that durably runs/re-runs them to completion.
-     * TODO: verify that activities do not collide if named same on same server but bound to different workflows
-     *
-     * @param {ActivityConfig} options - the activity configuration
-     * that will be used to wrap the activities.
-     * @returns {ProxyType<ACT>} - a proxy object with the same keys as the
-     * activities object, but with the values replaced by a wrapped function
-     *
-     * @example
-     * // import the activities
-     * import * as activities from './activities';
-     * const proxy = WorkflowService.proxyActivities<typeof activities>({ activities });
-     *
-     * //or destructure the proxy object, as the function names are the keys
-     * const { activity1, activity2 } = WorkflowService.proxyActivities<typeof activities>({ activities });
-     */
     static proxyActivities(options) {
         if (options.activities) {
             worker_1.WorkerService.registerActivities(options.activities);
@@ -237,13 +170,10 @@ class WorkflowService {
     }
     static wrapActivity(activityName, options) {
         return async function () {
-            //SYNC
-            //check if the activity already ran
             const [didRun, execIndex, result] = await WorkflowService.didRun('proxy');
             if (didRun) {
                 if (result?.$error) {
                     if (options?.retryPolicy?.throwOnError !== false) {
-                        //rethrow remote execution error (simulates throw)
                         const code = result.$error.code;
                         const message = result.$error.message;
                         const stack = result.$error.stack;
@@ -261,25 +191,17 @@ class WorkflowService {
                 }
                 return result.data;
             }
-            //package the interruption inputs
             const context = WorkflowService.getContext();
             const { interruptionRegistry } = context;
             const interruptionMessage = WorkflowService.getProxyInterruptPayload(context, activityName, execIndex, Array.from(arguments), options);
-            //push the packaged inputs to the registry
             interruptionRegistry.push({
                 code: enums_1.HMSH_CODE_DURABLE_PROXY,
                 ...interruptionMessage,
             });
-            //ASYNC
-            //sleep (allow others to be packaged / registered) and throw the error
             await (0, utils_1.sleepFor)(0);
             throw new errors_1.DurableProxyError(interruptionMessage);
         };
     }
-    /**
-      * constructs the payload necessary to spawn a proxyActivity job
-      * @private
-      */
     static getProxyInterruptPayload(context, activityName, execIndex, args, options) {
         const { workflowDimension, workflowId, originJobId, workflowTopic } = context;
         const activityTopic = `${workflowTopic}-activity`;
@@ -302,11 +224,6 @@ class WorkflowService {
             maximumInterval: maximumInterval ?? undefined,
         };
     }
-    /**
-     * Returns a search session for use when reading/writing to the workflow HASH.
-     * The search session provides access to methods like `get`, `mget`, `set`, `del`, and `incr`.
-     * @returns {Promise<Search>} - a search session
-     */
     static async search() {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowId = store.get('workflowId');
@@ -316,29 +233,15 @@ class WorkflowService {
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
-        //this ID is used as a item key with a hash (dash prefix ensures no collision)
         const searchSessionId = `-search${workflowDimension}-${execIndex}`;
         return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
     }
-    /**
-     * Returns a random number between 0 and 1. This number is deterministic
-     * and will never vary for a given seed. This is useful for randomizing
-     * pathways in a workflow that can be safely replayed.
-     * @returns {number} - a random number between 0 and 1
-     */
     static random() {
         const store = storage_1.asyncLocalStorage.getStore();
         const COUNTER = store.get('counter');
         const seed = COUNTER.counter = COUNTER.counter + 1;
         return (0, utils_1.deterministicRandom)(seed);
     }
-    /**
-     * Sends signal data into any other paused thread (which is currently
-     * awaiting the signal)
-     * @param {string} signalId - the signal id
-     * @param {Record<any, any>} data - the signal data
-     * @returns {Promise<string>} - the stream id
-     */
     static async signal(signalId, data) {
         const store = storage_1.asyncLocalStorage.getStore();
         const workflowTopic = store.get('workflowTopic');
@@ -348,12 +251,6 @@ class WorkflowService {
             return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
         }
     }
-    /**
-     * Spawns a hook from either the main thread or a hook thread with
-     * the provided options; worflowId/TaskQueue/Name are optional and will
-     * default to the current workflowId/WorkflowTopic if not provided
-     * @param {HookOptions} options - the hook options
-     */
     static async hook(options) {
         const { workflowId, namespace, workflowTopic, } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
@@ -375,13 +272,6 @@ class WorkflowService {
             return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
         }
     }
-    /**
-     * 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 cost and safety provided by proxyActivities.
-     * @template T - the result type
-     */
     static async once(fn, ...args) {
         const { COUNTER, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
@@ -406,9 +296,6 @@ class WorkflowService {
         await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, serializer_1.SerializerService.toString(payload));
         return response;
     }
-    /**
-     * Interrupts a running job
-     */
     static async interrupt(jobId, options = {}) {
         const { workflowTopic, namespace } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
@@ -416,21 +303,11 @@ class WorkflowService {
             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
-     * until the sleep command and then resume execution thereafter.
-     * @param {string} duration - See the `ms` package for syntax examples: '1 minute', '2 hours', '3 days'
-     * @returns {Promise<number>} - resolved duration in seconds
-     */
     static async sleepFor(duration) {
-        //SYNC
-        //return early if this sleep command has already run
         const [didRun, execIndex, result] = await WorkflowService.didRun('sleep');
         if (didRun) {
-            return result.duration; //in seconds
+            return result.duration;
         }
-        //package the interruption inputs
         const store = storage_1.asyncLocalStorage.getStore();
         const interruptionRegistry = store.get('interruptionRegistry');
         const workflowId = store.get('workflowId');
@@ -445,28 +322,14 @@ class WorkflowService {
             code: enums_1.HMSH_CODE_DURABLE_SLEEP,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep to allow other interruptions to be packaged and registered
         await (0, utils_1.sleepFor)(0);
-        // NOTE: If you are reading this in the stack trace, await `sleepFor`
         throw new errors_1.DurableSleepError(interruptionMessage);
     }
-    /**
-     * Pauses the workflow until `signalId` is received.
-     * @template T - the result type
-     * @param {string} signalId - a unique, shareable guid (e.g, 'abc123')
-     * @returns {Promise<T>}
-     * @example
-     * const result = await Durable.workflow.waitFor<typeof resultType>('abc123');
-     */
     static async waitFor(signalId) {
-        //SYNC
-        //return early if this waitFor command has already run
         const [didRun, execIndex, result] = await WorkflowService.didRun('wait');
         if (didRun) {
             return result.data.data;
         }
-        //package the interruption inputs
         const store = storage_1.asyncLocalStorage.getStore();
         const interruptionRegistry = store.get('interruptionRegistry');
         const workflowId = store.get('workflowId');
@@ -481,10 +344,7 @@ class WorkflowService {
             code: enums_1.HMSH_CODE_DURABLE_WAIT,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep to allow other interruptions to be packaged and registered
         await (0, utils_1.sleepFor)(0);
-        // NOTE: If you are reading this in the stack trace, await `waitFor`
         throw new errors_1.DurableWaitForError(interruptionMessage);
     }
 }

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

@@ -15,6 +15,7 @@ import { TaskService } from '../task';
 import { AppVID } from '../../types/app';
 import { ActivityType } from '../../types/activity';
 import { CacheMode } from '../../types/cache';
+import { JobExport } from '../../types/exporter';
 import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions, ExtensionType } from '../../types/job';
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
@@ -23,7 +24,6 @@ import { StringAnyType, StringStringType } from '../../types/serializer';
 import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
 import { WorkListTaskType } from '../../types/task';
-import { JobExport } from '../../types/exporter';
 declare class EngineService {
     namespace: string;
     apps: HotMeshApps | null;
@@ -86,11 +86,6 @@ declare class EngineService {
     delistJobCallback(jobId: string): void;
     hasOneTimeSubscription(context: JobState): boolean;
     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;
     export(jobId: string): Promise<JobExport>;
     getRaw(jobId: string): Promise<StringStringType>;