@hotmeshio/hotmesh 0.6.0 → 0.7.0

package/build/services/memflow/index.d.ts

@@ -1,4 +1,5 @@
 import { ContextType, WorkflowInterceptor } from '../../types/memflow';
+import { guid } from '../../modules/utils';
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
 import { Search } from './search';
@@ -61,6 +62,7 @@ import { didInterrupt } from './workflow/interruption';
  * ### 3. Durable Activities & Proxies
  * Define and execute durable activities with automatic retry:
  * ```typescript
+ * // Default: activities use workflow's task queue
  * const activities = MemFlow.workflow.proxyActivities<{
  *   analyzeDocument: typeof analyzeDocument;
  *   validateFindings: typeof validateFindings;
@@ -77,7 +79,29 @@ import { didInterrupt } from './workflow/interruption';
  * const validation = await activities.validateFindings(analysis);
  * ```
  *
- * ### 4. Workflow Composition
+ * ### 4. Explicit Activity Registration
+ * Register activity workers explicitly before workflows start:
+ * ```typescript
+ * // Register shared activity pool for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'shared-activities'
+ * }, sharedActivities, 'shared-activities');
+ *
+ * // Register custom activity pool for specific use cases
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'priority-activities'
+ * }, priorityActivities, 'priority-activities');
+ * ```
+ *
+ * ### 5. Workflow Composition
  * Build complex workflows through composition:
  * ```typescript
  * // Start a child workflow
@@ -100,29 +124,34 @@ import { didInterrupt } from './workflow/interruption';
  * });
  * ```
  *
- * ### 5. Workflow Interceptors
+ * ### 6. Workflow Interceptors
  * Add cross-cutting concerns through interceptors that run as durable functions:
  * ```typescript
- * // Add audit interceptor that uses MemFlow functions
+ * // First register shared activity worker for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'interceptor-activities'
+ * }, { auditLog }, 'interceptor-activities');
+ *
+ * // Add audit interceptor that uses activities with explicit taskQueue
  * MemFlow.registerInterceptor({
  *   async execute(ctx, next) {
  *     try {
- *       // Interceptors can use MemFlow functions and participate in replay
- *       const entity = await MemFlow.workflow.entity();
- *       await entity.append('auditLog', {
- *         action: 'started',
- *         timestamp: new Date().toISOString()
+ *       // Interceptors use explicit taskQueue to prevent per-workflow queues
+ *       const { auditLog } = MemFlow.workflow.proxyActivities<typeof activities>({
+ *         activities: { auditLog },
+ *         taskQueue: 'interceptor-activities', // Explicit shared queue
+ *         retryPolicy: { maximumAttempts: 3 }
  *       });
  *
- *       // Rate limiting with durable sleep
- *       await MemFlow.workflow.sleepFor('100 milliseconds');
+ *       await auditLog(ctx.get('workflowId'), 'started');
  *
  *       const result = await next();
  *
- *       await entity.append('auditLog', {
- *         action: 'completed',
- *         timestamp: new Date().toISOString()
- *       });
+ *       await auditLog(ctx.get('workflowId'), 'completed');
  *
  *       return result;
  *     } catch (err) {
@@ -141,6 +170,16 @@ import { didInterrupt } from './workflow/interruption';
  * ```typescript
  * import { Client, Worker, MemFlow } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
+ * import * as activities from './activities';
+ *
+ * // (Optional) Register shared activity workers for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'shared-activities'
+ * }, sharedActivities, 'shared-activities');
  *
  * // Initialize worker
  * await Worker.create({
@@ -210,6 +249,49 @@ declare class MemFlowClass {
      * equivalent to the Temporal `Worker` service.
      */
     static Worker: typeof WorkerService;
+    /**
+     * Register activity workers for a task queue. Activities execute via message queue
+     * and can run on different servers from workflows.
+     *
+     * @example
+     * ```typescript
+     * // Activity worker
+     * const activities = {
+     *   async processPayment(amount: number) { return `Processed $${amount}`; },
+     *   async sendEmail(to: string, msg: string) { /* ... *\/ }
+     * };
+     *
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'payment'
+     * }, activities, 'payment');
+     *
+     * // Workflow worker (can be on different server)
+     * async function orderWorkflow(amount: number) {
+     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *     processPayment: (amount: number) => Promise<string>;
+     *     sendEmail: (to: string, msg: string) => Promise<void>;
+     *   }>({
+     *     taskQueue: 'payment',
+     *     retryPolicy: { maximumAttempts: 3 }
+     *   });
+     *
+     *   const result = await processPayment(amount);
+     *   await sendEmail('customer@example.com', result);
+     *   return result;
+     * }
+     *
+     * await MemFlow.Worker.create({
+     *   connection: { class: Postgres, options: { connectionString: '...' } },
+     *   taskQueue: 'orders',
+     *   workflow: orderWorkflow
+     * });
+     * ```
+     */
+    static registerActivityWorker: typeof WorkerService.registerActivityWorker;
     /**
      * The MemFlow `workflow` service is functionally
      * equivalent to the Temporal `Workflow` service
@@ -234,6 +316,10 @@ declare class MemFlowClass {
      * Clear all registered workflow interceptors
      */
     static clearInterceptors(): void;
+    /**
+     * Generate a unique identifier for workflow IDs
+     */
+    static guid: typeof guid;
     /**
      * Shutdown everything. All connections, workers, and clients will be closed.
      * Include in your signal handlers to ensure a clean shutdown.

package/build/services/memflow/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemFlow = void 0;
 const hotmesh_1 = require("../hotmesh");
+const utils_1 = require("../../modules/utils");
 const client_1 = require("./client");
 const connection_1 = require("./connection");
 const search_1 = require("./search");
@@ -65,6 +66,7 @@ const interceptor_1 = require("./interceptor");
  * ### 3. Durable Activities & Proxies
  * Define and execute durable activities with automatic retry:
  * ```typescript
+ * // Default: activities use workflow's task queue
  * const activities = MemFlow.workflow.proxyActivities<{
  *   analyzeDocument: typeof analyzeDocument;
  *   validateFindings: typeof validateFindings;
@@ -81,7 +83,29 @@ const interceptor_1 = require("./interceptor");
  * const validation = await activities.validateFindings(analysis);
  * ```
  *
- * ### 4. Workflow Composition
+ * ### 4. Explicit Activity Registration
+ * Register activity workers explicitly before workflows start:
+ * ```typescript
+ * // Register shared activity pool for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'shared-activities'
+ * }, sharedActivities, 'shared-activities');
+ *
+ * // Register custom activity pool for specific use cases
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'priority-activities'
+ * }, priorityActivities, 'priority-activities');
+ * ```
+ *
+ * ### 5. Workflow Composition
  * Build complex workflows through composition:
  * ```typescript
  * // Start a child workflow
@@ -104,29 +128,34 @@ const interceptor_1 = require("./interceptor");
  * });
  * ```
  *
- * ### 5. Workflow Interceptors
+ * ### 6. Workflow Interceptors
  * Add cross-cutting concerns through interceptors that run as durable functions:
  * ```typescript
- * // Add audit interceptor that uses MemFlow functions
+ * // First register shared activity worker for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'interceptor-activities'
+ * }, { auditLog }, 'interceptor-activities');
+ *
+ * // Add audit interceptor that uses activities with explicit taskQueue
  * MemFlow.registerInterceptor({
  *   async execute(ctx, next) {
  *     try {
- *       // Interceptors can use MemFlow functions and participate in replay
- *       const entity = await MemFlow.workflow.entity();
- *       await entity.append('auditLog', {
- *         action: 'started',
- *         timestamp: new Date().toISOString()
+ *       // Interceptors use explicit taskQueue to prevent per-workflow queues
+ *       const { auditLog } = MemFlow.workflow.proxyActivities<typeof activities>({
+ *         activities: { auditLog },
+ *         taskQueue: 'interceptor-activities', // Explicit shared queue
+ *         retryPolicy: { maximumAttempts: 3 }
  *       });
  *
- *       // Rate limiting with durable sleep
- *       await MemFlow.workflow.sleepFor('100 milliseconds');
+ *       await auditLog(ctx.get('workflowId'), 'started');
  *
  *       const result = await next();
  *
- *       await entity.append('auditLog', {
- *         action: 'completed',
- *         timestamp: new Date().toISOString()
- *       });
+ *       await auditLog(ctx.get('workflowId'), 'completed');
  *
  *       return result;
  *     } catch (err) {
@@ -145,6 +174,16 @@ const interceptor_1 = require("./interceptor");
  * ```typescript
  * import { Client, Worker, MemFlow } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
+ * import * as activities from './activities';
+ *
+ * // (Optional) Register shared activity workers for interceptors
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'shared-activities'
+ * }, sharedActivities, 'shared-activities');
  *
  * // Initialize worker
  * await Worker.create({
@@ -245,6 +284,49 @@ MemFlowClass.Handle = handle_1.WorkflowHandleService;
  * equivalent to the Temporal `Worker` service.
  */
 MemFlowClass.Worker = worker_1.WorkerService;
+/**
+ * Register activity workers for a task queue. Activities execute via message queue
+ * and can run on different servers from workflows.
+ *
+ * @example
+ * ```typescript
+ * // Activity worker
+ * const activities = {
+ *   async processPayment(amount: number) { return `Processed $${amount}`; },
+ *   async sendEmail(to: string, msg: string) { /* ... *\/ }
+ * };
+ *
+ * await MemFlow.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'payment'
+ * }, activities, 'payment');
+ *
+ * // Workflow worker (can be on different server)
+ * async function orderWorkflow(amount: number) {
+ *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+ *     processPayment: (amount: number) => Promise<string>;
+ *     sendEmail: (to: string, msg: string) => Promise<void>;
+ *   }>({
+ *     taskQueue: 'payment',
+ *     retryPolicy: { maximumAttempts: 3 }
+ *   });
+ *
+ *   const result = await processPayment(amount);
+ *   await sendEmail('customer@example.com', result);
+ *   return result;
+ * }
+ *
+ * await MemFlow.Worker.create({
+ *   connection: { class: Postgres, options: { connectionString: '...' } },
+ *   taskQueue: 'orders',
+ *   workflow: orderWorkflow
+ * });
+ * ```
+ */
+MemFlowClass.registerActivityWorker = worker_1.WorkerService.registerActivityWorker;
 /**
  * The MemFlow `workflow` service is functionally
  * equivalent to the Temporal `Workflow` service
@@ -260,3 +342,7 @@ MemFlowClass.workflow = workflow_1.WorkflowService;
  */
 MemFlowClass.didInterrupt = interruption_1.didInterrupt;
 MemFlowClass.interceptorService = new interceptor_1.InterceptorService();
+/**
+ * Generate a unique identifier for workflow IDs
+ */
+MemFlowClass.guid = utils_1.guid;

package/build/services/memflow/worker.d.ts

@@ -1,5 +1,6 @@
 import { HotMesh } from '../hotmesh';
 import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/memflow';
+import { StreamData, StreamDataResponse } from '../../types/stream';
 /**
  * The *Worker* service Registers worker functions and connects them to the mesh,
  * using the target backend provider/s (Postgres, NATS, etc).
@@ -58,6 +59,102 @@ export declare class WorkerService {
      * @private
      */
     static registerActivities<ACT>(activities: ACT): Registry;
+    /**
+     * Register activity workers for a task queue. Activities are invoked via message queue,
+     * so they can run on different servers from workflows.
+     *
+     * The task queue name gets `-activity` appended automatically for the worker topic.
+     * For example, `taskQueue: 'payment'` creates a worker listening on `payment-activity`.
+     *
+     * @param config - Worker configuration (connection, namespace, taskQueue)
+     * @param activities - Activity functions to register
+     * @param activityTaskQueue - Task queue name (without `-activity` suffix).
+     *                            Defaults to `config.taskQueue` if not provided.
+     *
+     * @returns Promise<HotMesh> The initialized activity worker
+     *
+     * @example
+     * ```typescript
+     * // Activity worker (can be on separate server)
+     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Client as Postgres } from 'pg';
+     *
+     * const activities = {
+     *   async processPayment(amount: number): Promise<string> {
+     *     return `Processed $${amount}`;
+     *   },
+     *   async sendEmail(to: string, subject: string): Promise<void> {
+     *     // Send email
+     *   }
+     * };
+     *
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'payment'  // Listens on 'payment-activity'
+     * }, activities, 'payment');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Workflow worker (can be on different server)
+     * async function orderWorkflow(orderId: string, amount: number) {
+     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *     processPayment: (amount: number) => Promise<string>;
+     *     sendEmail: (to: string, subject: string) => Promise<void>;
+     *   }>({
+     *     taskQueue: 'payment',
+     *     retryPolicy: { maximumAttempts: 3 }
+     *   });
+     *
+     *   const result = await processPayment(amount);
+     *   await sendEmail('customer@example.com', 'Order confirmed');
+     *   return result;
+     * }
+     *
+     * await MemFlow.Worker.create({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'orders',
+     *   workflow: orderWorkflow
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Shared activity pool for interceptors
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'shared'
+     * }, { auditLog, collectMetrics }, 'shared');
+     *
+     * const interceptor: WorkflowInterceptor = {
+     *   async execute(ctx, next) {
+     *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+     *       auditLog: (id: string, action: string) => Promise<void>;
+     *     }>({
+     *       taskQueue: 'shared',
+     *       retryPolicy: { maximumAttempts: 3 }
+     *     });
+     *     await auditLog(ctx.get('workflowId'), 'started');
+     *     return next();
+     *   }
+     * };
+     * ```
+     */
+    static registerActivityWorker(config: Partial<WorkerConfig>, activities: any, activityTaskQueue?: string): Promise<HotMesh>;
+    /**
+     * Create an activity callback function that can be used by activity workers
+     * @private
+     */
+    static createActivityCallback(): (payload: StreamData) => Promise<StreamDataResponse>;
     /**
      * Connects a worker to the mesh.
      *

package/build/services/memflow/worker.js

@@ -104,6 +104,219 @@ class WorkerService {
         }
         return WorkerService.activityRegistry;
     }
+    /**
+     * Register activity workers for a task queue. Activities are invoked via message queue,
+     * so they can run on different servers from workflows.
+     *
+     * The task queue name gets `-activity` appended automatically for the worker topic.
+     * For example, `taskQueue: 'payment'` creates a worker listening on `payment-activity`.
+     *
+     * @param config - Worker configuration (connection, namespace, taskQueue)
+     * @param activities - Activity functions to register
+     * @param activityTaskQueue - Task queue name (without `-activity` suffix).
+     *                            Defaults to `config.taskQueue` if not provided.
+     *
+     * @returns Promise<HotMesh> The initialized activity worker
+     *
+     * @example
+     * ```typescript
+     * // Activity worker (can be on separate server)
+     * import { MemFlow } from '@hotmeshio/hotmesh';
+     * import { Client as Postgres } from 'pg';
+     *
+     * const activities = {
+     *   async processPayment(amount: number): Promise<string> {
+     *     return `Processed $${amount}`;
+     *   },
+     *   async sendEmail(to: string, subject: string): Promise<void> {
+     *     // Send email
+     *   }
+     * };
+     *
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'payment'  // Listens on 'payment-activity'
+     * }, activities, 'payment');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Workflow worker (can be on different server)
+     * async function orderWorkflow(orderId: string, amount: number) {
+     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *     processPayment: (amount: number) => Promise<string>;
+     *     sendEmail: (to: string, subject: string) => Promise<void>;
+     *   }>({
+     *     taskQueue: 'payment',
+     *     retryPolicy: { maximumAttempts: 3 }
+     *   });
+     *
+     *   const result = await processPayment(amount);
+     *   await sendEmail('customer@example.com', 'Order confirmed');
+     *   return result;
+     * }
+     *
+     * await MemFlow.Worker.create({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'orders',
+     *   workflow: orderWorkflow
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Shared activity pool for interceptors
+     * await MemFlow.registerActivityWorker({
+     *   connection: {
+     *     class: Postgres,
+     *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+     *   },
+     *   taskQueue: 'shared'
+     * }, { auditLog, collectMetrics }, 'shared');
+     *
+     * const interceptor: WorkflowInterceptor = {
+     *   async execute(ctx, next) {
+     *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+     *       auditLog: (id: string, action: string) => Promise<void>;
+     *     }>({
+     *       taskQueue: 'shared',
+     *       retryPolicy: { maximumAttempts: 3 }
+     *     });
+     *     await auditLog(ctx.get('workflowId'), 'started');
+     *     return next();
+     *   }
+     * };
+     * ```
+     */
+    static async registerActivityWorker(config, activities, activityTaskQueue) {
+        // 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';
+        // Append '-activity' suffix for the worker topic
+        const activityTopic = `${taskQueue}-activity`;
+        const targetNamespace = config?.namespace ?? factory_1.APP_ID;
+        const optionsHash = WorkerService.hashOptions(config?.connection);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
+        // Return existing worker if already initialized (idempotent)
+        if (WorkerService.instances.has(targetTopic)) {
+            return await WorkerService.instances.get(targetTopic);
+        }
+        // Create activity worker that listens on '{taskQueue}-activity' topic
+        const hotMeshWorker = await hotmesh_1.HotMesh.init({
+            guid: config.guid ? `${config.guid}XA` : undefined,
+            taskQueue,
+            logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
+            appId: targetNamespace,
+            engine: { connection: config.connection },
+            workers: [
+                {
+                    topic: activityTopic,
+                    connection: config.connection,
+                    callback: WorkerService.createActivityCallback(),
+                },
+            ],
+        });
+        WorkerService.instances.set(targetTopic, hotMeshWorker);
+        return hotMeshWorker;
+    }
+    /**
+     * Create an activity callback function that can be used by activity workers
+     * @private
+     */
+    static createActivityCallback() {
+        return async (data) => {
+            try {
+                //always run the activity function when instructed; return the response
+                const activityInput = data.data;
+                const activityName = activityInput.activityName;
+                const activityFunction = WorkerService.activityRegistry[activityName];
+                if (!activityFunction) {
+                    throw new Error(`Activity '${activityName}' not found in registry`);
+                }
+                const pojoResponse = await activityFunction.apply(null, activityInput.arguments);
+                return {
+                    status: stream_1.StreamStatus.SUCCESS,
+                    metadata: { ...data.metadata },
+                    data: { response: pojoResponse },
+                };
+            }
+            catch (err) {
+                // Log error (note: we don't have access to this.activityRunner here)
+                console.error('memflow-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)) {
+                    //use code 599 as a proxy for all retryable errors
+                    // (basically anything not 596, 597, 598)
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 599,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_RETRYABLE,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowTimeoutError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 596,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_TIMEOUT,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowMaxedError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 597,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_MAXED,
+                            },
+                        },
+                    };
+                }
+                else if (err instanceof errors_1.MemFlowFatalError) {
+                    return {
+                        status: stream_1.StreamStatus.SUCCESS,
+                        code: 598,
+                        metadata: { ...data.metadata },
+                        data: {
+                            $error: {
+                                message: err.message,
+                                stack: err.stack,
+                                code: enums_1.HMSH_CODE_MEMFLOW_FATAL,
+                            },
+                        },
+                    };
+                }
+            }
+        };
+    }
     /**
      * Connects a worker to the mesh.
      *
@@ -173,6 +386,10 @@ class WorkerService {
         const targetNamespace = config?.namespace ?? factory_1.APP_ID;
         const optionsHash = WorkerService.hashOptions(config?.connection);
         const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
+        // Return existing worker if already initialized
+        if (WorkerService.instances.has(targetTopic)) {
+            return await WorkerService.instances.get(targetTopic);
+        }
         const hotMeshWorker = await hotmesh_1.HotMesh.init({
             guid: config.guid ? `${config.guid}XA` : undefined,
             taskQueue: config.taskQueue,