@hotmeshio/hotmesh 0.9.0 → 0.10.0

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

@@ -17,12 +17,12 @@ const index_1 = require("./index");
  *
  * @example
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
  * import * as workflows from './workflows';
  *
  * async function run() {
- *   const worker = await MemFlow.Worker.create({
+ *   const worker = await Durable.Worker.create({
  *     connection: {
  *       class: Postgres,
  *       options: { connectionString: 'postgres://user:password@localhost:5432/db' }
@@ -68,7 +68,7 @@ class WorkerService {
                 await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
-                hotMesh.engine.logger.error('memflow-worker-deploy-activate-err', err);
+                hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
                 throw err;
             }
         }
@@ -77,7 +77,7 @@ class WorkerService {
                 await hotMesh.activate(factory_1.APP_VERSION);
             }
             catch (err) {
-                hotMesh.engine.logger.error('memflow-worker-activate-err', err);
+                hotMesh.engine.logger.error('durable-worker-activate-err', err);
                 throw err;
             }
         }
@@ -121,7 +121,7 @@ class WorkerService {
      * @example
      * ```typescript
      * // Activity worker (can be on separate server)
-     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Durable } from '@hotmeshio/hotmesh';
      * import { Client as Postgres } from 'pg';
      *
      * const activities = {
@@ -133,7 +133,7 @@ class WorkerService {
      *   }
      * };
      *
-     * await MemFlow.registerActivityWorker({
+     * await Durable.registerActivityWorker({
      *   connection: {
      *     class: Postgres,
      *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -146,7 +146,7 @@ class WorkerService {
      * ```typescript
      * // Workflow worker (can be on different server)
      * async function orderWorkflow(orderId: string, amount: number) {
-     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *   const { processPayment, sendEmail } = Durable.workflow.proxyActivities<{
      *     processPayment: (amount: number) => Promise<string>;
      *     sendEmail: (to: string, subject: string) => Promise<void>;
      *   }>({
@@ -159,7 +159,7 @@ class WorkerService {
      *   return result;
      * }
      *
-     * await MemFlow.Worker.create({
+     * await Durable.Worker.create({
      *   connection: {
      *     class: Postgres,
      *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -172,7 +172,7 @@ class WorkerService {
      * @example
      * ```typescript
      * // Shared activity pool for interceptors
-     * await MemFlow.registerActivityWorker({
+     * await Durable.registerActivityWorker({
      *   connection: {
      *     class: Postgres,
      *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -182,7 +182,7 @@ class WorkerService {
      *
      * const interceptor: WorkflowInterceptor = {
      *   async execute(ctx, next) {
-     *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+     *     const { auditLog } = Durable.workflow.proxyActivities<{
      *       auditLog: (id: string, action: string) => Promise<void>;
      *     }>({
      *       taskQueue: 'shared',
@@ -198,7 +198,7 @@ class WorkerService {
         // Register activities globally in the registry
         WorkerService.registerActivities(activities);
         // Use provided activityTaskQueue or fall back to config.taskQueue
-        const taskQueue = activityTaskQueue || config.taskQueue || 'memflow-activities';
+        const taskQueue = activityTaskQueue || config.taskQueue || 'durable-activities';
         // Append '-activity' suffix for the worker topic
         const activityTopic = `${taskQueue}-activity`;
         const targetNamespace = config?.namespace ?? factory_1.APP_ID;
@@ -249,14 +249,14 @@ class WorkerService {
             }
             catch (err) {
                 // Log error (note: we don't have access to this.activityRunner here)
-                console.error('memflow-worker-activity-err', {
+                console.error('durable-worker-activity-err', {
                     name: err.name,
                     message: err.message,
                     stack: err.stack,
                 });
-                if (!(err instanceof errors_1.MemFlowTimeoutError) &&
-                    !(err instanceof errors_1.MemFlowMaxedError) &&
-                    !(err instanceof errors_1.MemFlowFatalError)) {
+                if (!(err instanceof errors_1.DurableTimeoutError) &&
+                    !(err instanceof errors_1.DurableMaxedError) &&
+                    !(err instanceof errors_1.DurableFatalError)) {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
@@ -267,12 +267,12 @@ class WorkerService {
                             $error: {
                                 message: err.message,
                                 stack: err.stack,
-                                code: enums_1.HMSH_CODE_MEMFLOW_RETRYABLE,
+                                code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                             },
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowTimeoutError) {
+                else if (err instanceof errors_1.DurableTimeoutError) {
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: 596,
@@ -281,12 +281,12 @@ class WorkerService {
                             $error: {
                                 message: err.message,
                                 stack: err.stack,
-                                code: enums_1.HMSH_CODE_MEMFLOW_TIMEOUT,
+                                code: enums_1.HMSH_CODE_DURABLE_TIMEOUT,
                             },
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowMaxedError) {
+                else if (err instanceof errors_1.DurableMaxedError) {
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: 597,
@@ -295,12 +295,12 @@ class WorkerService {
                             $error: {
                                 message: err.message,
                                 stack: err.stack,
-                                code: enums_1.HMSH_CODE_MEMFLOW_MAXED,
+                                code: enums_1.HMSH_CODE_DURABLE_MAXED,
                             },
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowFatalError) {
+                else if (err instanceof errors_1.DurableFatalError) {
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: 598,
@@ -309,7 +309,7 @@ class WorkerService {
                             $error: {
                                 message: err.message,
                                 stack: err.stack,
-                                code: enums_1.HMSH_CODE_MEMFLOW_FATAL,
+                                code: enums_1.HMSH_CODE_DURABLE_FATAL,
                             },
                         },
                     };
@@ -322,12 +322,12 @@ class WorkerService {
      *
      * @example
      * ```typescript
-     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Durable } from '@hotmeshio/hotmesh';
      * import { Client as Postgres } from 'pg';
      * import * as workflows from './workflows';
      *
      * async function run() {
-     *   const worker = await MemFlow.Worker.create({
+     *   const worker = await Durable.Worker.create({
      *     connection: {
      *       class: Postgres,
      *       options: {
@@ -376,7 +376,7 @@ class WorkerService {
      * Run the connected worker; no-op (unnecessary to call)
      */
     async run() {
-        this.workflowRunner.engine.logger.info('memflow-worker-running');
+        this.workflowRunner.engine.logger.info('durable-worker-running');
     }
     /**
      * @private
@@ -425,19 +425,19 @@ class WorkerService {
                 };
             }
             catch (err) {
-                this.activityRunner.engine.logger.error('memflow-worker-activity-err', {
+                this.activityRunner.engine.logger.error('durable-worker-activity-err', {
                     name: err.name,
                     message: err.message,
                     stack: err.stack,
                 });
-                if (!(err instanceof errors_1.MemFlowTimeoutError) &&
-                    !(err instanceof errors_1.MemFlowMaxedError) &&
-                    !(err instanceof errors_1.MemFlowFatalError)) {
+                if (!(err instanceof errors_1.DurableTimeoutError) &&
+                    !(err instanceof errors_1.DurableMaxedError) &&
+                    !(err instanceof errors_1.DurableFatalError)) {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_MEMFLOW_RETRYABLE,
+                        code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
                             $error: {
@@ -449,7 +449,7 @@ class WorkerService {
                     };
                 }
                 return {
-                    //always returrn success (the MemFlow module is just fine);
+                    //always returrn success (the Durable module is just fine);
                     //  it's the user's function that has failed
                     status: stream_1.StreamStatus.SUCCESS,
                     code: err.code,
@@ -539,10 +539,11 @@ class WorkerService {
                 const [cursor, replay] = await store.findJobFields(workflowInput.workflowId, replayQuery, 50000, 5000);
                 context.set('replay', replay);
                 context.set('cursor', cursor); // if != 0, more remain
+                context.set('activityInterceptorService', index_1.Durable.getInterceptorService());
                 // Execute workflow with interceptors
                 const workflowResponse = await storage_1.asyncLocalStorage.run(context, async () => {
                     // Get the interceptor service
-                    const interceptorService = index_1.MemFlow.getInterceptorService();
+                    const interceptorService = index_1.Durable.getInterceptorService();
                     // Create the workflow execution function
                     const execWorkflow = async () => {
                         return await workflowFunction.apply(this, workflowInput.arguments);
@@ -555,24 +556,24 @@ class WorkerService {
                 if (interruptionRegistry.length > 0) {
                     const payload = interruptionRegistry[0];
                     switch (payload.type) {
-                        case 'MemFlowWaitForError':
-                            throw new errors_1.MemFlowWaitForError(payload);
-                        case 'MemFlowProxyError':
-                            throw new errors_1.MemFlowProxyError(payload);
-                        case 'MemFlowChildError':
-                            throw new errors_1.MemFlowChildError(payload);
-                        case 'MemFlowSleepError':
-                            throw new errors_1.MemFlowSleepError(payload);
-                        case 'MemFlowTimeoutError':
-                            throw new errors_1.MemFlowTimeoutError(payload.message, payload.stack);
-                        case 'MemFlowMaxedError':
-                            throw new errors_1.MemFlowMaxedError(payload.message, payload.stack);
-                        case 'MemFlowFatalError':
-                            throw new errors_1.MemFlowFatalError(payload.message, payload.stack);
-                        case 'MemFlowRetryError':
-                            throw new errors_1.MemFlowRetryError(payload.message, payload.stack);
+                        case 'DurableWaitForError':
+                            throw new errors_1.DurableWaitForError(payload);
+                        case 'DurableProxyError':
+                            throw new errors_1.DurableProxyError(payload);
+                        case 'DurableChildError':
+                            throw new errors_1.DurableChildError(payload);
+                        case 'DurableSleepError':
+                            throw new errors_1.DurableSleepError(payload);
+                        case 'DurableTimeoutError':
+                            throw new errors_1.DurableTimeoutError(payload.message, payload.stack);
+                        case 'DurableMaxedError':
+                            throw new errors_1.DurableMaxedError(payload.message, payload.stack);
+                        case 'DurableFatalError':
+                            throw new errors_1.DurableFatalError(payload.message, payload.stack);
+                        case 'DurableRetryError':
+                            throw new errors_1.DurableRetryError(payload.message, payload.stack);
                         default:
-                            throw new errors_1.MemFlowRetryError(`Unknown interruption type: ${payload.type}`);
+                            throw new errors_1.DurableRetryError(`Unknown interruption type: ${payload.type}`);
                     }
                 }
                 return {
@@ -586,7 +587,7 @@ class WorkerService {
                 if (isProcessing) {
                     return;
                 }
-                if (err instanceof errors_1.MemFlowWaitForError ||
+                if (err instanceof errors_1.DurableWaitForError ||
                     interruptionRegistry.length > 1) {
                     isProcessing = true;
                     //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
@@ -596,10 +597,10 @@ class WorkerService {
                     const collatorFlowId = `${(0, utils_1.guid)()}$C`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
-                        code: enums_1.HMSH_CODE_MEMFLOW_ALL,
+                        code: enums_1.HMSH_CODE_DURABLE_ALL,
                         metadata: { ...data.metadata },
                         data: {
-                            code: enums_1.HMSH_CODE_MEMFLOW_ALL,
+                            code: enums_1.HMSH_CODE_DURABLE_ALL,
                             items: [...interruptionRegistry],
                             size: interruptionRegistry.length,
                             workflowDimension: workflowDimension || '',
@@ -612,7 +613,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowSleepError) {
+                else if (err instanceof errors_1.DurableSleepError) {
                     //return the sleep interruption
                     isProcessing = true;
                     return {
@@ -632,7 +633,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowProxyError) {
+                else if (err instanceof errors_1.DurableProxyError) {
                     //return the proxyActivity interruption
                     isProcessing = true;
                     return {
@@ -662,7 +663,7 @@ class WorkerService {
                         },
                     };
                 }
-                else if (err instanceof errors_1.MemFlowChildError) {
+                else if (err instanceof errors_1.DurableChildError) {
                     //return the child interruption
                     isProcessing = true;
                     const msg = {
@@ -677,12 +678,12 @@ class WorkerService {
                         data: {
                             arguments: err.arguments,
                             await: err.await,
-                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_MEMFLOW_EXP_BACKOFF,
+                            backoffCoefficient: err.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
                             code: err.code,
                             index: err.index,
                             message: JSON.stringify(msg),
-                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
-                            maximumInterval: err.maximumInterval || (0, utils_1.s)(enums_1.HMSH_MEMFLOW_MAX_INTERVAL),
+                            maximumAttempts: err.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+                            maximumInterval: err.maximumInterval || (0, utils_1.s)(enums_1.HMSH_DURABLE_MAX_INTERVAL),
                             originJobId: err.originJobId,
                             entity: err.entity,
                             parentWorkflowId: err.parentWorkflowId,
@@ -700,7 +701,7 @@ class WorkerService {
                 isProcessing = true;
                 return {
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.MemFlowRetryError(err.message).code,
+                    code: err.code || new errors_1.DurableRetryError(err.message).code,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -708,7 +709,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.MemFlowRetryError(err.message).code,
+                            code: err.code || new errors_1.DurableRetryError(err.message).code,
                         },
                     },
                 };

package/build/services/{memflow → durable}/workflow/all.d.ts

@@ -4,20 +4,20 @@
  * deterministic execution counter. Use this when you need to run
  * multiple durable operations concurrently within a workflow function.
  *
- * In most cases, standard `Promise.all` works correctly for MemFlow
- * operations (e.g., parallel `waitFor` calls). Use `MemFlow.workflow.all`
+ * In most cases, standard `Promise.all` works correctly for Durable
+ * operations (e.g., parallel `waitFor` calls). Use `Durable.workflow.all`
  * when you observe counter-sequencing issues with complex parallel
  * patterns.
  *
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function parallelWorkflow(): Promise<[string, number]> {
- *   const { fetchName, fetchScore } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { fetchName, fetchScore } = Durable.workflow.proxyActivities<typeof activities>();
  *
- *   const [name, score] = await MemFlow.workflow.all(
+ *   const [name, score] = await Durable.workflow.all(
  *     fetchName('user-1'),
  *     fetchScore('user-1'),
  *   );

package/build/services/{memflow → durable}/workflow/all.js

@@ -7,20 +7,20 @@ exports.all = void 0;
  * deterministic execution counter. Use this when you need to run
  * multiple durable operations concurrently within a workflow function.
  *
- * In most cases, standard `Promise.all` works correctly for MemFlow
- * operations (e.g., parallel `waitFor` calls). Use `MemFlow.workflow.all`
+ * In most cases, standard `Promise.all` works correctly for Durable
+ * operations (e.g., parallel `waitFor` calls). Use `Durable.workflow.all`
  * when you observe counter-sequencing issues with complex parallel
  * patterns.
  *
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function parallelWorkflow(): Promise<[string, number]> {
- *   const { fetchName, fetchScore } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { fetchName, fetchScore } = Durable.workflow.proxyActivities<typeof activities>();
  *
- *   const [name, score] = await MemFlow.workflow.all(
+ *   const [name, score] = await Durable.workflow.all(
  *     fetchName('user-1'),
  *     fetchScore('user-1'),
  *   );

package/build/services/{memflow → durable}/workflow/common.d.ts

@@ -1,15 +1,15 @@
-import { MemFlowChildError, MemFlowFatalError, MemFlowMaxedError, MemFlowProxyError, MemFlowRetryError, MemFlowSleepError, MemFlowTimeoutError, MemFlowWaitForError } from '../../../modules/errors';
+import { DurableChildError, DurableFatalError, DurableMaxedError, DurableProxyError, DurableRetryError, DurableSleepError, DurableTimeoutError, DurableWaitForError } from '../../../modules/errors';
 import { KeyService, KeyType } from '../../../modules/key';
 import { asyncLocalStorage } from '../../../modules/storage';
 import { deterministicRandom, guid, s, sleepImmediate } from '../../../modules/utils';
 import { HotMesh } from '../../hotmesh';
 import { SerializerService } from '../../serializer';
-import { ActivityConfig, ChildResponseType, HookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions } from '../../../types/memflow';
+import { ActivityConfig, ChildResponseType, HookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions } from '../../../types/durable';
 import { JobInterruptOptions } from '../../../types/job';
 import { StreamCode, StreamStatus } from '../../../types/stream';
 import { StringAnyType, StringScalarType, StringStringType } from '../../../types/serializer';
-import { HMSH_CODE_MEMFLOW_CHILD, HMSH_CODE_MEMFLOW_FATAL, HMSH_CODE_MEMFLOW_MAXED, HMSH_CODE_MEMFLOW_PROXY, HMSH_CODE_MEMFLOW_SLEEP, HMSH_CODE_MEMFLOW_TIMEOUT, HMSH_CODE_MEMFLOW_WAIT, HMSH_MEMFLOW_EXP_BACKOFF, HMSH_MEMFLOW_MAX_ATTEMPTS, HMSH_MEMFLOW_MAX_INTERVAL } from '../../../modules/enums';
-import { MemFlowChildErrorType, MemFlowProxyErrorType } from '../../../types/error';
+import { HMSH_CODE_DURABLE_CHILD, HMSH_CODE_DURABLE_FATAL, HMSH_CODE_DURABLE_MAXED, HMSH_CODE_DURABLE_PROXY, HMSH_CODE_DURABLE_SLEEP, HMSH_CODE_DURABLE_TIMEOUT, HMSH_CODE_DURABLE_WAIT, HMSH_DURABLE_EXP_BACKOFF, HMSH_DURABLE_MAX_ATTEMPTS, HMSH_DURABLE_MAX_INTERVAL } from '../../../modules/enums';
+import { DurableChildErrorType, DurableProxyErrorType } from '../../../types/error';
 import { TelemetryService } from '../../telemetry';
 import { QuorumMessage } from '../../../types';
 import { UserMessage } from '../../../types/quorum';
@@ -17,4 +17,4 @@ import { Search } from '../search';
 import { WorkerService } from '../worker';
 import { Entity } from '../entity';
 import { ExecHookOptions } from './execHook';
-export { MemFlowChildError, MemFlowFatalError, MemFlowMaxedError, MemFlowProxyError, MemFlowRetryError, MemFlowSleepError, MemFlowTimeoutError, MemFlowWaitForError, KeyService, KeyType, asyncLocalStorage, deterministicRandom, guid, s, sleepImmediate, HotMesh, SerializerService, ActivityConfig, ChildResponseType, HookOptions, ExecHookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions, JobInterruptOptions, StreamCode, StreamStatus, StringAnyType, StringScalarType, StringStringType, HMSH_CODE_MEMFLOW_CHILD, HMSH_CODE_MEMFLOW_FATAL, HMSH_CODE_MEMFLOW_MAXED, HMSH_CODE_MEMFLOW_PROXY, HMSH_CODE_MEMFLOW_SLEEP, HMSH_CODE_MEMFLOW_TIMEOUT, HMSH_CODE_MEMFLOW_WAIT, HMSH_MEMFLOW_EXP_BACKOFF, HMSH_MEMFLOW_MAX_ATTEMPTS, HMSH_MEMFLOW_MAX_INTERVAL, MemFlowChildErrorType, MemFlowProxyErrorType, TelemetryService, QuorumMessage, UserMessage, Search, WorkerService, Entity, };
+export { DurableChildError, DurableFatalError, DurableMaxedError, DurableProxyError, DurableRetryError, DurableSleepError, DurableTimeoutError, DurableWaitForError, KeyService, KeyType, asyncLocalStorage, deterministicRandom, guid, s, sleepImmediate, HotMesh, SerializerService, ActivityConfig, ChildResponseType, HookOptions, ExecHookOptions, ProxyResponseType, ProxyType, WorkflowContext, WorkflowOptions, JobInterruptOptions, StreamCode, StreamStatus, StringAnyType, StringScalarType, StringStringType, HMSH_CODE_DURABLE_CHILD, HMSH_CODE_DURABLE_FATAL, HMSH_CODE_DURABLE_MAXED, HMSH_CODE_DURABLE_PROXY, HMSH_CODE_DURABLE_SLEEP, HMSH_CODE_DURABLE_TIMEOUT, HMSH_CODE_DURABLE_WAIT, HMSH_DURABLE_EXP_BACKOFF, HMSH_DURABLE_MAX_ATTEMPTS, HMSH_DURABLE_MAX_INTERVAL, DurableChildErrorType, DurableProxyErrorType, TelemetryService, QuorumMessage, UserMessage, Search, WorkerService, Entity, };

package/build/services/durable/workflow/common.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = exports.WorkerService = exports.Search = exports.TelemetryService = exports.HMSH_DURABLE_MAX_INTERVAL = exports.HMSH_DURABLE_MAX_ATTEMPTS = exports.HMSH_DURABLE_EXP_BACKOFF = exports.HMSH_CODE_DURABLE_WAIT = exports.HMSH_CODE_DURABLE_TIMEOUT = exports.HMSH_CODE_DURABLE_SLEEP = exports.HMSH_CODE_DURABLE_PROXY = exports.HMSH_CODE_DURABLE_MAXED = exports.HMSH_CODE_DURABLE_FATAL = exports.HMSH_CODE_DURABLE_CHILD = exports.StreamStatus = exports.SerializerService = exports.HotMesh = exports.sleepImmediate = exports.s = exports.guid = exports.deterministicRandom = exports.asyncLocalStorage = exports.KeyType = exports.KeyService = exports.DurableWaitForError = exports.DurableTimeoutError = exports.DurableSleepError = exports.DurableRetryError = exports.DurableProxyError = exports.DurableMaxedError = exports.DurableFatalError = exports.DurableChildError = void 0;
+const errors_1 = require("../../../modules/errors");
+Object.defineProperty(exports, "DurableChildError", { enumerable: true, get: function () { return errors_1.DurableChildError; } });
+Object.defineProperty(exports, "DurableFatalError", { enumerable: true, get: function () { return errors_1.DurableFatalError; } });
+Object.defineProperty(exports, "DurableMaxedError", { enumerable: true, get: function () { return errors_1.DurableMaxedError; } });
+Object.defineProperty(exports, "DurableProxyError", { enumerable: true, get: function () { return errors_1.DurableProxyError; } });
+Object.defineProperty(exports, "DurableRetryError", { enumerable: true, get: function () { return errors_1.DurableRetryError; } });
+Object.defineProperty(exports, "DurableSleepError", { enumerable: true, get: function () { return errors_1.DurableSleepError; } });
+Object.defineProperty(exports, "DurableTimeoutError", { enumerable: true, get: function () { return errors_1.DurableTimeoutError; } });
+Object.defineProperty(exports, "DurableWaitForError", { enumerable: true, get: function () { return errors_1.DurableWaitForError; } });
+const key_1 = require("../../../modules/key");
+Object.defineProperty(exports, "KeyService", { enumerable: true, get: function () { return key_1.KeyService; } });
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return key_1.KeyType; } });
+const storage_1 = require("../../../modules/storage");
+Object.defineProperty(exports, "asyncLocalStorage", { enumerable: true, get: function () { return storage_1.asyncLocalStorage; } });
+const utils_1 = require("../../../modules/utils");
+Object.defineProperty(exports, "deterministicRandom", { enumerable: true, get: function () { return utils_1.deterministicRandom; } });
+Object.defineProperty(exports, "guid", { enumerable: true, get: function () { return utils_1.guid; } });
+Object.defineProperty(exports, "s", { enumerable: true, get: function () { return utils_1.s; } });
+Object.defineProperty(exports, "sleepImmediate", { enumerable: true, get: function () { return utils_1.sleepImmediate; } });
+const hotmesh_1 = require("../../hotmesh");
+Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
+const serializer_1 = require("../../serializer");
+Object.defineProperty(exports, "SerializerService", { enumerable: true, get: function () { return serializer_1.SerializerService; } });
+const stream_1 = require("../../../types/stream");
+Object.defineProperty(exports, "StreamStatus", { enumerable: true, get: function () { return stream_1.StreamStatus; } });
+const enums_1 = require("../../../modules/enums");
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_CHILD", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_CHILD; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_FATAL", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_FATAL; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_MAXED", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_MAXED; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_PROXY", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_PROXY; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_SLEEP", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_SLEEP; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_TIMEOUT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_TIMEOUT; } });
+Object.defineProperty(exports, "HMSH_CODE_DURABLE_WAIT", { enumerable: true, get: function () { return enums_1.HMSH_CODE_DURABLE_WAIT; } });
+Object.defineProperty(exports, "HMSH_DURABLE_EXP_BACKOFF", { enumerable: true, get: function () { return enums_1.HMSH_DURABLE_EXP_BACKOFF; } });
+Object.defineProperty(exports, "HMSH_DURABLE_MAX_ATTEMPTS", { enumerable: true, get: function () { return enums_1.HMSH_DURABLE_MAX_ATTEMPTS; } });
+Object.defineProperty(exports, "HMSH_DURABLE_MAX_INTERVAL", { enumerable: true, get: function () { return enums_1.HMSH_DURABLE_MAX_INTERVAL; } });
+const telemetry_1 = require("../../telemetry");
+Object.defineProperty(exports, "TelemetryService", { enumerable: true, get: function () { return telemetry_1.TelemetryService; } });
+const search_1 = require("../search");
+Object.defineProperty(exports, "Search", { enumerable: true, get: function () { return search_1.Search; } });
+const worker_1 = require("../worker");
+Object.defineProperty(exports, "WorkerService", { enumerable: true, get: function () { return worker_1.WorkerService; } });
+const entity_1 = require("../entity");
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return entity_1.Entity; } });

package/build/services/{memflow → durable}/workflow/context.d.ts

@@ -11,11 +11,11 @@ import { WorkflowContext } from './common';
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Access the workflow ID and namespace
  * export async function contextAwareWorkflow(): Promise<string> {
- *   const ctx = MemFlow.workflow.getContext();
+ *   const ctx = Durable.workflow.getContext();
  *   console.log(`Running workflow ${ctx.workflowId} in ${ctx.namespace}`);
  *   return ctx.workflowId;
  * }
@@ -24,7 +24,7 @@ import { WorkflowContext } from './common';
  * ```typescript
  * // Check if the current execution is a replay
  * export async function replayAwareWorkflow(): Promise<void> {
- *   const { counter, workflowDimension } = MemFlow.workflow.getContext();
+ *   const { counter, workflowDimension } = Durable.workflow.getContext();
  *
  *   // Use context for logging/debugging
  *   console.log(`Execution counter: ${counter}, dimension: ${workflowDimension}`);
@@ -34,9 +34,9 @@ import { WorkflowContext } from './common';
  * ```typescript
  * // Pass context info to child workflows
  * export async function parentWorkflow(): Promise<void> {
- *   const { workflowId } = MemFlow.workflow.getContext();
+ *   const { workflowId } = Durable.workflow.getContext();
  *
- *   await MemFlow.workflow.execChild({
+ *   await Durable.workflow.execChild({
  *     taskQueue: 'children',
  *     workflowName: 'childWorkflow',
  *     args: [workflowId],  // pass parent ID to child

package/build/services/{memflow → durable}/workflow/context.js

@@ -14,11 +14,11 @@ const common_1 = require("./common");
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Access the workflow ID and namespace
  * export async function contextAwareWorkflow(): Promise<string> {
- *   const ctx = MemFlow.workflow.getContext();
+ *   const ctx = Durable.workflow.getContext();
  *   console.log(`Running workflow ${ctx.workflowId} in ${ctx.namespace}`);
  *   return ctx.workflowId;
  * }
@@ -27,7 +27,7 @@ const common_1 = require("./common");
  * ```typescript
  * // Check if the current execution is a replay
  * export async function replayAwareWorkflow(): Promise<void> {
- *   const { counter, workflowDimension } = MemFlow.workflow.getContext();
+ *   const { counter, workflowDimension } = Durable.workflow.getContext();
  *
  *   // Use context for logging/debugging
  *   console.log(`Execution counter: ${counter}, dimension: ${workflowDimension}`);
@@ -37,9 +37,9 @@ const common_1 = require("./common");
  * ```typescript
  * // Pass context info to child workflows
  * export async function parentWorkflow(): Promise<void> {
- *   const { workflowId } = MemFlow.workflow.getContext();
+ *   const { workflowId } = Durable.workflow.getContext();
  *
- *   await MemFlow.workflow.execChild({
+ *   await Durable.workflow.execChild({
  *     taskQueue: 'children',
  *     workflowName: 'childWorkflow',
  *     args: [workflowId],  // pass parent ID to child

package/build/services/{memflow → durable}/workflow/emit.d.ts

@@ -12,14 +12,14 @@ import { StringAnyType } from './common';
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Emit a domain event when an order is processed
  * export async function orderWorkflow(orderId: string): Promise<void> {
- *   const { processOrder } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { processOrder } = Durable.workflow.proxyActivities<typeof activities>();
  *   const result = await processOrder(orderId);
  *
- *   await MemFlow.workflow.emit({
+ *   await Durable.workflow.emit({
  *     'order.completed': { orderId, total: result.total },
  *     'analytics.event': { type: 'order', orderId },
  *   });
@@ -29,11 +29,11 @@ import { StringAnyType } from './common';
  * ```typescript
  * // Emit progress events during a long-running workflow
  * export async function batchWorkflow(items: string[]): Promise<void> {
- *   const { processItem } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { processItem } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   for (let i = 0; i < items.length; i++) {
  *     await processItem(items[i]);
- *     await MemFlow.workflow.emit(
+ *     await Durable.workflow.emit(
  *       { 'batch.progress': { completed: i + 1, total: items.length } },
  *       { once: false },  // emit on every execution (progress updates)
  *     );

package/build/services/{memflow → durable}/workflow/emit.js

@@ -16,14 +16,14 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Emit a domain event when an order is processed
  * export async function orderWorkflow(orderId: string): Promise<void> {
- *   const { processOrder } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { processOrder } = Durable.workflow.proxyActivities<typeof activities>();
  *   const result = await processOrder(orderId);
  *
- *   await MemFlow.workflow.emit({
+ *   await Durable.workflow.emit({
  *     'order.completed': { orderId, total: result.total },
  *     'analytics.event': { type: 'order', orderId },
  *   });
@@ -33,11 +33,11 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  * ```typescript
  * // Emit progress events during a long-running workflow
  * export async function batchWorkflow(items: string[]): Promise<void> {
- *   const { processItem } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { processItem } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   for (let i = 0; i < items.length; i++) {
  *     await processItem(items[i]);
- *     await MemFlow.workflow.emit(
+ *     await Durable.workflow.emit(
  *       { 'batch.progress': { completed: i + 1, total: items.length } },
  *       { once: false },  // emit on every execution (progress updates)
  *     );