@hotmeshio/hotmesh 0.4.0 → 0.4.2

package/README.md

@@ -1,15 +1,16 @@
-# HotMesh MemFlow
+# HotMesh
 
 **Permanent-Memory Workflows & AI Agents**
 
 ![beta release](https://img.shields.io/badge/release-beta-blue.svg)  ![made with typescript](https://img.shields.io/badge/built%20with-typescript-lightblue.svg)
 
-MemFlow is a drop-in Temporal-style engine that runs natively on Postgres — but with a twist:
-every workflow owns a *permanent*, JSON-backed context that lives beyond the main workflow.
-Any number of *hooks* (lightweight, thread-safe workers) can attach to that record at any
-time, read it, and safely write back incremental knowledge.
-Think **durable execution** + **shared, evolving memory** → perfect for human-in-the-loop
-processes and AI agents that learn over time.
+**HotMesh** is a Temporal-style workflow engine that runs natively on PostgreSQL — with a powerful twist: every workflow maintains a permanent, JSON-backed context that persists independently of the workflow itself.
+
+This means:
+
+* Any number of lightweight, thread-safe **hook workers** can attach to the same workflow record at any time.
+* These hooks can safely **read and incrementally write** to shared state.
+* The result is a **durable execution model** with **evolving memory**, ideal for **human-in-the-loop processes** and **AI agents that learn over time**.
 
 ---
 
@@ -61,10 +62,11 @@ async function main() {
 main().catch(console.error);
 ```
 
+---
 
 ## 🧠 How Permanent Memory Works
 
-* **Context = JSONB row** in `<yourappname>.jobs` table
+* **Context = persistent JSON record** – each workflow's memory is stored as a JSONB row in your Postgres database
 * **Atomic operations** (`set`, `merge`, `append`, `increment`, `toggle`, `delete`, …)
 * **Transactional** – every update participates in the workflow/DB transaction
 * **Time-travel-safe** – full replay compatibility; side-effect detector guarantees determinism
@@ -135,14 +137,37 @@ export async function hook2(name: string, kind: string): Promise<void> {
   await ctx.merge({ user: { lastSeen: new Date().toISOString() } });
   await MemFlow.workflow.signal('hook2-complete', { ok: true });
 }
-```
 
-**Highlights**
+/* ------------ Worker/Hook Registration ------------ */
+async function startWorker() {
+  const mf = await MemFlow.init({
+    appId: 'my-app',
+    engine: {
+      connection: {
+        class: Postgres,
+        options: { connectionString: process.env.DATABASE_URL }
+      }
+    }
+  });
+
+  const worker = await mf.worker.create({
+    taskQueue: 'contextual',
+    workflow: example
+  });
 
-* Hook functions are replay-safe.
-* Hook functions can safely read and write to the the *same* JSON context.
-* All context operations (`set`, `merge`, `append`, etc.) execute transactionally.
-* Context data is stored as JSONB; add partial indexes for improved query analysis.
+  await mf.worker.create({
+    taskQueue: 'contextual',
+    workflow: hook1
+  });
+
+  await mf.worker.create({
+    taskQueue: 'contextual',
+    workflow: hook2
+  });
+
+  console.log('Workers and hooks started and listening...');
+}
+```
 
 ---
 

package/build/modules/enums.d.ts

@@ -0,0 +1,110 @@
+import { LogLevel } from '../types/logger';
+/**
+ * Determines the log level for the application. The default is 'info'.
+ */
+export declare const HMSH_LOGLEVEL: LogLevel;
+/**
+ * Determines the log level for telemetry. The default is 'info' which emits worker and trigger spans. 'debug' emits all spans.
+ */
+export declare const HMSH_TELEMETRY: "debug" | "info";
+/**
+ * If Redis, explicitly sets whether the application is running in a cluster. The default is false.
+ * @deprecated
+ */
+export declare const HMSH_IS_CLUSTER: boolean;
+/**
+ * Default cleanup time for signal in the db when its associated job is completed.
+ */
+export declare const HMSH_SIGNAL_EXPIRE = 3600;
+export declare const HMSH_CODE_SUCCESS = 200;
+export declare const HMSH_CODE_PENDING = 202;
+export declare const HMSH_CODE_NOTFOUND = 404;
+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;
+/**
+ * This is thrown when a MemFlow has been interrupted by a sleepFor call.
+ */
+export declare const HMSH_CODE_MEMFLOW_SLEEP = 588;
+/**
+ * This is thrown when a MemFlow has been interrupted by a Promise.all call.
+ */
+export declare const HMSH_CODE_MEMFLOW_ALL = 589;
+/**
+ * This is thrown when a MemFlow has been interrupted by an execChild or startChild call.
+ */
+export declare const HMSH_CODE_MEMFLOW_CHILD = 590;
+/**
+ * This is thrown when a MemFlow has been interrupted by a proxyActivity call.
+ */
+export declare const HMSH_CODE_MEMFLOW_PROXY = 591;
+/**
+ * This is thrown when a MemFlow has been interrupted by a waitForSignal call.
+ */
+export declare const HMSH_CODE_MEMFLOW_WAIT = 595;
+/**
+ * The timeout status code for MemFlow. This status code is thrown when MemFlow has encountered a timeout error and needs to aler the caller why the call failed.
+ */
+export declare const HMSH_CODE_MEMFLOW_TIMEOUT = 596;
+/**
+ * The maxed status code for MemFlow. This status code is used to indicate that the MemFlow has reached the maximum
+ * number of attempts and should be halted. Thrown from a proxied activity or a flow to halt standard execution
+ * and prevent further attempts.
+ */
+export declare const HMSH_CODE_MEMFLOW_MAXED = 597;
+/**
+ * The fatal status code for MemFlow. This status code is used to indicate that the MemFlow has encountered a fatal error. Throw from a proxied activity or a flow to halt standard execution.
+ */
+export declare const HMSH_CODE_MEMFLOW_FATAL = 598;
+/**
+ * The retryable status code for MemFlow. This status code is used to indicate that the MemFlow has encountered a retryable error (essentially unknown and covered by the standard retry policy).
+ */
+export declare const HMSH_CODE_MEMFLOW_RETRYABLE = 599;
+export declare const HMSH_STATUS_UNKNOWN = "unknown";
+/**
+ * The number of cycles to re/try for a quorum to be established.
+ */
+export declare const HMSH_QUORUM_ROLLCALL_CYCLES = 12;
+/**
+ * The delay in milliseconds between quorum rollcall cycles.
+ */
+export declare const HMSH_QUORUM_DELAY_MS = 250;
+/**
+ * The number of times the call-response exchange must succeed in succession to establish a quorum.
+ */
+export declare const HMSH_ACTIVATION_MAX_RETRY = 3;
+export declare const HMSH_DEPLOYMENT_DELAY: number;
+export declare const HMSH_DEPLOYMENT_PAUSE: number;
+export declare const HMSH_OTT_WAIT_TIME: number;
+export declare const HMSH_EXPIRE_JOB_SECONDS: number;
+export declare const MAX_STREAM_BACKOFF: number;
+export declare const INITIAL_STREAM_BACKOFF: number;
+export declare const MAX_STREAM_RETRIES: number;
+export declare const MAX_DELAY = 2147483647;
+export declare const HMSH_MAX_RETRIES: number;
+export declare const HMSH_MAX_TIMEOUT_MS: number;
+export declare const HMSH_GRADUATED_INTERVAL_MS: number;
+/**
+ * The maximum number of attempts to retry a MemFlow job before it is considered failed.
+ * @default 3
+ */
+export declare const HMSH_MEMFLOW_MAX_ATTEMPTS = 3;
+/**
+ * The maximum interval to wait before retrying a MemFlow job.
+ * @default 120s
+ */
+export declare const HMSH_MEMFLOW_MAX_INTERVAL = "120s";
+/**
+ * The exponential backoff factor to apply to the interval between retries.
+ * @default 10
+ */
+export declare const HMSH_MEMFLOW_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;
+export declare const HMSH_XPENDING_COUNT: number;
+export declare const HMSH_EXPIRE_DURATION: number;
+export declare const HMSH_FIDELITY_SECONDS: number;
+export declare const HMSH_SCOUT_INTERVAL_SECONDS: number;
+export declare const HMSH_GUID_SIZE: number;

package/build/modules/enums.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HMSH_GUID_SIZE = 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_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_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_SIGNAL_EXPIRE = exports.HMSH_IS_CLUSTER = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
+/**
+ * Determines the log level for the application. The default is 'info'.
+ */
+exports.HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL || 'info';
+/**
+ * Determines the log level for telemetry. The default is 'info' which emits worker and trigger spans. 'debug' emits all spans.
+ */
+exports.HMSH_TELEMETRY = process.env.HMSH_TELEMETRY || 'info';
+/**
+ * If Redis, explicitly sets whether the application is running in a cluster. The default is false.
+ * @deprecated
+ */
+exports.HMSH_IS_CLUSTER = process.env.HMSH_IS_CLUSTER === 'true';
+/**
+ * Default cleanup time for signal in the db when its associated job is completed.
+ */
+exports.HMSH_SIGNAL_EXPIRE = 3600; //seconds
+// HOTMESH STATUS CODES
+exports.HMSH_CODE_SUCCESS = 200;
+exports.HMSH_CODE_PENDING = 202;
+exports.HMSH_CODE_NOTFOUND = 404;
+exports.HMSH_CODE_INTERRUPT = 410;
+exports.HMSH_CODE_UNKNOWN = 500;
+exports.HMSH_CODE_TIMEOUT = 504;
+exports.HMSH_CODE_UNACKED = 999;
+// MEMFLOW STATUS CODES
+/**
+ * This is thrown when a MemFlow has been interrupted by a sleepFor call.
+ */
+exports.HMSH_CODE_MEMFLOW_SLEEP = 588;
+/**
+ * This is thrown when a MemFlow has been interrupted by a Promise.all call.
+ */
+exports.HMSH_CODE_MEMFLOW_ALL = 589;
+/**
+ * This is thrown when a MemFlow has been interrupted by an execChild or startChild call.
+ */
+exports.HMSH_CODE_MEMFLOW_CHILD = 590;
+/**
+ * This is thrown when a MemFlow has been interrupted by a proxyActivity call.
+ */
+exports.HMSH_CODE_MEMFLOW_PROXY = 591;
+/**
+ * This is thrown when a MemFlow has been interrupted by a waitForSignal call.
+ */
+exports.HMSH_CODE_MEMFLOW_WAIT = 595;
+/**
+ * The timeout status code for MemFlow. This status code is thrown when MemFlow has encountered a timeout error and needs to aler the caller why the call failed.
+ */
+exports.HMSH_CODE_MEMFLOW_TIMEOUT = 596;
+/**
+ * The maxed status code for MemFlow. This status code is used to indicate that the MemFlow has reached the maximum
+ * number of attempts and should be halted. Thrown from a proxied activity or a flow to halt standard execution
+ * and prevent further attempts.
+ */
+exports.HMSH_CODE_MEMFLOW_MAXED = 597;
+/**
+ * The fatal status code for MemFlow. This status code is used to indicate that the MemFlow has encountered a fatal error. Throw from a proxied activity or a flow to halt standard execution.
+ */
+exports.HMSH_CODE_MEMFLOW_FATAL = 598;
+/**
+ * The retryable status code for MemFlow. This status code is used to indicate that the MemFlow has encountered a retryable error (essentially unknown and covered by the standard retry policy).
+ */
+exports.HMSH_CODE_MEMFLOW_RETRYABLE = 599;
+// HOTMESH MESSAGES
+exports.HMSH_STATUS_UNKNOWN = 'unknown';
+// QUORUM
+/**
+ * The number of cycles to re/try for a quorum to be established.
+ */
+exports.HMSH_QUORUM_ROLLCALL_CYCLES = 12;
+/**
+ * The delay in milliseconds between quorum rollcall cycles.
+ */
+exports.HMSH_QUORUM_DELAY_MS = 250;
+/**
+ * The number of times the call-response exchange must succeed in succession to establish a quorum.
+ */
+exports.HMSH_ACTIVATION_MAX_RETRY = 3;
+//backend provisioning
+exports.HMSH_DEPLOYMENT_DELAY = parseInt(process.env.HMSH_DEPLOYMENT_DELAY, 10) || 10000; //in ms
+exports.HMSH_DEPLOYMENT_PAUSE = parseInt(process.env.HMSH_DEPLOYMENT_PAUSE, 10) || 250; //in ms
+// ENGINE
+exports.HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
+exports.HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
+// STREAM ROUTER
+exports.MAX_STREAM_BACKOFF = parseInt(process.env.MAX_STREAM_BACKOFF, 10) || 500;
+exports.INITIAL_STREAM_BACKOFF = parseInt(process.env.INITIAL_STREAM_BACKOFF, 10) || 250;
+exports.MAX_STREAM_RETRIES = parseInt(process.env.MAX_STREAM_RETRIES, 10) || 2;
+exports.MAX_DELAY = 2147483647; // Maximum allowed delay in milliseconds for setTimeout
+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;
+// MEMFLOW
+/**
+ * The maximum number of attempts to retry a MemFlow job before it is considered failed.
+ * @default 3
+ */
+exports.HMSH_MEMFLOW_MAX_ATTEMPTS = 3;
+/**
+ * The maximum interval to wait before retrying a MemFlow job.
+ * @default 120s
+ */
+exports.HMSH_MEMFLOW_MAX_INTERVAL = '120s';
+/**
+ * The exponential backoff factor to apply to the interval between retries.
+ * @default 10
+ */
+exports.HMSH_MEMFLOW_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;
+exports.HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
+// TASK WORKER
+exports.HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
+const BASE_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;
+// UTILS
+exports.HMSH_GUID_SIZE = Math.min(parseInt(process.env.HMSH_GUID_SIZE, 10) || 22, 32);

package/build/modules/errors.d.ts

@@ -0,0 +1,124 @@
+import { ActivityDuplex } from '../types/activity';
+import { CollationFaultType, CollationStage } from '../types/collator';
+import { MemFlowChildErrorType, MemFlowProxyErrorType, MemFlowSleepErrorType, MemFlowWaitForAllErrorType, MemFlowWaitForErrorType } from '../types/error';
+declare class GetStateError extends Error {
+    jobId: string;
+    code: number;
+    constructor(jobId: string);
+}
+declare class SetStateError extends Error {
+    constructor();
+}
+declare class MemFlowWaitForError extends Error {
+    code: number;
+    signalId: string;
+    workflowId: string;
+    index: number;
+    workflowDimension: string;
+    constructor(params: MemFlowWaitForErrorType);
+}
+declare class MemFlowProxyError extends Error {
+    activityName: string;
+    arguments: string[];
+    backoffCoefficient: number;
+    code: number;
+    index: number;
+    maximumAttempts: number;
+    maximumInterval: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    expire: number;
+    workflowDimension: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: MemFlowProxyErrorType);
+}
+declare class MemFlowChildError extends Error {
+    await: boolean;
+    arguments: string[];
+    backoffCoefficient: number;
+    code: number;
+    expire: number;
+    persistent: boolean;
+    signalIn: boolean;
+    workflowDimension: string;
+    index: number;
+    maximumAttempts: number;
+    maximumInterval: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: MemFlowChildErrorType);
+}
+declare class MemFlowWaitForAllError extends Error {
+    items: any[];
+    code: number;
+    workflowDimension: string;
+    size: number;
+    index: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowId: string;
+    workflowTopic: string;
+    constructor(params: MemFlowWaitForAllErrorType);
+}
+declare class MemFlowSleepError extends Error {
+    workflowId: string;
+    code: number;
+    duration: number;
+    index: number;
+    workflowDimension: string;
+    constructor(params: MemFlowSleepErrorType);
+}
+declare class MemFlowTimeoutError extends Error {
+    code: number;
+    constructor(message: string, stack?: string);
+}
+declare class MemFlowMaxedError extends Error {
+    code: number;
+    constructor(message: string, stackTrace?: string);
+}
+declare class MemFlowFatalError extends Error {
+    code: number;
+    constructor(message: string, stackTrace?: string);
+}
+declare class MemFlowRetryError extends Error {
+    code: number;
+    constructor(message: string, stackTrace?: string);
+}
+declare class MapDataError extends Error {
+    constructor();
+}
+declare class RegisterTimeoutError extends Error {
+    constructor();
+}
+declare class DuplicateJobError extends Error {
+    jobId: string;
+    constructor(jobId: string);
+}
+declare class InactiveJobError extends Error {
+    jobId: string;
+    activityId: string;
+    status: number;
+    constructor(jobId: string, status: number, activityId: string);
+}
+declare class GenerationalError extends Error {
+    expected: string;
+    actual: string;
+    jobId: string;
+    activityId: string;
+    dimensionalAddress: string;
+    constructor(expected: string, actual: string, jobId: string, activityId: string, dimensionalAddress: string);
+}
+declare class ExecActivityError extends Error {
+    constructor();
+}
+declare class CollationError extends Error {
+    status: number;
+    leg: ActivityDuplex;
+    stage: CollationStage;
+    fault: CollationFaultType;
+    constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
+}
+export { CollationError, MemFlowChildError, MemFlowFatalError, MemFlowMaxedError, MemFlowProxyError, MemFlowRetryError, MemFlowSleepError, MemFlowTimeoutError, MemFlowWaitForAllError, MemFlowWaitForError, DuplicateJobError, ExecActivityError, GenerationalError, GetStateError, InactiveJobError, MapDataError, RegisterTimeoutError, SetStateError, };

package/build/modules/errors.js

@@ -0,0 +1,191 @@
+"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.MemFlowWaitForError = exports.MemFlowWaitForAllError = exports.MemFlowTimeoutError = exports.MemFlowSleepError = exports.MemFlowRetryError = exports.MemFlowProxyError = exports.MemFlowMaxedError = exports.MemFlowFatalError = exports.MemFlowChildError = exports.CollationError = void 0;
+const enums_1 = require("./enums");
+class GetStateError extends Error {
+    constructor(jobId) {
+        super(`${jobId} Not Found`);
+        this.code = enums_1.HMSH_CODE_NOTFOUND;
+        this.jobId = jobId;
+    }
+}
+exports.GetStateError = GetStateError;
+class SetStateError extends Error {
+    constructor() {
+        super('Error occurred while setting job state');
+    }
+}
+exports.SetStateError = SetStateError;
+class MemFlowWaitForError extends Error {
+    constructor(params) {
+        super(`WaitFor Interruption`);
+        this.signalId = params.signalId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_MEMFLOW_WAIT;
+    }
+}
+exports.MemFlowWaitForError = MemFlowWaitForError;
+class MemFlowProxyError extends Error {
+    constructor(params) {
+        super(`ProxyActivity Interruption`);
+        this.arguments = params.arguments;
+        this.workflowId = params.workflowId;
+        this.workflowTopic = params.workflowTopic;
+        this.parentWorkflowId = params.parentWorkflowId;
+        this.expire = params.expire;
+        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_MEMFLOW_PROXY;
+    }
+}
+exports.MemFlowProxyError = MemFlowProxyError;
+class MemFlowChildError extends Error {
+    constructor(params) {
+        super(`ExecChild Interruption`);
+        this.arguments = params.arguments;
+        this.workflowId = params.workflowId;
+        this.workflowTopic = params.workflowTopic;
+        this.parentWorkflowId = params.parentWorkflowId;
+        this.expire = params.expire;
+        this.persistent = params.persistent;
+        this.signalIn = params.signalIn;
+        this.originJobId = params.originJobId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_MEMFLOW_CHILD;
+        this.await = params.await;
+        this.backoffCoefficient = params.backoffCoefficient;
+        this.maximumAttempts = params.maximumAttempts;
+        this.maximumInterval = params.maximumInterval;
+    }
+}
+exports.MemFlowChildError = MemFlowChildError;
+class MemFlowWaitForAllError extends Error {
+    constructor(params) {
+        super(`Collation Interruption`);
+        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_MEMFLOW_ALL;
+    }
+}
+exports.MemFlowWaitForAllError = MemFlowWaitForAllError;
+class MemFlowSleepError extends Error {
+    constructor(params) {
+        super(`SleepFor Interruption`);
+        this.duration = params.duration;
+        this.workflowId = params.workflowId;
+        this.index = params.index;
+        this.workflowDimension = params.workflowDimension;
+        this.code = enums_1.HMSH_CODE_MEMFLOW_SLEEP;
+    }
+}
+exports.MemFlowSleepError = MemFlowSleepError;
+class MemFlowTimeoutError extends Error {
+    constructor(message, stack) {
+        super(message);
+        if (this.stack) {
+            this.stack = stack;
+        }
+        this.code = enums_1.HMSH_CODE_MEMFLOW_TIMEOUT;
+    }
+}
+exports.MemFlowTimeoutError = MemFlowTimeoutError;
+class MemFlowMaxedError extends Error {
+    constructor(message, stackTrace) {
+        super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
+        this.code = enums_1.HMSH_CODE_MEMFLOW_MAXED;
+    }
+}
+exports.MemFlowMaxedError = MemFlowMaxedError;
+class MemFlowFatalError extends Error {
+    constructor(message, stackTrace) {
+        super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
+        this.code = enums_1.HMSH_CODE_MEMFLOW_FATAL;
+    }
+}
+exports.MemFlowFatalError = MemFlowFatalError;
+class MemFlowRetryError extends Error {
+    constructor(message, stackTrace) {
+        super(message);
+        if (stackTrace) {
+            this.stack = stackTrace;
+        }
+        this.code = enums_1.HMSH_CODE_MEMFLOW_RETRYABLE;
+    }
+}
+exports.MemFlowRetryError = MemFlowRetryError;
+class MapDataError extends Error {
+    constructor() {
+        super('Error occurred while mapping data');
+    }
+}
+exports.MapDataError = MapDataError;
+class RegisterTimeoutError extends Error {
+    constructor() {
+        super('Error occurred while registering activity timeout');
+    }
+}
+exports.RegisterTimeoutError = RegisterTimeoutError;
+class DuplicateJobError extends Error {
+    constructor(jobId) {
+        super('Duplicate job');
+        this.jobId = jobId;
+        this.message = `Duplicate job: ${jobId}`;
+    }
+}
+exports.DuplicateJobError = DuplicateJobError;
+class InactiveJobError extends Error {
+    constructor(jobId, status, activityId) {
+        super('Inactive job');
+        this.jobId = jobId;
+        this.activityId = activityId;
+        this.message = `Inactive job: ${jobId}`;
+        this.status = status;
+    }
+}
+exports.InactiveJobError = InactiveJobError;
+class GenerationalError extends Error {
+    constructor(expected, actual, jobId, activityId, dimensionalAddress) {
+        super('Generational Error');
+        this.expected = expected;
+        this.actual = actual;
+        this.jobId = jobId;
+        this.activityId = activityId;
+        this.dimensionalAddress = dimensionalAddress;
+    }
+}
+exports.GenerationalError = GenerationalError;
+class ExecActivityError extends Error {
+    constructor() {
+        super('Error occurred while executing activity');
+    }
+}
+exports.ExecActivityError = ExecActivityError;
+class CollationError extends Error {
+    constructor(status, leg, stage, fault) {
+        super('collation-error');
+        this.leg = leg;
+        this.status = status;
+        this.stage = stage;
+        this.fault = fault;
+    }
+}
+exports.CollationError = CollationError;