@hotmeshio/hotmesh 0.4.0 → 0.4.1

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;

package/build/modules/key.d.ts

@@ -0,0 +1,66 @@
+import { KeyStoreParams, KeyType } from '../types/hotmesh';
+/**
+ * Keys
+ *
+ * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
+ * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
+ * hmsh:<appid>:r: ->                                 {hash}    throttle rates {':': '23', 'topic.thing': '555'} => {':i': 'all', 'topic.thing': '555seconds'}
+ * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
+ * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
+ * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
+ * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
+ * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
+ * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
+ * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
+ * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
+ * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
+ * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
+ * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
+ * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
+ * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
+ * hmsh:<appid>:signals ->                            {string}  dynamic hook signals (hget/hdel); expirable
+ * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
+ * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
+ * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
+ */
+declare const HMNS = "hmsh";
+declare const KEYSEP = ":";
+declare const VALSEP = "::";
+declare const WEBSEP = "::";
+declare const TYPSEP = "::";
+declare class KeyService {
+    /**
+     * Returns a key that can be used to access a value in the key/value store
+     * appropriate for the given key type; the keys have an implicit hierarchy
+     * and are used to organize data in the store in a tree-like structure
+     * via the use of colons as separators.
+     * @param namespace
+     * @param keyType
+     * @param params
+     * @returns {string}
+     */
+    static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
+    /**
+     * Extracts the parts of a given key string, safely handling cases where
+     * the 'id' portion may contain additional colons.
+     * @param key - The key to parse.
+     * @returns An object with the parsed key parts.
+     */
+    static parseKey(key: string): Record<string, string | undefined>;
+    /**
+     * Reconstructs a key string from its parts.
+     * @param parts - An object with the key parts.
+     * @returns The reconstructed key string.
+     */
+    static reconstituteKey(parts: Record<string, string | undefined>): string;
+    /**
+     * Resolves an entity type abbreviation to a table-friendly name.
+     * @param abbreviation - The abbreviated entity type.
+     * @returns The long-form entity name.
+     */
+    static resolveEntityType(abbreviation: string, id?: string): string;
+    static resolveAbbreviation(entity: string): string;
+}
+export { KeyService, KeyType, KeyStoreParams, HMNS, KEYSEP, TYPSEP, WEBSEP, VALSEP, };