@hotmeshio/hotmesh 0.8.0 → 0.10.0

package/README.md

@@ -4,27 +4,39 @@
 
 Run durable workflows on Postgres. No servers, no queues, just your database.
 
+```bash
+npm install @hotmeshio/hotmesh
+```
 
-## Common Use Cases
+## Use HotMesh for
 
-### 1. Pipeline Database
-Transform Postgres into a durable pipeline processor. Orchestrate long-running, multi-step pipelines transactionally and durably.
+- **Durable pipelines** — Orchestrate long-running, multi-step pipelines transactionally.
+- **Temporal replacement** — The `Durable` module provides a Temporal-compatible API (`Client`, `Worker`, `proxyActivities`, `sleepFor`, `startChild`, signals) that runs directly on Postgres. No app server required.
+- **Distributed state machines** — Build stateful applications where every component can [fail and recover](https://github.com/hotmeshio/sdk-typescript/blob/main/services/collator/README.md).
+- **AI and training pipelines** — Multi-step AI workloads where each stage is expensive and must not be repeated on failure. A crashed pipeline resumes from the last committed step, not from the beginning.
 
-### 2. Temporal You Own
-Get the power of Temporal without the infrastructure. HotMesh includes MemFlow, a Temporal-compatible API that runs directly on your Postgres database. No app server required.
+## How it works in 30 seconds
 
-### 3. Distributed State Machine
-Build resilient, stateful applications where every component can [fail and recover](https://github.com/hotmeshio/sdk-typescript/blob/main/services/collator/README.md). HotMesh manages state transitions, retries, and coordination.
+1. **You write workflow functions.** Plain TypeScript — branching, loops, error handling. HotMesh also supports a YAML syntax for declarative, functional workflows.
+2. **HotMesh compiles them into a transactional execution plan.** Each step becomes a committed database row. If the process crashes mid-workflow, it resumes from the last committed step.
+3. **Your Postgres database is the engine.** It stores state, coordinates retries, and delivers messages. Every connected client participates in execution — there is no central server.
 
-### 4. Workflow-as-Code Platform
-Choose your style: procedural workflows with MemFlow's Temporal API, or functional workflows with HotMesh's YAML syntax.
+## Quickstart
 
-## Installation
+Install the package:
 
 ```bash
 npm install @hotmeshio/hotmesh
 ```
 
+The repo includes a `docker-compose.yml` that starts Postgres, NATS, and a development container:
+
+```bash
+docker compose up -d
+```
+
+Then follow the [Quick Start guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/quickstart.md) for a progressive walkthrough — from a single trigger to conditional, parallel, and compositional workflows.
+
 ## Two ways to write workflows
 
 Both approaches reuse your activity functions:
@@ -48,17 +60,17 @@ export async function notifyBackorder(itemId: string): Promise<void> {
 
 ```typescript
 // workflows.ts
-import { MemFlow } from '@hotmeshio/hotmesh';
+import { Durable } from '@hotmeshio/hotmesh';
 import * as activities from './activities';
 
 export async function orderWorkflow(itemId: string, qty: number) {
-  const { checkInventory, reserveItem, notifyBackorder } = 
-    MemFlow.workflow.proxyActivities<typeof activities>({
+  const { checkInventory, reserveItem, notifyBackorder } =
+    Durable.workflow.proxyActivities<typeof activities>({
       taskQueue: 'inventory-tasks'
     });
-  
+
   const available = await checkInventory(itemId);
-  
+
   if (available >= qty) {
     return await reserveItem(itemId, qty);
   } else {
@@ -73,18 +85,18 @@ const connection = {
   options: { connectionString: 'postgresql://localhost:5432/mydb' }
 };
 
-await MemFlow.registerActivityWorker({
+await Durable.registerActivityWorker({
   connection,
   taskQueue: 'inventory-tasks'
 }, activities, 'inventory-activities');
 
-await MemFlow.Worker.create({
+await Durable.Worker.create({
   connection,
   taskQueue: 'orders',
   workflow: orderWorkflow
 });
 
-const client = new MemFlow.Client({ connection });
+const client = new Durable.Client({ connection });
 const handle = await client.workflow.start({
   args: ['item-123', 5],
   taskQueue: 'orders',
@@ -102,23 +114,23 @@ const result = await handle.result();
 activities:
   trigger:
     type: trigger
-    
+
   checkInventory:
     type: worker
     topic: inventory.check
-    
+
   reserveItem:
     type: worker
     topic: inventory.reserve
-    
+
   notifyBackorder:
     type: worker
     topic: inventory.backorder.notify
-    
+
 transitions:
   trigger:
     - to: checkInventory
-    
+
   checkInventory:
     - to: reserveItem
       conditions:
@@ -128,7 +140,7 @@ transitions:
               '@pipe':
                 - ['{checkInventory.output.data.availableQty}', '{trigger.output.data.requestedQty}']
                 - ['{@conditional.gte}']
-    
+
     - to: notifyBackorder
       conditions:
         match:
@@ -139,6 +151,7 @@ transitions:
                 - ['{@conditional.gte}']
 ```
 
+Deploy and run as follows:
 ```typescript
 // main.ts (reuses same activities.ts)
 import * as activities from './activities';
@@ -185,42 +198,164 @@ const result = await hotMesh.pubsub('order.requested', {
 
 Both compile to the same distributed execution model.
 
-## Core features
+## Common patterns
 
-- **Durable execution** - Survives crashes, retries automatically
-- **No infrastructure** - Runs on your existing Postgres
-- **Temporal compatible** - Drop-in replacement for many use cases
-- **Distributed** - Every client participates in execution
-- **Observable** - Full execution history in your database
+All snippets below run inside a workflow function (like `orderWorkflow` above). Durable methods are available as static imports:
 
-## Common patterns
+```typescript
+import { Durable } from '@hotmeshio/hotmesh';
+```
 
-**Long-running workflows**
+**Long-running workflows** — `sleepFor` is durable. The process can restart; the timer survives.
 
 ```typescript
-await sleep('30 days');
+// sendFollowUp is a proxied activity from proxyActivities()
+await Durable.workflow.sleepFor('30 days');
 await sendFollowUp();
 ```
 
-**Parallel execution**
+**Parallel execution** — fan out to multiple activities and wait for all results.
 
 ```typescript
-const results = await Promise.all([
-  processPayment(),
-  updateInventory(),
-  notifyWarehouse()
+// proxied activities run as durable, retryable steps
+const [payment, inventory, shipment] = await Promise.all([
+  processPayment(orderId),
+  updateInventory(orderId),
+  notifyWarehouse(orderId)
 ]);
 ```
 
-**Child workflows**
+**Child workflows** — compose workflows from other workflows.
 
 ```typescript
-const childHandle = await startChild(validateOrder, { args: [orderId] });
+const childHandle = await Durable.workflow.startChild(validateOrder, {
+  args: [orderId],
+  taskQueue: 'validation',
+  workflowId: `validate-${orderId}`
+});
 const validation = await childHandle.result();
 ```
 
-## License
+**Signals** — pause a workflow until an external event arrives.
+
+```typescript
+const approval = await Durable.workflow.waitFor<{ approved: boolean }>('manager-approval');
+if (!approval.approved) return 'rejected';
+```
+
+## Retries and error handling
+
+Activities retry automatically on failure. Configure the policy per activity or per worker:
+
+```typescript
+// Durable: per-activity retry policy
+const { reserveItem } = Durable.workflow.proxyActivities<typeof activities>({
+  taskQueue: 'inventory-tasks',
+  retryPolicy: {
+    maximumAttempts: 5,
+    backoffCoefficient: 2,
+    maximumInterval: '60s'
+  }
+});
+```
+
+```typescript
+// HotMesh: worker-level retry policy
+const hotMesh = await HotMesh.init({
+  appId: 'orders',
+  engine: { connection },
+  workers: [{
+    topic: 'inventory.reserve',
+    connection,
+    retryPolicy: {
+      maximumAttempts: 5,
+      backoffCoefficient: 2,
+      maximumInterval: '60s'
+    },
+    callback: async (data) => { /* ... */ }
+  }]
+});
+```
+
+Defaults: 3 attempts, coefficient 10, 120s cap. Delay formula: `min(coefficient ^ attempt, maximumInterval)`. Duration strings like `'5 seconds'`, `'2 minutes'`, and `'1 hour'` are supported.
+
+If all retries are exhausted, the activity fails and the error propagates to the workflow function — handle it with a standard `try/catch`.
+
+## Workflow state is queryable data
+
+Workflow state lives in your database as ordinary rows — `jobs` and `jobs_attributes`. Query it directly, back it up with pg_dump, replicate it, join it against your application tables.
+
+```sql
+SELECT
+  j.key          AS job_key,
+  j.status       AS semaphore,
+  j.entity       AS workflow,
+  a.field        AS attribute,
+  a.value        AS value,
+  j.created_at,
+  j.updated_at
+FROM
+  jobs j
+  JOIN jobs_attributes a ON a.job_id = j.id
+WHERE
+  j.key = 'order-456'
+ORDER BY
+  a.field;
+```
+
+What happened? Consult the database. What's still running? Query the semaphore. What failed? Read the row. The execution state isn't reconstructed from a log — it was committed transactionally as each step ran.
+
+You can also use the Temporal-compatible API:
+
+```typescript
+const handle = client.workflow.getHandle('orders', 'orderWorkflow', 'order-456');
+
+const result = await handle.result();           // final output
+const status = await handle.status();           // semaphore (0 = complete)
+const state  = await handle.state(true);        // full state with metadata
+const exported = await handle.export({          // selective export
+  allow: ['data', 'state', 'status', 'timeline']
+});
+```
+
+## Observability
+
+There is no proprietary dashboard. Workflow state lives in Postgres, so use whatever tools you already have:
 
-HotMesh is licensed under the Apache License, Version 2.0.
+- **Direct SQL** — query `jobs` and `jobs_attributes` to inspect state, as shown above.
+- **Handle API** — `handle.status()`, `handle.state(true)`, and `handle.export()` give programmatic access to any running or completed workflow.
+- **Logging** — set `HMSH_LOGLEVEL` (`debug`, `info`, `warn`, `error`, `silent`) to control log verbosity.
+- **OpenTelemetry** — set `HMSH_TELEMETRY=true` to emit spans and metrics. Plug in any OTel-compatible collector.
+
+## Architecture
+
+For a deep dive into the transactional execution model — how every step is crash-safe, how the monotonic collation ledger guarantees exactly-once delivery, and how cycles and retries remain correct under arbitrary failure — see the [Collation Design Document](https://github.com/hotmeshio/sdk-typescript/blob/main/services/collator/README.md). The symbolic system (how to design workflows) and lifecycle details (how to deploy workflows) are covered in the [Architectural Overview](https://zenodo.org/records/12168558).
+
+## Familiar with Temporal?
+
+Durable is designed as a drop-in-compatible alternative for common Temporal patterns.
+
+**What's the same:** `Client`, `Worker`, `proxyActivities`, `sleepFor`, `startChild`/`execChild`, signals (`waitFor`/`signal`), retry policies, and the overall workflow-as-code programming model.
+
+**What's different:** No Temporal server or cluster to operate. Postgres is the only infrastructure dependency — it stores state, coordinates workers, and delivers messages. HotMesh also offers a YAML-based approach for declarative workflows that compile to the same execution model.
+
+## Running tests
+
+Tests run inside Docker. Start the services and run the full suite:
+
+```bash
+docker compose up -d
+docker compose exec hotmesh npm test
+```
+
+Run a specific test group:
+
+```bash
+docker compose exec hotmesh npm run test:durable         # all Durable tests (Temporal pattern coverage proofs)
+docker compose exec hotmesh npm run test:durable:hello   # single Durable test (hello world proxyActivity proof)
+docker compose exec hotmesh npm run test:virtual         # all Virtual network function (VNF) tests
+```
+
+## License
 
-You may use, modify, and distribute HotMesh in accordance with the license, including as part of your own applications and services. However, offering HotMesh itself as a standalone, hosted commercial orchestration service (or a substantially similar service) requires prior written permission from the author.
+HotMesh is source-available under the [HotMesh Source Available License](./LICENSE).

package/build/index.d.ts

@@ -1,15 +1,16 @@
 import { HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
-import { MeshCall } from './services/meshcall';
-import { MemFlow } from './services/memflow';
-import { ClientService as Client } from './services/memflow/client';
-import { ConnectionService as Connection } from './services/memflow/connection';
-import { Search } from './services/memflow/search';
-import { Entity } from './services/memflow/entity';
-import { WorkerService as Worker } from './services/memflow/worker';
-import { WorkflowService as workflow } from './services/memflow/workflow';
-import { WorkflowHandleService as WorkflowHandle } from './services/memflow/handle';
-import { proxyActivities } from './services/memflow/workflow/proxyActivities';
+import { Virtual } from './services/virtual';
+import { Durable } from './services/durable';
+import { DBA } from './services/dba';
+import { ClientService as Client } from './services/durable/client';
+import { ConnectionService as Connection } from './services/durable/connection';
+import { Search } from './services/durable/search';
+import { Entity } from './services/durable/entity';
+import { WorkerService as Worker } from './services/durable/worker';
+import { WorkflowService as workflow } from './services/durable/workflow';
+import { WorkflowHandleService as WorkflowHandle } from './services/durable/handle';
+import { proxyActivities } from './services/durable/workflow/proxyActivities';
 import * as Errors from './modules/errors';
 import * as Utils from './modules/utils';
 import * as Enums from './modules/enums';
@@ -18,5 +19,5 @@ import { ConnectorService as Connector } from './services/connector/factory';
 import { PostgresConnection as ConnectorPostgres } from './services/connector/providers/postgres';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 export { Connector, //factory
-ConnectorNATS, ConnectorPostgres, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
+ConnectorNATS, ConnectorPostgres, HotMesh, HotMeshConfig, Virtual, Durable, DBA, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
 export * as Types from './types';

package/build/index.js

@@ -23,28 +23,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorPostgres = exports.ConnectorNATS = exports.Connector = void 0;
+exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.DBA = exports.Durable = exports.Virtual = exports.HotMesh = exports.ConnectorPostgres = exports.ConnectorNATS = exports.Connector = void 0;
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
-const meshcall_1 = require("./services/meshcall");
-Object.defineProperty(exports, "MeshCall", { enumerable: true, get: function () { return meshcall_1.MeshCall; } });
-const memflow_1 = require("./services/memflow");
-Object.defineProperty(exports, "MemFlow", { enumerable: true, get: function () { return memflow_1.MemFlow; } });
-const client_1 = require("./services/memflow/client");
+const virtual_1 = require("./services/virtual");
+Object.defineProperty(exports, "Virtual", { enumerable: true, get: function () { return virtual_1.Virtual; } });
+const durable_1 = require("./services/durable");
+Object.defineProperty(exports, "Durable", { enumerable: true, get: function () { return durable_1.Durable; } });
+const dba_1 = require("./services/dba");
+Object.defineProperty(exports, "DBA", { enumerable: true, get: function () { return dba_1.DBA; } });
+const client_1 = require("./services/durable/client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.ClientService; } });
-const connection_1 = require("./services/memflow/connection");
+const connection_1 = require("./services/durable/connection");
 Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return connection_1.ConnectionService; } });
-const search_1 = require("./services/memflow/search");
+const search_1 = require("./services/durable/search");
 Object.defineProperty(exports, "Search", { enumerable: true, get: function () { return search_1.Search; } });
-const entity_1 = require("./services/memflow/entity");
+const entity_1 = require("./services/durable/entity");
 Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return entity_1.Entity; } });
-const worker_1 = require("./services/memflow/worker");
+const worker_1 = require("./services/durable/worker");
 Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return worker_1.WorkerService; } });
-const workflow_1 = require("./services/memflow/workflow");
+const workflow_1 = require("./services/durable/workflow");
 Object.defineProperty(exports, "workflow", { enumerable: true, get: function () { return workflow_1.WorkflowService; } });
-const handle_1 = require("./services/memflow/handle");
+const handle_1 = require("./services/durable/handle");
 Object.defineProperty(exports, "WorkflowHandle", { enumerable: true, get: function () { return handle_1.WorkflowHandleService; } });
-const proxyActivities_1 = require("./services/memflow/workflow/proxyActivities");
+const proxyActivities_1 = require("./services/durable/workflow/proxyActivities");
 Object.defineProperty(exports, "proxyActivities", { enumerable: true, get: function () { return proxyActivities_1.proxyActivities; } });
 const Errors = __importStar(require("./modules/errors"));
 exports.Errors = Errors;

package/build/modules/enums.d.ts

@@ -11,10 +11,6 @@ export declare const HMSH_TELEMETRY: "debug" | "info";
  * Default cleanup time for signal in the db when its associated job is completed.
  */
 export declare const HMSH_SIGNAL_EXPIRE = 3600;
-/**
- * Determines if the system is running in cluster mode (for Redis cluster support).
- */
-export declare const HMSH_IS_CLUSTER: boolean;
 export declare const HMSH_CODE_SUCCESS = 200;
 export declare const HMSH_CODE_PENDING = 202;
 export declare const HMSH_CODE_NOTFOUND = 404;
@@ -23,43 +19,43 @@ 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.
+ * This is thrown when a Durable has been interrupted by a sleepFor call.
  */
-export declare const HMSH_CODE_MEMFLOW_SLEEP = 588;
+export declare const HMSH_CODE_DURABLE_SLEEP = 588;
 /**
- * This is thrown when a MemFlow has been interrupted by a Promise.all call.
+ * This is thrown when a Durable has been interrupted by a Promise.all call.
  */
-export declare const HMSH_CODE_MEMFLOW_ALL = 589;
+export declare const HMSH_CODE_DURABLE_ALL = 589;
 /**
- * This is thrown when a MemFlow has been interrupted by an execChild or startChild call.
+ * This is thrown when a Durable has been interrupted by an execChild or startChild call.
  */
-export declare const HMSH_CODE_MEMFLOW_CHILD = 590;
+export declare const HMSH_CODE_DURABLE_CHILD = 590;
 /**
- * This is thrown when a MemFlow has been interrupted by a proxyActivity call.
+ * This is thrown when a Durable has been interrupted by a proxyActivity call.
  */
-export declare const HMSH_CODE_MEMFLOW_PROXY = 591;
+export declare const HMSH_CODE_DURABLE_PROXY = 591;
 /**
- * This is thrown when a MemFlow has been interrupted by a waitForSignal call.
+ * This is thrown when a Durable has been interrupted by a waitForSignal call.
  */
-export declare const HMSH_CODE_MEMFLOW_WAIT = 595;
+export declare const HMSH_CODE_DURABLE_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.
+ * The timeout status code for Durable. This status code is thrown when Durable has encountered a timeout error and needs to aler the caller why the call failed.
  */
-export declare const HMSH_CODE_MEMFLOW_TIMEOUT = 596;
+export declare const HMSH_CODE_DURABLE_TIMEOUT = 596;
 /**
- * The maxed status code for MemFlow. This status code is used to indicate that the MemFlow has reached the maximum
+ * The maxed status code for Durable. This status code is used to indicate that the Durable 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;
+export declare const HMSH_CODE_DURABLE_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.
+ * The fatal status code for Durable. This status code is used to indicate that the Durable 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;
+export declare const HMSH_CODE_DURABLE_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).
+ * The retryable status code for Durable. This status code is used to indicate that the Durable 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_CODE_DURABLE_RETRYABLE = 599;
 export declare const HMSH_STATUS_UNKNOWN = "unknown";
 /**
  * The number of cycles to re/try for a quorum to be established.
@@ -85,20 +81,20 @@ 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.
+ * The maximum number of attempts to retry a Durable job before it is considered failed.
  * @default 3
  */
-export declare const HMSH_MEMFLOW_MAX_ATTEMPTS = 3;
+export declare const HMSH_DURABLE_MAX_ATTEMPTS = 3;
 /**
- * The maximum interval to wait before retrying a MemFlow job.
+ * The maximum interval to wait before retrying a Durable job.
  * @default 120s
  */
-export declare const HMSH_MEMFLOW_MAX_INTERVAL = "120s";
+export declare const HMSH_DURABLE_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_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;
@@ -124,10 +120,3 @@ export declare const HMSH_NOTIFY_PAYLOAD_LIMIT: number;
  * Used when LISTEN/NOTIFY is unavailable or fails. Default 30 seconds.
  */
 export declare const HMSH_ROUTER_POLL_FALLBACK_INTERVAL: number;
-/**
- * Serializer compression threshold. When a stringified object exceeds this size
- * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce
- * Redis hash storage size. Default 100 bytes - small enough to catch most
- * workflow state but compression only applies if it actually reduces size.
- */
-export declare const HMSH_SERIALIZER_COMPRESSION_THRESHOLD: number;

package/build/modules/enums.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_NOTIFY_PAYLOAD_LIMIT = exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_ROUTER_SCOUT_INTERVAL_MS = exports.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS = 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_IS_CLUSTER = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
-exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = exports.HMSH_ROUTER_POLL_FALLBACK_INTERVAL = void 0;
+exports.HMSH_ROUTER_POLL_FALLBACK_INTERVAL = exports.HMSH_NOTIFY_PAYLOAD_LIMIT = exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_ROUTER_SCOUT_INTERVAL_MS = exports.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS = 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.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_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_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
 /**
  * Determines the log level for the application. The default is 'info'.
  */
@@ -14,10 +13,6 @@ exports.HMSH_TELEMETRY = process.env.HMSH_TELEMETRY || 'info';
  * Default cleanup time for signal in the db when its associated job is completed.
  */
 exports.HMSH_SIGNAL_EXPIRE = 3600; //seconds
-/**
- * Determines if the system is running in cluster mode (for Redis cluster support).
- */
-exports.HMSH_IS_CLUSTER = process.env.HMSH_IS_CLUSTER === 'true';
 // HOTMESH STATUS CODES
 exports.HMSH_CODE_SUCCESS = 200;
 exports.HMSH_CODE_PENDING = 202;
@@ -26,45 +21,45 @@ exports.HMSH_CODE_INTERRUPT = 410;
 exports.HMSH_CODE_UNKNOWN = 500;
 exports.HMSH_CODE_TIMEOUT = 504;
 exports.HMSH_CODE_UNACKED = 999;
-// MEMFLOW STATUS CODES
+// DURABLE STATUS CODES
 /**
- * This is thrown when a MemFlow has been interrupted by a sleepFor call.
+ * This is thrown when a Durable has been interrupted by a sleepFor call.
  */
-exports.HMSH_CODE_MEMFLOW_SLEEP = 588;
+exports.HMSH_CODE_DURABLE_SLEEP = 588;
 /**
- * This is thrown when a MemFlow has been interrupted by a Promise.all call.
+ * This is thrown when a Durable has been interrupted by a Promise.all call.
  */
-exports.HMSH_CODE_MEMFLOW_ALL = 589;
+exports.HMSH_CODE_DURABLE_ALL = 589;
 /**
- * This is thrown when a MemFlow has been interrupted by an execChild or startChild call.
+ * This is thrown when a Durable has been interrupted by an execChild or startChild call.
  */
-exports.HMSH_CODE_MEMFLOW_CHILD = 590;
+exports.HMSH_CODE_DURABLE_CHILD = 590;
 /**
- * This is thrown when a MemFlow has been interrupted by a proxyActivity call.
+ * This is thrown when a Durable has been interrupted by a proxyActivity call.
  */
-exports.HMSH_CODE_MEMFLOW_PROXY = 591;
+exports.HMSH_CODE_DURABLE_PROXY = 591;
 /**
- * This is thrown when a MemFlow has been interrupted by a waitForSignal call.
+ * This is thrown when a Durable has been interrupted by a waitForSignal call.
  */
-exports.HMSH_CODE_MEMFLOW_WAIT = 595;
+exports.HMSH_CODE_DURABLE_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.
+ * The timeout status code for Durable. This status code is thrown when Durable has encountered a timeout error and needs to aler the caller why the call failed.
  */
-exports.HMSH_CODE_MEMFLOW_TIMEOUT = 596;
+exports.HMSH_CODE_DURABLE_TIMEOUT = 596;
 /**
- * The maxed status code for MemFlow. This status code is used to indicate that the MemFlow has reached the maximum
+ * The maxed status code for Durable. This status code is used to indicate that the Durable 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;
+exports.HMSH_CODE_DURABLE_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.
+ * The fatal status code for Durable. This status code is used to indicate that the Durable has encountered a fatal error. Throw from a proxied activity or a flow to halt standard execution.
  */
-exports.HMSH_CODE_MEMFLOW_FATAL = 598;
+exports.HMSH_CODE_DURABLE_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).
+ * The retryable status code for Durable. This status code is used to indicate that the Durable has encountered a retryable error (essentially unknown and covered by the standard retry policy).
  */
-exports.HMSH_CODE_MEMFLOW_RETRYABLE = 599;
+exports.HMSH_CODE_DURABLE_RETRYABLE = 599;
 // HOTMESH MESSAGES
 exports.HMSH_STATUS_UNKNOWN = 'unknown';
 // QUORUM
@@ -94,22 +89,22 @@ exports.MAX_DELAY = 2147483647; // Maximum allowed delay in milliseconds for set
 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
+// DURABLE
 /**
- * The maximum number of attempts to retry a MemFlow job before it is considered failed.
+ * The maximum number of attempts to retry a Durable job before it is considered failed.
  * @default 3
  */
-exports.HMSH_MEMFLOW_MAX_ATTEMPTS = 3;
+exports.HMSH_DURABLE_MAX_ATTEMPTS = 3;
 /**
- * The maximum interval to wait before retrying a MemFlow job.
+ * The maximum interval to wait before retrying a Durable job.
  * @default 120s
  */
-exports.HMSH_MEMFLOW_MAX_INTERVAL = '120s';
+exports.HMSH_DURABLE_MAX_INTERVAL = '120s';
 /**
  * The exponential backoff factor to apply to the interval between retries.
  * @default 10
  */
-exports.HMSH_MEMFLOW_EXP_BACKOFF = 10;
+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
@@ -156,10 +151,3 @@ exports.HMSH_NOTIFY_PAYLOAD_LIMIT = parseInt(process.env.HMSH_NOTIFY_PAYLOAD_LIM
  * Used when LISTEN/NOTIFY is unavailable or fails. Default 30 seconds.
  */
 exports.HMSH_ROUTER_POLL_FALLBACK_INTERVAL = parseInt(process.env.HOTMESH_POSTGRES_FALLBACK_INTERVAL, 10) || 30000;
-/**
- * Serializer compression threshold. When a stringified object exceeds this size
- * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce
- * Redis hash storage size. Default 100 bytes - small enough to catch most
- * workflow state but compression only applies if it actually reduces size.
- */
-exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = parseInt(process.env.HMSH_SERIALIZER_COMPRESSION_THRESHOLD, 10) || 100000000;