@hotmeshio/hotmesh 0.0.51 → 0.0.53

package/README.md

@@ -109,15 +109,19 @@ HotMesh's *Durable* module is a TypeScript Library modeled after Temporal.io. If
     ```
 
 #### Workflow Extensions
-Redis governance delivers more than just reliability. Externalizing state fundamentally changes the execution profile for your functions, allowing you to design long-running, durable workflows. The `Durable` base class (shown in the examples above) provides additional methods for solving the most common state management challenges.
+Externalizing state fundamentally changes the execution profile for your functions, allowing you to design long-running, durable workflows. The `Durable` base class (shown in the examples above) provides additional methods for solving the most common state management challenges.
 
- - `waitForSignal` Pause your function and wait for external event(s) before continuing. The *waitForSignal* method will collate and cache the signals and only awaken your function once all signals have arrived.
-   ```javascript
-    const signals = [a, b] = await Durable.workflow.waitForSignal('sig1', 'sig2')` 
+ - `waitFor` Pause your function using your chosen signal key, and only awaken when the signal is received from the outide. Use a standard `Promise` to collate and cache the signals and only awaken your function once all signals have arrived.
+    ```javascript
+    const { waitFor } = Durable.workflow;
+    const [a, b] = await Promise.all([
+      waitFor<{payload: string}>('sig1'),
+      waitFor<number>('sig2')
+    ]);
     ```
- - `signal` Send a signal (and optional payload) to a paused function awaiting the signal.
+ - `signal` Send a signal (and payload) to a paused function awaiting the signal. Signals may also be sent from the outside to awaken a paused function.
     ```javascript
-      await Durable.workflow.signal('sig1', {payload: 'hi!'});
+    await Durable.workflow.signal('sig1', {payload: 'hi!'});
     ```
  - `hook` Redis governance converts your functions into 're-entrant processes'. Optionally use the *hook* method to spawn parallel execution threads to augment a running workflow.
     ```javascript
@@ -135,9 +139,9 @@ Redis governance delivers more than just reliability. Externalizing state fundam
     ```javascript
     const random = await Durable.workflow.random();
     ```
- - `executeChild` Call another durable function and await the response. *Design sophisticated, multi-process solutions by leveraging this command.*
+ - `execChild` Call another durable function and await the response. *Design sophisticated, multi-process solutions by leveraging this command.*
     ```javascript
-    const jobResponse = await Durable.workflow.executeChild({
+    const jobResponse = await Durable.workflow.execChild({
       workflowName: 'newsletter',
       taskQueue: 'default',
       args: [{ id, user_id, etc }],
@@ -151,7 +155,7 @@ Redis governance delivers more than just reliability. Externalizing state fundam
       args: [{ id, user_id, etc }],
     });
     ```
- - `getContext` Get the current workflow context (workflowId, etc).
+ - `getContext` Get the current workflow context (workflowId, replay history, replay index, etc).
     ```javascript
     const context = await Durable.workflow.getContext();
     ```

package/build/index.d.ts

@@ -1,6 +1,5 @@
 import { Durable } from './services/durable';
-import { MeshOSService as MeshOS } from './services/durable/meshos';
 import { HotMeshService as HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
-export { Durable, HotMesh, HotMeshConfig, MeshOS };
+export { Durable, HotMesh, HotMeshConfig };
 export * as Types from './types';

package/build/index.js

@@ -23,11 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.MeshOS = exports.HotMesh = exports.Durable = void 0;
+exports.Types = exports.HotMesh = exports.Durable = void 0;
 const durable_1 = require("./services/durable");
 Object.defineProperty(exports, "Durable", { enumerable: true, get: function () { return durable_1.Durable; } });
-const meshos_1 = require("./services/durable/meshos");
-Object.defineProperty(exports, "MeshOS", { enumerable: true, get: function () { return meshos_1.MeshOSService; } });
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMeshService; } });
 exports.Types = __importStar(require("./types"));

package/build/modules/enums.d.ts

@@ -7,9 +7,11 @@ export declare const HMSH_CODE_INTERRUPT = 410;
 export declare const HMSH_CODE_UNKNOWN = 500;
 export declare const HMSH_CODE_TIMEOUT = 504;
 export declare const HMSH_CODE_UNACKED = 999;
-export declare const HMSH_CODE_DURABLE_SLEEPFOR = 592;
-export declare const HMSH_CODE_DURABLE_INCOMPLETE = 593;
-export declare const HMSH_CODE_DURABLE_WAITFOR = 594;
+export declare const HMSH_CODE_DURABLE_SLEEP = 588;
+export declare const HMSH_CODE_DURABLE_ALL = 589;
+export declare const HMSH_CODE_DURABLE_CHILD = 590;
+export declare const HMSH_CODE_DURABLE_PROXY = 591;
+export declare const HMSH_CODE_DURABLE_WAIT = 595;
 export declare const HMSH_CODE_DURABLE_TIMEOUT = 596;
 export declare const HMSH_CODE_DURABLE_MAXED = 597;
 export declare const HMSH_CODE_DURABLE_FATAL = 598;
@@ -23,6 +25,9 @@ export declare const HMSH_EXPIRE_JOB_SECONDS: number;
 export declare const HMSH_MAX_RETRIES: number;
 export declare const HMSH_MAX_TIMEOUT_MS: number;
 export declare const HMSH_GRADUATED_INTERVAL_MS: number;
+export declare const HMSH_DURABLE_MAX_ATTEMPTS = 3;
+export declare const HMSH_DURABLE_MAX_INTERVAL = "120s";
+export declare const HMSH_DURABLE_EXP_BACKOFF = 10;
 export declare const HMSH_BLOCK_TIME_MS: number;
 export declare const HMSH_XCLAIM_DELAY_MS: number;
 export declare const HMSH_XCLAIM_COUNT: number;

package/build/modules/enums.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_DURABLE_RETRYABLE = exports.HMSH_CODE_DURABLE_FATAL = exports.HMSH_CODE_DURABLE_MAXED = exports.HMSH_CODE_DURABLE_TIMEOUT = exports.HMSH_CODE_DURABLE_WAITFOR = exports.HMSH_CODE_DURABLE_INCOMPLETE = exports.HMSH_CODE_DURABLE_SLEEPFOR = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_LOGLEVEL = void 0;
+exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_DURABLE_EXP_BACKOFF = exports.HMSH_DURABLE_MAX_INTERVAL = exports.HMSH_DURABLE_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_DURABLE_RETRYABLE = exports.HMSH_CODE_DURABLE_FATAL = exports.HMSH_CODE_DURABLE_MAXED = exports.HMSH_CODE_DURABLE_TIMEOUT = exports.HMSH_CODE_DURABLE_WAIT = exports.HMSH_CODE_DURABLE_PROXY = exports.HMSH_CODE_DURABLE_CHILD = exports.HMSH_CODE_DURABLE_ALL = exports.HMSH_CODE_DURABLE_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_LOGLEVEL = void 0;
 // HOTMESH SYSTEM
 exports.HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL || 'info';
-// STATUS CODES AND MESSAGES
+// HOTMESH STATUS CODES
 exports.HMSH_CODE_SUCCESS = 200;
 exports.HMSH_CODE_PENDING = 202;
 exports.HMSH_CODE_NOTFOUND = 404;
@@ -11,13 +11,17 @@ exports.HMSH_CODE_INTERRUPT = 410;
 exports.HMSH_CODE_UNKNOWN = 500;
 exports.HMSH_CODE_TIMEOUT = 504;
 exports.HMSH_CODE_UNACKED = 999;
-exports.HMSH_CODE_DURABLE_SLEEPFOR = 592;
-exports.HMSH_CODE_DURABLE_INCOMPLETE = 593;
-exports.HMSH_CODE_DURABLE_WAITFOR = 594;
+// DURABLE STATUS CODES
+exports.HMSH_CODE_DURABLE_SLEEP = 588;
+exports.HMSH_CODE_DURABLE_ALL = 589;
+exports.HMSH_CODE_DURABLE_CHILD = 590;
+exports.HMSH_CODE_DURABLE_PROXY = 591;
+exports.HMSH_CODE_DURABLE_WAIT = 595;
 exports.HMSH_CODE_DURABLE_TIMEOUT = 596;
 exports.HMSH_CODE_DURABLE_MAXED = 597;
 exports.HMSH_CODE_DURABLE_FATAL = 598;
 exports.HMSH_CODE_DURABLE_RETRYABLE = 599;
+// HOTMESH MESSAGES
 exports.HMSH_STATUS_UNKNOWN = 'unknown';
 // QUORUM
 exports.HMSH_QUORUM_ROLLCALL_CYCLES = 12; //max iterations
@@ -30,8 +34,12 @@ exports.HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS,
 exports.HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
 exports.HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
 exports.HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
-const BASE_BLOCK_DURATION = 10000; // Modified for clarity
-const TEST_BLOCK_DURATION = 1000; // Modified for clarity
+// DURABLE
+exports.HMSH_DURABLE_MAX_ATTEMPTS = 3;
+exports.HMSH_DURABLE_MAX_INTERVAL = '120s';
+exports.HMSH_DURABLE_EXP_BACKOFF = 10;
+const BASE_BLOCK_DURATION = 10000;
+const TEST_BLOCK_DURATION = 1000;
 exports.HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS ? parseInt(process.env.HMSH_BLOCK_TIME_MS, 10) : (process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BASE_BLOCK_DURATION);
 exports.HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
 exports.HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
@@ -39,6 +47,6 @@ exports.HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 1
 // TASK WORKER
 exports.HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
 const BASE_FIDELITY_SECONDS = 5;
-const TEST_FIDELITY_SECONDS = 5;
+const TEST_FIDELITY_SECONDS = 1;
 exports.HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS ? parseInt(process.env.HMSH_FIDELITY_SECONDS, 10) : (process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS);
 exports.HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;

package/build/modules/errors.d.ts

@@ -8,43 +8,122 @@ declare class GetStateError extends Error {
 declare class SetStateError extends Error {
     constructor();
 }
-declare class DurableIncompleteSignalError extends Error {
+declare class DurableWaitForError extends Error {
     code: number;
-    constructor(message: string);
-}
-declare class DurableWaitForSignalError extends Error {
+    signalId: string;
+    workflowId: string;
+    index: number;
+    workflowDimension: string;
+    constructor(params: {
+        signalId: string;
+        index: number;
+        workflowDimension: string;
+        workflowId: string;
+    });
+}
+declare class DurableProxyError extends Error {
+    activityName: string;
+    arguments: string[];
+    backoffCoefficient: number;
     code: number;
-    signals: {
-        signal: string;
+    index: number;
+    maximumAttempts: number;
+    maximumInterval: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowDimension: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: {
+        arguments: string[];
+        activityName: string;
+        backoffCoefficient?: number;
         index: number;
-    }[];
-    constructor(message: string, signals: {
-        signal: string;
+        maximumAttempts?: number;
+        maximumInterval?: number;
+        originJobId: string | null;
+        parentWorkflowId: string;
+        workflowDimension: string;
+        workflowId: string;
+        workflowTopic: string;
+    });
+}
+declare class DurableChildError extends Error {
+    await: boolean;
+    arguments: string[];
+    backoffCoefficient: number;
+    code: number;
+    workflowDimension: string;
+    index: number;
+    maximumAttempts: number;
+    maximumInterval: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: {
+        arguments: string[];
+        await?: boolean;
+        backoffCoefficient?: number;
         index: number;
-    }[]);
+        maximumAttempts?: number;
+        maximumInterval?: number;
+        originJobId: string | null;
+        parentWorkflowId: string;
+        workflowDimension: string;
+        workflowId: string;
+        workflowTopic: string;
+    });
+}
+declare class DurableWaitForAllError extends Error {
+    items: any[];
+    code: number;
+    workflowDimension: string;
+    size: number;
+    index: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: {
+        items: string[];
+        workflowId: string;
+        workflowTopic: string;
+        parentWorkflowId: string;
+        originJobId: string | null;
+        size: number;
+        index: number;
+        workflowDimension: string;
+    });
 }
-declare class DurableSleepForError extends Error {
+declare class DurableSleepError extends Error {
+    workflowId: string;
     code: number;
     duration: number;
     index: number;
-    dimension: string;
-    constructor(message: string, duration: number, index: number, dimension: string);
+    workflowDimension: string;
+    constructor(params: {
+        duration: number;
+        index: number;
+        workflowDimension: string;
+        workflowId: string;
+    });
 }
 declare class DurableTimeoutError extends Error {
     code: number;
-    constructor(message: string);
+    constructor(message: string, stack?: string);
 }
 declare class DurableMaxedError extends Error {
     code: number;
-    constructor(message: string);
+    constructor(message: string, stackTrace?: string);
 }
 declare class DurableFatalError extends Error {
     code: number;
-    constructor(message: string);
+    constructor(message: string, stackTrace?: string);
 }
 declare class DurableRetryError extends Error {
     code: number;
-    constructor(message: string);
+    constructor(message: string, stackTrace?: string);
 }
 declare class MapDataError extends Error {
     constructor();
@@ -53,6 +132,7 @@ declare class RegisterTimeoutError extends Error {
     constructor();
 }
 declare class DuplicateJobError extends Error {
+    jobId: string;
     constructor(jobId: string);
 }
 declare class InactiveJobError extends Error {
@@ -79,4 +159,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DurableFatalError, DurableIncompleteSignalError, DurableMaxedError, DurableRetryError, DurableSleepForError, DurableTimeoutError, DurableWaitForSignalError, DuplicateJobError, ExecActivityError, GenerationalError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };
+export { CollationError, DurableChildError, DurableFatalError, DurableMaxedError, DurableProxyError, DurableRetryError, DurableSleepError, DurableTimeoutError, DurableWaitForAllError, DurableWaitForError, DuplicateJobError, ExecActivityError, GenerationalError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };

package/build/modules/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.GenerationalError = exports.ExecActivityError = exports.DuplicateJobError = exports.DurableWaitForSignalError = exports.DurableTimeoutError = exports.DurableSleepForError = exports.DurableRetryError = exports.DurableMaxedError = exports.DurableIncompleteSignalError = exports.DurableFatalError = exports.CollationError = void 0;
+exports.SetStateError = exports.RegisterTimeoutError = exports.MapDataError = exports.InactiveJobError = exports.GetStateError = exports.GenerationalError = exports.ExecActivityError = exports.DuplicateJobError = exports.DurableWaitForError = exports.DurableWaitForAllError = exports.DurableTimeoutError = exports.DurableSleepError = exports.DurableRetryError = exports.DurableProxyError = exports.DurableMaxedError = exports.DurableFatalError = exports.DurableChildError = exports.CollationError = void 0;
 const enums_1 = require("./enums");
 class GetStateError extends Error {
     constructor(jobId) {
@@ -16,58 +16,114 @@ class SetStateError extends Error {
     }
 }
 exports.SetStateError = SetStateError;
-//thrown when a signal set is incomplete but already configured
-//if a waitFor set has 'n' items, this can be thrown `n - 1` times
-class DurableIncompleteSignalError extends Error {
-    constructor(message) {
-        super(message);
-        this.code = enums_1.HMSH_CODE_DURABLE_INCOMPLETE;
-    }
-}
-exports.DurableIncompleteSignalError = DurableIncompleteSignalError;
-//the original waitFor error that is thrown for a new signal set
-class DurableWaitForSignalError extends Error {
-    constructor(message, signals) {
-        super(message);
-        this.signals = signals;
-        this.code = enums_1.HMSH_CODE_DURABLE_WAITFOR;
-    }
-}
-exports.DurableWaitForSignalError = DurableWaitForSignalError;
-class DurableSleepForError extends Error {
-    constructor(message, duration, index, dimension) {
-        super(message);
-        this.duration = duration;
-        this.index = index;
-        this.dimension = dimension;
-        this.code = enums_1.HMSH_CODE_DURABLE_SLEEPFOR;
-    }
-}
-exports.DurableSleepForError = DurableSleepForError;
+class DurableWaitForError extends Error {
+    constructor(params) {
+        super(`Durable WaitFor Error [${params.workflowId}]`);
+        this.signalId = params.signalId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_DURABLE_WAIT;
+    }
+}
+exports.DurableWaitForError = DurableWaitForError;
+class DurableProxyError extends Error {
+    constructor(params) {
+        super(`Durable Proxy Activity Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        this.arguments = params.arguments;
+        this.workflowId = params.workflowId;
+        this.workflowTopic = params.workflowTopic;
+        this.parentWorkflowId = params.parentWorkflowId;
+        this.originJobId = params.originJobId;
+        this.index = params.index;
+        this.activityName = params.activityName;
+        this.workflowDimension = params.workflowDimension;
+        this.backoffCoefficient = params.backoffCoefficient;
+        this.maximumAttempts = params.maximumAttempts;
+        this.maximumInterval = params.maximumInterval;
+        this.code = enums_1.HMSH_CODE_DURABLE_PROXY;
+    }
+}
+exports.DurableProxyError = DurableProxyError;
+class DurableChildError extends Error {
+    constructor(params) {
+        super(`Durable Child Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        this.arguments = params.arguments;
+        this.workflowId = params.workflowId;
+        this.workflowTopic = params.workflowTopic;
+        this.parentWorkflowId = params.parentWorkflowId;
+        this.originJobId = params.originJobId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_DURABLE_CHILD;
+        this.await = params.await;
+        this.backoffCoefficient = params.backoffCoefficient;
+        this.maximumAttempts = params.maximumAttempts;
+        this.maximumInterval = params.maximumInterval;
+    }
+}
+exports.DurableChildError = DurableChildError;
+class DurableWaitForAllError extends Error {
+    constructor(params) {
+        super(`Durable Wait for All Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        this.items = params.items;
+        this.size = params.size;
+        this.workflowId = params.workflowId;
+        this.workflowTopic = params.workflowTopic;
+        this.parentWorkflowId = params.parentWorkflowId;
+        this.originJobId = params.originJobId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_DURABLE_ALL;
+    }
+}
+exports.DurableWaitForAllError = DurableWaitForAllError;
+class DurableSleepError extends Error {
+    constructor(params) {
+        super(`Durable Sleep Error [${params.workflowId}]`);
+        this.duration = params.duration;
+        this.workflowId = params.workflowId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_DURABLE_SLEEP;
+    }
+}
+exports.DurableSleepError = DurableSleepError;
 class DurableTimeoutError extends Error {
-    constructor(message) {
+    constructor(message, stack) {
         super(message);
+        if (this.stack) {
+            this.stack = stack;
+        }
         this.code = enums_1.HMSH_CODE_DURABLE_TIMEOUT;
     }
 }
 exports.DurableTimeoutError = DurableTimeoutError;
 class DurableMaxedError extends Error {
-    constructor(message) {
+    constructor(message, stackTrace) {
         super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
         this.code = enums_1.HMSH_CODE_DURABLE_MAXED;
     }
 }
 exports.DurableMaxedError = DurableMaxedError;
 class DurableFatalError extends Error {
-    constructor(message) {
+    constructor(message, stackTrace) {
         super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
         this.code = enums_1.HMSH_CODE_DURABLE_FATAL;
     }
 }
 exports.DurableFatalError = DurableFatalError;
 class DurableRetryError extends Error {
-    constructor(message) {
+    constructor(message, stackTrace) {
         super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
         this.code = enums_1.HMSH_CODE_DURABLE_RETRYABLE;
     }
 }
@@ -87,6 +143,7 @@ exports.RegisterTimeoutError = RegisterTimeoutError;
 class DuplicateJobError extends Error {
     constructor(jobId) {
         super("Duplicate job");
+        this.jobId = jobId;
         this.message = `Duplicate job: ${jobId}`;
     }
 }

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.51",
+    "version": "0.0.53",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -21,13 +21,16 @@
         "start": "ts-node src/index.ts",
         "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
         "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
+        "test:pipe": "NODE_ENV=test jest ./tests/unit/services/pipe/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:reentrant": "NODE_ENV=test jest ./tests/functional/reentrant/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:signal": "NODE_ENV=test jest ./tests/functional/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
@@ -46,13 +49,15 @@
         "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:meshos": "NODE_ENV=test jest ./tests/durable/meshos/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:basic": "NODE_ENV=test jest ./tests/durable/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:collision": "NODE_ENV=test jest ./tests/durable/collision/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:interrupt": "NODE_ENV=test jest ./tests/durable/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",

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

@@ -46,7 +46,15 @@ declare class Activity {
     mapInputData(): void;
     mapOutputData(): void;
     registerTimeout(): Promise<void>;
+    /**
+     * Any StreamMessage with a status of ERROR is bound to the activity
+     */
     bindActivityError(data: Record<string, unknown>): void;
+    /**
+     * unhandled activity errors (activities that return an ERROR StreamMessage
+     * status and have no adjacent children to transition to) are bound to the job
+     */
+    bindJobError(data: Record<string, unknown>): void;
     getTriggerConfig(): Promise<ActivityType>;
     getJobStatus(): null | number;
     setStatus(amount: number, multi?: RedisMulti): Promise<void>;