@hotmeshio/hotmesh 0.1.15 → 0.1.16

package/build/services/{durable → meshflow}/worker.js

@@ -15,6 +15,7 @@ const stream_1 = require("../../types/stream");
 const search_1 = require("./search");
 const factory_1 = require("./schemas/factory");
 class WorkerService {
+    constructor() { }
     static async activateWorkflow(hotMesh) {
         const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
         const appVersion = app?.version;
@@ -63,7 +64,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);
@@ -95,7 +95,8 @@ class WorkerService {
         const targetNamespace = config?.namespace ?? factory_1.APP_ID;
         const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
         const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
-        const hotMeshWorker = await hotmesh_1.HotMeshService.init({
+        const hotMeshWorker = await hotmesh_1.HotMesh.init({
+            guid: config.guid ? `${config.guid}XA` : undefined,
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: targetNamespace,
             engine: { redis: redisConfig },
@@ -113,7 +114,6 @@ class WorkerService {
     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];
@@ -130,14 +130,12 @@ class WorkerService {
                     message: err.message,
                     stack: err.stack,
                 });
-                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)
+                if (!(err instanceof errors_1.MeshFlowTimeoutError) &&
+                    !(err instanceof errors_1.MeshFlowMaxedError) &&
+                    !(err instanceof errors_1.MeshFlowFatalError)) {
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
+                        code: enums_1.HMSH_CODE_MESHFLOW_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
                             $error: {
@@ -149,8 +147,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,
@@ -175,7 +171,8 @@ class WorkerService {
         const targetNamespace = config?.namespace ?? factory_1.APP_ID;
         const optionsHash = (0, utils_1.hashOptions)(config?.connection?.options);
         const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
-        const hotMeshWorker = await hotmesh_1.HotMeshService.init({
+        const hotMeshWorker = await hotmesh_1.HotMesh.init({
+            guid: config.guid,
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
             engine: { redis: redisConfig },
@@ -196,7 +193,6 @@ class WorkerService {
             const interruptionRegistry = [];
             let isProcessing = false;
             try {
-                //incoming data payload has arguments and workflowId
                 const workflowInput = data.data;
                 const context = new Map();
                 context.set('canRetry', workflowInput.canRetry);
@@ -207,20 +203,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);
@@ -230,7 +220,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);
                 });
@@ -245,20 +235,19 @@ class WorkerService {
                 if (isProcessing) {
                     return;
                 }
-                if (err instanceof errors_1.DurableWaitForError ||
+                if (err instanceof errors_1.MeshFlowWaitForError ||
                     interruptionRegistry.length > 1) {
                     isProcessing = true;
-                    //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
                     const workflowInput = data.data;
                     const execIndex = counter.counter - interruptionRegistry.length + 1;
                     const { workflowId, workflowTopic, workflowDimension, originJobId } = workflowInput;
                     const collatorFlowId = `${(0, utils_1.guid)()}$C`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_DURABLE_ALL,
+                        code: enums_1.HMSH_CODE_MESHFLOW_ALL,
                         metadata: { ...data.metadata },
                         data: {
-                            code: enums_1.HMSH_CODE_DURABLE_ALL,
+                            code: enums_1.HMSH_CODE_MESHFLOW_ALL,
                             items: [...interruptionRegistry],
                             size: interruptionRegistry.length,
                             workflowDimension: workflowDimension || '',
@@ -270,8 +259,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.DurableSleepError) {
-                    //return the sleep interruption
+                else if (err instanceof errors_1.MeshFlowSleepError) {
                     isProcessing = true;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
@@ -290,8 +278,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.DurableProxyError) {
-                    //return the proxyActivity interruption
+                else if (err instanceof errors_1.MeshFlowProxyError) {
                     isProcessing = true;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
@@ -320,8 +307,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.DurableChildError) {
-                    //return the child interruption
+                else if (err instanceof errors_1.MeshFlowChildError) {
                     isProcessing = true;
                     const msg = {
                         message: err.message,
@@ -335,12 +321,12 @@ class WorkerService {
                         data: {
                             arguments: err.arguments,
                             await: err.await,
-                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
                             code: err.code,
                             index: err.index,
                             message: JSON.stringify(msg),
-                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
-                            maximumInterval: err.maximumInterval || (0, ms_1.default)(enums_1.HMSH_DURABLE_MAX_INTERVAL) / 1000,
+                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+                            maximumInterval: err.maximumInterval || (0, ms_1.default)(enums_1.HMSH_MESHFLOW_MAX_INTERVAL) / 1000,
                             originJobId: err.originJobId,
                             parentWorkflowId: err.parentWorkflowId,
                             expire: err.expire,
@@ -351,12 +337,10 @@ class WorkerService {
                         },
                     };
                 }
-                // ALL other errors are actual fatal errors (598, 597, 596)
-                //  OR will be retried (599)
                 isProcessing = true;
                 return {
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.DurableRetryError(err.message).code,
+                    code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -364,7 +348,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.DurableRetryError(err.message).code,
+                            code: err.code || new errors_1.MeshFlowRetryError(err.message).code,
                         },
                     },
                 };
@@ -378,7 +362,7 @@ class WorkerService {
     }
 }
 _a = WorkerService;
-WorkerService.activityRegistry = {}; //user's activities
+WorkerService.activityRegistry = {};
 WorkerService.instances = new Map();
 WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     const targetNamespace = config?.namespace ?? factory_1.APP_ID;
@@ -387,7 +371,7 @@ WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     if (WorkerService.instances.has(targetTopic)) {
         return await WorkerService.instances.get(targetTopic);
     }
-    const hotMeshClient = hotmesh_1.HotMeshService.init({
+    const hotMeshClient = hotmesh_1.HotMesh.init({
         logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
         appId: targetNamespace,
         engine: {

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

@@ -0,0 +1,27 @@
+import { HotMesh } from '../hotmesh';
+import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOptions } from '../../types/meshflow';
+import { JobInterruptOptions } from '../../types/job';
+import { MeshFlowChildErrorType, MeshFlowProxyErrorType } from '../../types/error';
+import { Search } from './search';
+export declare class WorkflowService {
+    constructor();
+    static didRun(prefix: string): Promise<[boolean, number, any]>;
+    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
+    static getContext(): WorkflowContext;
+    static getHotMesh(): Promise<HotMesh>;
+    static execChild<T>(options: WorkflowOptions): Promise<T>;
+    static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): MeshFlowChildErrorType;
+    static startChild(options: WorkflowOptions): Promise<string>;
+    static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
+    static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
+    static getProxyInterruptPayload(context: WorkflowContext, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): MeshFlowProxyErrorType;
+    static search(): Promise<Search>;
+    static random(): number;
+    static signal(signalId: string, data: Record<any, any>): Promise<string>;
+    static hook(options: HookOptions): Promise<string>;
+    static once<T>(fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T>;
+    static interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;
+    static all<T>(...promises: Promise<T>[]): Promise<T[]>;
+    static sleepFor(duration: string): Promise<number>;
+    static waitFor<T>(signalId: string): Promise<T>;
+}

package/build/services/{durable → meshflow}/workflow.js

@@ -15,13 +15,7 @@ const enums_1 = require("../../modules/enums");
 const worker_1 = require("./worker");
 const search_1 = require("./search");
 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
-     */
+    constructor() { }
     static async didRun(prefix) {
         const { COUNTER, replay, workflowDimension } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
@@ -32,12 +26,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 +45,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');
@@ -95,10 +79,6 @@ 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');
@@ -106,17 +86,7 @@ class WorkflowService {
         const namespace = store.get('namespace');
         return await worker_1.WorkerService.getHotMesh(workflowTopic, { connection, 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);
@@ -127,21 +97,20 @@ class WorkflowService {
                 (!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);
+                    if (code === enums_1.HMSH_CODE_MESHFLOW_FATAL) {
+                        throw new errors_1.MeshFlowFatalError(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_MESHFLOW_MAXED) {
+                        throw new errors_1.MeshFlowMaxedError(message, stack);
                     }
-                    else if (code == enums_1.HMSH_CODE_DURABLE_TIMEOUT) {
-                        throw new errors_1.DurableTimeoutError(message, stack);
+                    else if (code == enums_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
+                        throw new errors_1.MeshFlowTimeoutError(message, stack);
                     }
                     else {
-                        throw new errors_1.DurableRetryError(message, stack);
+                        throw new errors_1.MeshFlowRetryError(message, stack);
                     }
                 }
                 return result.$error;
@@ -151,20 +120,13 @@ class WorkflowService {
             }
         }
         const interruptionMessage = WorkflowService.getChildInterruptPayload(context, options, execIndex);
-        //push the packaged inputs to the registry
         interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_DURABLE_CHILD,
+            code: enums_1.HMSH_CODE_MESHFLOW_CHILD,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep (allow others to be packaged / registered) and throw the error
         await (0, utils_1.sleepImmediate)();
-        throw new errors_1.DurableChildError(interruptionMessage);
+        throw new errors_1.MeshFlowChildError(interruptionMessage);
     }
-    /**
-     * constructs the payload necessary to spawn a child job
-     * @private
-     */
     static getChildInterruptPayload(context, options, execIndex) {
         const { workflowId, originJobId, workflowDimension } = context;
         let childJobId;
@@ -184,10 +146,10 @@ class WorkflowService {
         return {
             arguments: [...(options.args || [])],
             await: options?.await ?? true,
-            backoffCoefficient: options?.config?.backoffCoefficient ?? enums_1.HMSH_DURABLE_EXP_BACKOFF,
+            backoffCoefficient: options?.config?.backoffCoefficient ?? enums_1.HMSH_MESHFLOW_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) /
+            maximumAttempts: options?.config?.maximumAttempts ?? enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
+            maximumInterval: (0, ms_1.default)(options?.config?.maximumInterval ?? enums_1.HMSH_MESHFLOW_MAX_INTERVAL) /
                 1000,
             originJobId: originJobId ?? workflowId,
             expire: options.expire,
@@ -198,37 +160,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 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);
@@ -245,49 +179,38 @@ 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;
-                        if (code === enums_1.HMSH_CODE_DURABLE_FATAL) {
-                            throw new errors_1.DurableFatalError(message, stack);
+                        if (code === enums_1.HMSH_CODE_MESHFLOW_FATAL) {
+                            throw new errors_1.MeshFlowFatalError(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_MESHFLOW_MAXED) {
+                            throw new errors_1.MeshFlowMaxedError(message, stack);
                         }
-                        else if (code == enums_1.HMSH_CODE_DURABLE_TIMEOUT) {
-                            throw new errors_1.DurableTimeoutError(message, stack);
+                        else if (code == enums_1.HMSH_CODE_MESHFLOW_TIMEOUT) {
+                            throw new errors_1.MeshFlowTimeoutError(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,
+                code: enums_1.HMSH_CODE_MESHFLOW_PROXY,
                 ...interruptionMessage,
             });
-            //ASYNC
-            //sleep (allow others to be packaged / registered) and throw the error
             await (0, utils_1.sleepImmediate)();
-            throw new errors_1.DurableProxyError(interruptionMessage);
+            throw new errors_1.MeshFlowProxyError(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`;
@@ -311,11 +234,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');
@@ -329,29 +247,15 @@ class WorkflowService {
             connection,
             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');
@@ -368,12 +272,6 @@ class WorkflowService {
             });
         }
     }
-    /**
-     * 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, connection, namespace, workflowTopic } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
@@ -393,18 +291,11 @@ class WorkflowService {
                 arguments: [...options.args],
                 id: targetWorkflowId,
                 workflowTopic,
-                backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MESHFLOW_EXP_BACKOFF,
             };
             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, connection, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
@@ -432,9 +323,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, connection, namespace, } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
@@ -445,28 +333,15 @@ class WorkflowService {
             return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
         }
     }
-    /**
-     * Promise.all (limited to 25 total concurrent workflow)
-     */
     static async all(...promises) {
         await new Promise((resolve) => setTimeout(resolve, 1));
         return await Promise.all(promises);
     }
-    /**
-     * 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');
@@ -478,31 +353,17 @@ class WorkflowService {
             workflowDimension,
         };
         interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_DURABLE_SLEEP,
+            code: enums_1.HMSH_CODE_MESHFLOW_SLEEP,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep to allow other interruptions to be packaged and registered
         await (0, utils_1.sleepImmediate)();
-        // NOTE: If you are reading this in the stack trace, await `sleepFor`
-        throw new errors_1.DurableSleepError(interruptionMessage);
+        throw new errors_1.MeshFlowSleepError(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');
@@ -514,14 +375,11 @@ class WorkflowService {
             workflowDimension,
         };
         interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_DURABLE_WAIT,
+            code: enums_1.HMSH_CODE_MESHFLOW_WAIT,
             ...interruptionMessage,
         });
-        //ASYNC
-        //sleep to allow other interruptions to be packaged and registered
         await (0, utils_1.sleepImmediate)();
-        // NOTE: If you are reading this in the stack trace, await `waitFor`
-        throw new errors_1.DurableWaitForError(interruptionMessage);
+        throw new errors_1.MeshFlowWaitForError(interruptionMessage);
     }
 }
 exports.WorkflowService = WorkflowService;

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

@@ -1,12 +1,5 @@
 type DateInput = Date | string | number;
 declare class DateHandler {
-    /**
-     * It is so common in mapping operations to use a string (ISO) date as input. This helper
-     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
-     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
-     * @param input
-     * @returns
-     */
     static getDateInstance(input: DateInput): Date;
     fromISOString(isoString: string): Date;
     now(): number;

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

@@ -3,13 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateHandler = void 0;
 const utils_1 = require("../../../modules/utils");
 class DateHandler {
-    /**
-     * It is so common in mapping operations to use a string (ISO) date as input. This helper
-     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
-     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
-     * @param input
-     * @returns
-     */
     static getDateInstance(input) {
         const ISO_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/;
         if (typeof input === 'string') {