@hotmeshio/hotmesh 0.0.52 → 0.0.54

package/build/services/durable/workflow.js

@@ -8,117 +8,211 @@ const ms_1 = __importDefault(require("ms"));
 const errors_1 = require("../../modules/errors");
 const key_1 = require("../../modules/key");
 const storage_1 = require("../../modules/storage");
-const client_1 = require("./client");
-const connection_1 = require("./connection");
-const factory_1 = require("./factory");
+const utils_1 = require("../../modules/utils");
 const search_1 = require("./search");
 const worker_1 = require("./worker");
+const serializer_1 = require("../serializer");
 const stream_1 = require("../../types/stream");
-const utils_1 = require("../../modules/utils");
+const enums_1 = require("../../modules/enums");
 class WorkflowService {
     /**
-     * Spawns a child workflow. await and return the result.
-     * @template T - the result type
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<T>} - the result of the child workflow
+     * 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;
+        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+        if (sessionId in replay) {
+            const restored = serializer_1.SerializerService.fromString(replay[sessionId]);
+            return [true, execIndex, restored];
+        }
+        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 executeChild(options) {
+    static async isSideEffectAllowed(hotMeshClient, prefix) {
         const store = storage_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');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        //NOTE: this is the hash prefix; necessary for the search index to locate the entity
-        //if the hash is a helper, a dash begins it, so it isn't indexed
-        const entityOrEmptyString = options.entity ?? '';
-        //If the workflowId is not provided, it is generated from the entity and the workflow name
-        const childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
-        const parentWorkflowId = workflowId;
-        const client = new client_1.ClientService({
-            connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
-        });
-        let handle = await client.workflow.getHandle(options.entity ?? options.taskQueue, options.entity ?? options.workflowName, childJobId, namespace);
-        try {
-            return await handle.result(true);
-        }
-        catch (error) {
-            handle = await client.workflow.start({
-                ...options,
-                namespace,
-                workflowId: childJobId,
-                originJobId: originJobId ?? workflowId,
-                parentWorkflowId,
-                workflowTrace,
-                workflowSpan,
-            });
-            //todo: options.startToCloseTimeout
-            const result = await handle.result();
-            return result;
+        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+        const replay = store.get('replay');
+        if (sessionId in replay) {
+            return false;
         }
+        const keyParams = {
+            appId: hotMeshClient.appId,
+            jobId: workflowId
+        };
+        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
+        return guidValue === 1;
     }
     /**
-     * Spawns a child workflow. return the childJobId.
-     * This method is used when the result of the child workflow is not needed.
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<string>} - the childJobId
+     * Returns the current workflow context restored
+     * from Redis
      */
-    static async startChild(options) {
+    static getContext() {
         const store = storage_1.asyncLocalStorage.getStore();
-        const namespace = store.get('namespace');
         const workflowId = store.get('workflowId');
+        const replay = store.get('replay');
+        const cursor = store.get('cursor');
+        const interruptionRegistry = store.get('interruptionRegistry');
         const workflowDimension = store.get('workflowDimension') ?? '';
+        const workflowTopic = store.get('workflowTopic');
+        const namespace = store.get('namespace');
+        const originJobId = store.get('originJobId');
         const workflowTrace = store.get('workflowTrace');
+        const canRetry = store.get('canRetry');
         const workflowSpan = store.get('workflowSpan');
         const COUNTER = store.get('counter');
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-start${workflowDimension}-${execIndex}-`;
-        const replay = store.get('replay');
-        if (sessionId in replay) {
-            return replay[sessionId];
+        const raw = store.get('raw');
+        return {
+            canRetry,
+            COUNTER,
+            counter: COUNTER.counter,
+            cursor,
+            interruptionRegistry,
+            namespace,
+            originJobId,
+            raw,
+            replay,
+            workflowId,
+            workflowDimension,
+            workflowTopic,
+            workflowTrace,
+            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 { 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;
+                    if (code === enums_1.HMSH_CODE_DURABLE_FATAL) {
+                        throw new errors_1.DurableFatalError(message, stack);
+                    }
+                    else if (code == enums_1.HMSH_CODE_DURABLE_MAXED) {
+                        throw new errors_1.DurableMaxedError(message, stack);
+                    }
+                    else if (code == enums_1.HMSH_CODE_DURABLE_TIMEOUT) {
+                        throw new errors_1.DurableTimeoutError(message, stack);
+                    }
+                    else {
+                        throw new errors_1.DurableRetryError(message, stack);
+                    }
+                }
+                return result.$error;
+            }
+            else if (result.data) {
+                return result.data;
+            }
         }
-        //NOTE: this is the hash prefix; necessary for the search index to locate the entity
-        const entityOrEmptyString = options.entity ?? '';
-        //If the workflowId is not provided, it is generated from the entity and the workflow name
-        const parentWorkflowId = workflowId;
-        const workflowTopic = `${options.entity ?? options.taskQueue}-${options.entity ?? options.workflowName}`;
-        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);
-        let childJobId = await hotMeshClient.engine.store.exec('HGET', workflowGuid, sessionId);
-        if (childJobId) {
-            return childJobId;
+        const interruptionMessage = this.getChildInterruptPayload(context, options, execIndex);
+        //push the packaged inputs to the registry
+        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;
+        if (options.workflowId) {
+            childJobId = options.workflowId;
+        }
+        else if (options.entity) {
+            childJobId = `${options.entity}-${workflowId.substring(0, 7)}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
         }
         else {
-            childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
+            childJobId = `-${options.workflowName}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
         }
-        const client = new client_1.ClientService({
-            connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
-        });
-        await client.workflow.start({
-            ...options,
-            namespace,
-            workflowId: childJobId,
+        const parentWorkflowId = workflowId;
+        const taskQueueName = options.entity ?? options.taskQueue;
+        const workflowName = options.entity ?? options.workflowName;
+        const workflowTopic = `${taskQueueName}-${workflowName}`;
+        return {
+            arguments: [...(options.args || [])],
+            await: options?.await ?? true,
+            backoffCoefficient: options?.config?.backoffCoefficient ?? enums_1.HMSH_DURABLE_EXP_BACKOFF,
+            index: execIndex,
+            maximumAttempts: options?.config?.maximumAttempts ?? enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+            maximumInterval: (0, ms_1.default)(options?.config?.maximumInterval ?? enums_1.HMSH_DURABLE_MAX_INTERVAL) / 1000,
+            originJobId: originJobId ?? workflowId,
             parentWorkflowId,
-            workflowTrace,
-            workflowSpan,
-        });
-        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, childJobId);
-        return childJobId;
+            workflowDimension: workflowDimension,
+            workflowId: childJobId,
+            workflowTopic,
+        };
     }
     /**
-     * Wraps activities in a proxy that will durably run them
-     * @param {ActivityConfig} options - the activity configuration
-     * that will be used to wrap the activities. You must pass an
-     * `activities` object to this configuration. The activities object
-     * should be a key-value pair of activity names and their respective
-     * functions. This is typically done by importing the activities.
+     * 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 });
+    }
+    /**
+     * 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';
@@ -141,6 +235,73 @@ class WorkflowService {
         }
         return proxy;
     }
+    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;
+                        if (code === enums_1.HMSH_CODE_DURABLE_FATAL) {
+                            throw new errors_1.DurableFatalError(message, stack);
+                        }
+                        else if (code == enums_1.HMSH_CODE_DURABLE_MAXED) {
+                            throw new errors_1.DurableMaxedError(message, stack);
+                        }
+                        else if (code == enums_1.HMSH_CODE_DURABLE_TIMEOUT) {
+                            throw new errors_1.DurableTimeoutError(message, stack);
+                        }
+                    }
+                    return result.$error;
+                }
+                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`;
+        const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
+        let maximumInterval;
+        if (options.retryPolicy?.maximumInterval) {
+            maximumInterval = (0, ms_1.default)(options.retryPolicy.maximumInterval) / 1000;
+        }
+        return {
+            arguments: args,
+            workflowDimension: workflowDimension,
+            index: execIndex,
+            originJobId: originJobId || workflowId,
+            parentWorkflowId: workflowId,
+            workflowId: activityJobId,
+            workflowTopic: activityTopic,
+            activityName,
+            backoffCoefficient: options?.retryPolicy?.backoffCoefficient ?? undefined,
+            maximumAttempts: options?.retryPolicy?.maximumAttempts ?? undefined,
+            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`.
@@ -159,68 +320,6 @@ class WorkflowService {
         const searchSessionId = `-search${workflowDimension}-${execIndex}`;
         return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
     }
-    /**
-     * Return a handle to the hotmesh client currently running the workflow
-     * @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 });
-    }
-    /**
-     * Returns the current workflow context
-     * @returns {WorkflowContext} - the current workflow context
-     */
-    static getContext() {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowId = store.get('workflowId');
-        const replay = store.get('replay');
-        const cursor = store.get('cursor');
-        const workflowDimension = store.get('workflowDimension') ?? '';
-        const workflowTopic = store.get('workflowTopic');
-        const namespace = store.get('namespace');
-        const workflowTrace = store.get('workflowTrace');
-        const workflowSpan = store.get('workflowSpan');
-        const COUNTER = store.get('counter');
-        return {
-            counter: COUNTER.counter,
-            cursor,
-            namespace,
-            replay,
-            workflowId,
-            workflowDimension,
-            workflowTopic,
-            workflowTrace,
-            workflowSpan,
-        };
-    }
-    /**
-     * 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');
-        const workflowDimension = store.get('workflowDimension') ?? '';
-        const COUNTER = store.get('counter');
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
-        const replay = store.get('replay');
-        if (sessionId in replay) {
-            return false;
-        }
-        const keyParams = {
-            appId: hotMeshClient.appId,
-            jobId: workflowId
-        };
-        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
-        return guidValue === 1;
-    }
     /**
      * 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
@@ -234,8 +333,8 @@ class WorkflowService {
         return (0, utils_1.deterministicRandom)(seed);
     }
     /**
-     * Sends signal data into any other paused thread (which is paused and
-     * awaiting the signal) from within a hook-thread or the main-thread
+     * 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
@@ -245,8 +344,6 @@ class WorkflowService {
         const workflowTopic = store.get('workflowTopic');
         const namespace = store.get('namespace');
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
-        //todo: this particular one is better patterned as a get/set,
-        //since the receipt is a meaningful string (the stream id)
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
             return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
         }
@@ -258,50 +355,39 @@ class WorkflowService {
      * @param {HookOptions} options - the hook options
      */
     static async hook(options) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const namespace = store.get('namespace');
+        const { workflowId, namespace, workflowTopic, } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
-            const store = storage_1.asyncLocalStorage.getStore();
-            const workflowId = options.workflowId ?? store.get('workflowId');
-            let workflowTopic = store.get('workflowTopic');
+            const targetWorkflowId = options.workflowId ?? workflowId;
+            let targetTopic;
             if (options.entity || (options.taskQueue && options.workflowName)) {
-                workflowTopic = `${options.entity ?? options.taskQueue}-${options.entity ?? options.workflowName}`;
-            } //else this is essentially recursion as the function calls itself
+                targetTopic = `${options.entity ?? options.taskQueue}-${options.entity ?? options.workflowName}`;
+            }
+            else {
+                targetTopic = workflowTopic;
+            }
             const payload = {
                 arguments: [...options.args],
-                id: workflowId,
+                id: targetWorkflowId,
                 workflowTopic,
-                backoffCoefficient: options.config?.backoffCoefficient || factory_1.DEFAULT_COEFFICIENT,
+                backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
             };
             return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
         }
     }
-    static getLocalState() {
-        const store = storage_1.asyncLocalStorage.getStore();
-        return {
-            workflowId: store.get('workflowId'),
-            namespace: store.get('namespace'),
-            workflowTopic: store.get('workflowTopic'),
-            workflowDimension: store.get('workflowDimension') ?? '',
-            counter: store.get('counter'),
-            replay: store.get('replay'),
-        };
-    }
     /**
      * 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.
+     * not require the cost and safety provided by proxyActivities.
      * @template T - the result type
      */
     static async once(fn, ...args) {
-        const { workflowId, namespace, workflowTopic, workflowDimension, counter: COUNTER, replay, } = WorkflowService.getLocalState();
+        const { COUNTER, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const sessionId = `-once${workflowDimension}-${execIndex}-`;
         if (sessionId in replay) {
-            return JSON.parse(replay[sessionId]);
+            return serializer_1.SerializerService.fromString(replay[sessionId]).data;
         }
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         const keyParams = {
@@ -309,25 +395,22 @@ class WorkflowService {
             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 t1 = new Date();
         const response = await fn(...args);
-        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, JSON.stringify(response));
+        const t2 = new Date();
+        const payload = {
+            data: response,
+            ac: (0, utils_1.formatISODate)(t1),
+            au: (0, utils_1.formatISODate)(t2),
+        };
+        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, serializer_1.SerializerService.toString(payload));
         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 = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const namespace = store.get('namespace');
+        const { workflowTopic, namespace } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {
             return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
@@ -336,140 +419,73 @@ class WorkflowService {
     /**
      * 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 from that point.
-     * @param {string} duration - for example: '1 minute', '2 hours', '3 days'
-     * @returns {Promise<number>}
+     * 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) {
-        const seconds = (0, ms_1.default)(duration) / 1000;
-        const store = storage_1.asyncLocalStorage.getStore();
-        const namespace = store.get('namespace');
-        const workflowTopic = store.get('workflowTopic');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
-        if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'sleep')) {
-            const workflowId = store.get('workflowId');
-            const workflowDimension = store.get('workflowDimension') ?? '';
-            const COUNTER = store.get('counter');
-            const execIndex = COUNTER.counter;
-            // spawn a new sleep job if error code 592 is thrown by the worker
-            // NOTE: If this message appears in the stack trace, the `.sleepFor()` method in your workflow code was NOT awaited.
-            throw new errors_1.DurableSleepForError(workflowId, seconds, execIndex, workflowDimension);
+        //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 seconds;
+        //package the interruption inputs
+        const store = storage_1.asyncLocalStorage.getStore();
+        const interruptionRegistry = store.get('interruptionRegistry');
+        const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const interruptionMessage = {
+            workflowId,
+            duration: (0, ms_1.default)(duration) / 1000,
+            index: execIndex,
+            workflowDimension,
+        };
+        interruptionRegistry.push({
+            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);
     }
     /**
-     * Waits for a signal to awaken
-     * @param {string[]} signals - the signals to wait for
-     * @param {Record<string, string>} options - the options
-     * @returns {Promise<Record<any, any>[]>}
+     * 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 waitForSignal(signals, options) {
+    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 COUNTER = store.get('counter');
+        const interruptionRegistry = store.get('interruptionRegistry');
         const workflowId = store.get('workflowId');
-        const workflowTopic = store.get('workflowTopic');
         const workflowDimension = store.get('workflowDimension') ?? '';
-        const namespace = store.get('namespace');
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
-        //iterate the list of signals and check for done
-        let allAreComplete = true;
-        let noneAreComplete = false;
-        const signalResults = [];
-        for (const signal of signals) {
-            const execIndex = COUNTER.counter = COUNTER.counter + 1;
-            const wfsJobId = `-${workflowId}-$wfs${workflowDimension}-${execIndex}`;
-            try {
-                if (allAreComplete) {
-                    const state = await hotMeshClient.getState(`${hotMeshClient.appId}.wfs.execute`, wfsJobId);
-                    if (state.data?.signalData) {
-                        //user data is nested to isolate from the signal id; unpackage it
-                        const signalData = state.data.signalData;
-                        signalResults.push(signalData.data);
-                    }
-                    else {
-                        allAreComplete = false;
-                    }
-                }
-                else {
-                    signalResults.push({ signal, index: execIndex });
-                }
-            }
-            catch (err) {
-                //todo: options.startToCloseTimeout
-                allAreComplete = false;
-                noneAreComplete = true;
-                signalResults.push({ signal, index: execIndex });
-            }
-        }
-        ;
-        if (allAreComplete) {
-            return signalResults;
-        }
-        else if (noneAreComplete) {
-            //this error is caught by the workflow runner
-            //it is then returned as the workflow result (594)
-            throw new errors_1.DurableWaitForSignalError(workflowId, signalResults);
-        }
-        else {
-            //this error happens when a signal is received but others are still open
-            throw new errors_1.DurableIncompleteSignalError(workflowId);
-        }
-    }
-    static wrapActivity(activityName, options) {
-        return async function () {
-            const store = storage_1.asyncLocalStorage.getStore();
-            const COUNTER = store.get('counter');
-            //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');
-            const spn = store.get('workflowSpan');
-            const namespace = store.get('namespace');
-            const activityTopic = `${workflowTopic}-activity`;
-            const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
-            let activityState;
-            try {
-                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic, { namespace });
-                activityState = await hotMeshClient.getState(`${hotMeshClient.appId}.activity.execute`, activityJobId);
-                if (activityState.metadata.err) {
-                    await hotMeshClient.scrub(activityJobId);
-                    throw new Error(activityState.metadata.err);
-                }
-                else if (activityState.metadata.js === 0 || activityState.data?.done) {
-                    return activityState.data?.response;
-                }
-                //one time subscription
-                return await new Promise((resolve, reject) => {
-                    hotMeshClient.sub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`, async (topic, message) => {
-                        const response = message.data?.response;
-                        hotMeshClient.unsub(`${hotMeshClient.appId}.activity.executed.${activityJobId}`);
-                        // Resolve the Promise when the callback is triggered with a message
-                        resolve(response);
-                    });
-                });
-            }
-            catch (e) {
-                //expected; thrown by `getState` when the job cannot be found
-                const duration = (0, ms_1.default)(options?.startToCloseTimeout || '1 minute');
-                const payload = {
-                    arguments: Array.from(arguments),
-                    //when the origin job is removed
-                    originJobId: originJobId ?? workflowId,
-                    parentWorkflowId: workflowId,
-                    workflowId: activityJobId,
-                    workflowTopic: activityTopic,
-                    activityName,
-                };
-                //start the job
-                const hotMeshClient = await worker_1.WorkerService.getHotMesh(activityTopic, { namespace });
-                const context = { metadata: { trc, spn }, data: {} };
-                const jobOutput = await hotMeshClient.pubsub(`${hotMeshClient.appId}.activity.execute`, payload, context, duration);
-                return jobOutput.data.response;
-            }
+        const interruptionMessage = {
+            workflowId,
+            signalId,
+            index: execIndex,
+            workflowDimension,
         };
+        interruptionRegistry.push({
+            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);
     }
 }
 exports.WorkflowService = WorkflowService;