@hotmeshio/hotmesh 0.0.8 → 0.0.10

package/LICENSE

@@ -178,13 +178,10 @@ Terms and Conditions for Use, Reproduction, and Distribution
       product that includes the Work or any part of it, as a commercial
       service to third parties, or in any other commercial context where
       you derive direct or indirect financial benefit from the use of the
-      Work. This includes, but is not limited to, providing 
-      routing-as-a-service, bpm-as-a-service, workflow-as-a-service,
-      integration-as-a-service, operational-data-as-a-service
-      or any other similar service that would compete with 
-      HotMesh's commercial offering of workflow and routing services.
-      Any such use requires explicit written permission from the
-      Licensor.
+      Work in a manner that would compete with the Licensor's commercial 
+      service-mesh-as-a-service, bpm-as-a-service, workflow-as-a-service,
+      integration-as-a-service or similar orchestration-type service.
+      Any such use requires explicit written permission from the Licensor.
 
    END OF TERMS AND CONDITIONS
 

package/README.md

@@ -1,7 +1,7 @@
 # HotMesh
 ![alpha release](https://img.shields.io/badge/release-alpha-yellow)
 
-Build sophisticated, durable workflows without the overhead of a dedicated server cluster. With HotMesh, your code remains front and center using [infrastructure](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh) you already own.
+Elevate Redis from an in-memory data store to a game-changing [service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/faq.md#what-is-hotmesh). Turn your unpredictable functions into unbreakable workflows.
 
 ## Install
 [![npm version](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh.svg)](https://badge.fury.io/js/%40hotmeshio%2Fhotmesh)
@@ -11,94 +11,91 @@ npm install @hotmeshio/hotmesh
 ```
 
 ## Design
-HotMesh's TypeScript SDK is modeled after [Temporal IO's](https://github.com/temporalio) developer-friendly approach. Design and deploy durable workflows using familiar paradigms that keep your code delightful to maintain. Deploying Temporal's [hello-world tutorial](https://github.com/temporalio/samples-typescript/tree/main/hello-world/src), for example, requires few changes beyond using the HotMesh SDK and saving to Redis.
+The HotMesh SDK is designed to keep your code front-and-center. Write functions as you normally would, then use the HotMesh to make them durable.
 
-**./activities.ts**
-```javascript
-export async function greet(name: string): Promise<string> {
-  return `Hello, ${name}!`;
-}
-```
-
-**./workflows.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
-
-const { greet } = Durable.workflow.proxyActivities<typeof activities>();
+1. Start by defining **activities**. Activities are those functions that will be invoked by your workflow. They are commonly used to read and write to databases and invoke external services. They can be written in any style, using any framework, and can even be legacy functions you've already written. The only requirement is that they return a Promise.
+    ```javascript
+    //activities.ts
 
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-```
-
-**./worker.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-import * as activities from './activities';
-
-async function run() {
-  const connection = await Durable.NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Durable.Worker.create({
-    connection,
-    namespace: 'default',
-    taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-```
+    export async function greet(name: string): Promise<string> {
+      return `Hello, ${name}!`;
+    }
 
-**./client.ts**
-```javascript
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
-import { v4 as uuidv4 } from 'uuid';
-
-async function run() {
-  const connection = await Durable.Connection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-
-  const client = new Durable.Client({
-    connection,
-  });
-
-  const handle = await client.workflow.start({
-    args: ['HotMesh'],
-    taskQueue: 'hello-world',
-    workflowName: 'example',
-    workflowId: 'workflow-' + uuidv4(),
-  });
-
-  console.log(`Started workflow ${handle.workflowId}`);
-  console.log(await handle.result());
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-```
+    export async function saludar(nombre: string): Promise<string> {
+      return `¡Hola, ${nombre}!`;
+    }
+    ```
+2. Define your **workflow** logic. Include conditional branching, loops, etc to control activity execution. It's vanilla code written in your own coding style. The only requirement is to use `proxyActivities`, ensuring your activities are executed with HotMesh's durability guarantee.
+    ```javascript
+    //workflows.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import * as activities from './activities';
+
+    const { greet, saludar } = Durable.workflow
+      .proxyActivities<typeof activities>({
+        activities
+      });
+
+    export async function example(name: string, lang: string): Promise<string> {
+      if (lang === 'es') {
+        return await saludar(name);
+      } else {
+        return await greet(name);
+      }
+    }
+    ```
+
+3. Although you could call your workflow directly (it's just a vanilla function), it's only durable when invoked and orchestrated via HotMesh. By using a HotMesh **client** to send the request, the function is guaranteed to return a result.
+    ```javascript
+    //client.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
+    import { v4 as uuidv4 } from 'uuid';
+
+    async function run(): Promise<string> {
+      const client = new Durable.Client({
+        connection: {
+          class: Redis,
+          options: { host: 'localhost', port: 6379 }
+        }
+      });
+
+      const handle = await client.workflow.start({
+        args: ['HotMesh', 'es'],
+        taskQueue: 'hello-world',
+        workflowName: 'example',
+        workflowId: uuidv4()
+      });
+
+      return await handle.result();
+      //returns '¡Hola, HotMesh!'
+    }
+    ```
+
+4. The last step is to create a **worker** that executes the workflow. Workers listen for tasks on their assigned channel, executing their assigned workflow function until it succeeds.
+    ```javascript
+    //worker.ts
+
+    import { Durable } from '@hotmeshio/hotmesh';
+    import Redis from 'ioredis';
+    import * as workflows from './workflows';
+
+    async function run() {
+      const worker = await Durable.Worker.create({
+        connection: {
+          class: Redis,
+          options: { host: 'localhost', port: 6379 },
+        },
+        taskQueue: 'hello-world',
+        workflow: workflows.example,
+      });
+      await worker.run();
+    }
+    ```
 
->HotMesh delivers durable function execution using a [distributed service mesh](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md). The design consumes leftover CPU on your microservices to execute workflows without the cost and complexity of a central server/control plane.
+>HotMesh delivers durable workflows without the cost and complexity of a centralized service mesh. Refer to the [samples-typescript](https://github.com/hotmeshio/samples-typescript) Git Repo for a range of examples, including compositional workflows (where one workflow calls another) and remote execution (where calls are brokered across microservices).
 
 ## Advanced Design
 HotMesh's TypeScript SDK is the easiest way to make your functions durable. But if you need full control over your function lifecycles (including high-volume, high-speed use cases), you can use HotMesh's underlying YAML models to optimize your durable workflows. The following model depicts a sequence of activities orchestrated by HotMesh. Any function you associate with a `topic` in your YAML definition is guaranteed to be durable.

package/build/{cjs/modules → modules}/key.d.ts

@@ -25,7 +25,7 @@
  * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
-declare const PSNS = "hmsh";
+declare const HMNS = "hmsh";
 declare enum KeyType {
     APP = 0,
     ENGINE_ID = 1,
@@ -72,4 +72,4 @@ declare class KeyService {
      */
     static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
 }
-export { KeyService, KeyType, KeyStoreParams, PSNS };
+export { KeyService, KeyType, KeyStoreParams, HMNS };

package/build/{cjs/modules → modules}/key.js

@@ -27,10 +27,10 @@
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PSNS = exports.KeyType = exports.KeyService = void 0;
+exports.HMNS = exports.KeyType = exports.KeyService = void 0;
 //default namespace for hotmesh
-const PSNS = "hmsh";
-exports.PSNS = PSNS;
+const HMNS = "hmsh";
+exports.HMNS = HMNS;
 //these are the entity types that are stored in the key/value store
 var KeyType;
 (function (KeyType) {

package/build/{esm/package.json → package.json}

@@ -1,14 +1,9 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.8",
+    "version": "0.0.10",
     "description": "Durable Workflows",
-    "main": "build/cjs/index.js",
-    "module": "build/esm/index.js",
-    "types": "build/cjs/index.d.ts",
-    "exports": {
-        "import": "./build/esm/index.js",
-        "require": "./build/cjs/index.js"
-    },
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
     },
     "scripts": {
         "clean": "rimraf ./build",
-        "build:cjs": "tsc --build tsconfig.cjs.json",
-        "build:esm": "tsc --build tsconfig.esm.json",
-        "build": "npm run build:cjs && npm run build:esm",
+        "build": "tsc --build tsconfig.json",
         "clean-build": "npm run clean && npm run build",
         "lint": "eslint . --ext .ts",
         "lint:fix": "eslint . --fix --ext .ts",

package/build/{cjs/services → services}/durable/native.js

@@ -10,7 +10,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -22,9 +22,8 @@ async function run() {
   });
   const worker = await Worker.create({
     connection,
-    namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/build/{esm/services → services}/durable/worker.d.ts

@@ -13,9 +13,7 @@ export declare class WorkerService {
      * dynamically importing the user's workflow module. That file
      * contains a call, `proxyActivities`, which needs this info.
      *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
+     * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
      */

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

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
@@ -37,7 +14,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -49,9 +26,8 @@ async function run() {
   });
   const worker = await Worker.create({
     connection,
-    namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -92,19 +68,19 @@ class WorkerService {
      * dynamically importing the user's workflow module. That file
      * contains a call, `proxyActivities`, which needs this info.
      *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
+     * NOTE: Because the worker imports the workflows dynamically AFTER
      * the activities are loaded, there will be items in the registry,
      * allowing proxyActivities to succeed.
      */
     static registerActivities(activities) {
-        if (typeof activities === 'function') {
+        if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
             WorkerService.activityRegistry[activities.name] = activities;
         }
         else {
             Object.keys(activities).forEach(key => {
-                WorkerService.activityRegistry[activities[key].name] = activities[key];
+                if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+                    WorkerService.activityRegistry[activities[key].name] = activities[key];
+                }
             });
         }
         return WorkerService.activityRegistry;
@@ -112,8 +88,8 @@ class WorkerService {
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
-        WorkerService.registerActivities(config.activities);
-        const workflow = await Promise.resolve(`${config.workflowsPath}`).then(s => __importStar(require(s)));
+        //user can provide the workflow file directly
+        const workflow = config.workflow;
         const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
         const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
         const activityTopic = `${baseTopic}-activity`;

package/build/{cjs/services → services}/durable/workflow.js

@@ -33,8 +33,10 @@ Here is an example of how the methods in this file are used:
 ./workflows.ts
 
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+import * as activities from './activities';
+
 const { greet } = Durable.workflow.proxyActivities<typeof activities>({
+  activities: activities,
   startToCloseTimeout: '1 minute',
   retryPolicy: {
     initialInterval: '5 seconds',  // Initial delay between retries
@@ -71,6 +73,9 @@ class WorkflowService {
         return result;
     }
     static proxyActivities(options) {
+        if (options.activities) {
+            worker_1.WorkerService.registerActivities(options.activities);
+        }
         const proxy = {};
         const keys = Object.keys(worker_1.WorkerService.activityRegistry);
         if (keys.length) {

package/build/{cjs/services → services}/hotmesh/index.js

@@ -17,7 +17,7 @@ class HotMeshService {
     }
     verifyAndSetNamespace(namespace) {
         if (!namespace) {
-            this.namespace = key_1.PSNS;
+            this.namespace = key_1.HMNS;
         }
         else if (!namespace.match(/^[A-Za-z0-9-]+$/)) {
             throw new Error(`config.namespace [${namespace}] is invalid`);

package/build/{cjs/services → services}/store/index.js

@@ -58,7 +58,7 @@ class StoreService {
         };
         this.redisClient = redisClient;
     }
-    async init(namespace = key_1.PSNS, appId, logger) {
+    async init(namespace = key_1.HMNS, appId, logger) {
         this.namespace = namespace;
         this.appId = appId;
         this.logger = logger;
@@ -111,7 +111,7 @@ class StoreService {
             if (bCreate) {
                 const packageJson = await Promise.resolve().then(() => __importStar(require('../../package.json')));
                 const version = packageJson['version'] || '0.0.0';
-                settings = { namespace: key_1.PSNS, version };
+                settings = { namespace: key_1.HMNS, version };
                 await this.setSettings(settings);
                 return settings;
             }

package/build/{cjs/services → services}/stream/clients/ioredis.js

@@ -7,7 +7,7 @@ class IORedisStreamService extends index_1.StreamService {
     constructor(redisClient) {
         super(redisClient);
     }
-    async init(namespace = key_1.PSNS, appId, logger) {
+    async init(namespace = key_1.HMNS, appId, logger) {
         this.namespace = namespace;
         this.logger = logger;
         this.appId = appId;

package/build/{cjs/services → services}/stream/clients/redis.js

@@ -7,7 +7,7 @@ class RedisStreamService extends index_1.StreamService {
     constructor(redisClient) {
         super(redisClient);
     }
-    async init(namespace = key_1.PSNS, appId, logger) {
+    async init(namespace = key_1.HMNS, appId, logger) {
         this.namespace = namespace;
         this.logger = logger;
         this.appId = appId;

package/build/{cjs/services → services}/sub/clients/ioredis.js

@@ -7,7 +7,7 @@ class IORedisSubService extends index_1.SubService {
     constructor(redisClient) {
         super(redisClient);
     }
-    async init(namespace = key_1.PSNS, appId, engineId, logger) {
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
         this.namespace = namespace;
         this.logger = logger;
         this.appId = appId;

package/build/{cjs/services → services}/sub/clients/redis.js

@@ -7,7 +7,7 @@ class RedisSubService extends index_1.SubService {
     constructor(redisClient) {
         super(redisClient);
     }
-    async init(namespace = key_1.PSNS, appId, engineId, logger) {
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
         this.namespace = namespace;
         this.logger = logger;
         this.appId = appId;

package/build/{cjs/types → types}/durable.d.ts

@@ -32,12 +32,9 @@ type Registry = {
 };
 type WorkerConfig = {
     connection: Connection;
-    namespace: string;
+    namespace?: string;
     taskQueue: string;
-    workflowsPath: string;
-    activities: {
-        [key: string]: Function;
-    };
+    workflow: Function;
 };
 type ContextType = {
     workflowId: string;
@@ -48,8 +45,9 @@ type ProxyType<ACT> = {
     [K in keyof ACT]: FunctionSignature<ACT[K]>;
 };
 type ActivityConfig = {
-    startToCloseTimeout: string;
-    retryPolicy: {
+    startToCloseTimeout?: string;
+    activities?: any;
+    retryPolicy?: {
         initialInterval: string;
         maximumAttempts: number;
         backoffCoefficient: number;

package/modules/key.ts

@@ -27,7 +27,7 @@
  */
 
 //default namespace for hotmesh
-const PSNS = "hmsh";
+const HMNS = "hmsh";
 
 //these are the entity types that are stored in the key/value store
 enum KeyType {
@@ -126,4 +126,4 @@ class KeyService {
   }
 }
 
-export { KeyService, KeyType, KeyStoreParams, PSNS };
+export { KeyService, KeyType, KeyStoreParams, HMNS };

package/package.json

@@ -1,14 +1,9 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Durable Workflows",
-  "main": "build/cjs/index.js",
-  "module": "build/esm/index.js",
-  "types": "build/cjs/index.d.ts",
-  "exports": {
-    "import": "./build/esm/index.js",
-    "require": "./build/cjs/index.js"
-  },
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -19,9 +14,7 @@
   },
   "scripts": {
     "clean": "rimraf ./build",
-    "build:cjs": "tsc --build tsconfig.cjs.json",
-    "build:esm": "tsc --build tsconfig.esm.json",
-    "build": "npm run build:cjs && npm run build:esm",
+    "build": "tsc --build tsconfig.json",
     "clean-build": "npm run clean && npm run build",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --fix --ext .ts",

package/services/durable/native.ts

@@ -9,7 +9,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -21,9 +21,8 @@ async function run() {
   });
   const worker = await Worker.create({
     connection,
-    namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();

package/services/durable/worker.ts

@@ -13,7 +13,7 @@ Here is an example of how the methods in this file are used:
 import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
 
-import * as activities from './activities';
+import * as workflows from './workflows';
 
 async function run() {
   const connection = await NativeConnection.connect({
@@ -25,9 +25,8 @@ async function run() {
   });
   const worker = await Worker.create({
     connection,
-    namespace: 'default',
     taskQueue: 'hello-world',
-    workflowsPath: require.resolve('./workflows'),
+    workflow: workflows.example,
     activities,
   });
   await worker.run();
@@ -86,18 +85,18 @@ export class WorkerService {
    * dynamically importing the user's workflow module. That file
    * contains a call, `proxyActivities`, which needs this info.
    * 
-   * NOTE: The `worker` and `client` both call `proxyActivities`,
-   * as a natural result of importing worflows.ts. However,
-   * because the worker imports the workflows dynamically AFTER
+   * NOTE: Because the worker imports the workflows dynamically AFTER
    * the activities are loaded, there will be items in the registry,
    * allowing proxyActivities to succeed.
    */
   static registerActivities<ACT>(activities: ACT): Registry  {
-    if (typeof activities === 'function') {
+    if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
       WorkerService.activityRegistry[activities.name] = activities as Function;
     } else {
       Object.keys(activities).forEach(key => {
-        WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
+          WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        }
       });
     }
     return WorkerService.activityRegistry;
@@ -106,8 +105,8 @@ export class WorkerService {
   static async create(config: WorkerConfig) {
     //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
-    WorkerService.registerActivities<typeof config.activities>(config.activities);
-    const workflow = await import(config.workflowsPath);
+    //user can provide the workflow file directly
+    const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
     const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
     const activityTopic = `${baseTopic}-activity`;

package/services/durable/workflow.ts

@@ -31,8 +31,10 @@ Here is an example of how the methods in this file are used:
 ./workflows.ts
 
 import { Durable } from '@hotmeshio/hotmesh';
-import type * as activities from './activities';
+import * as activities from './activities';
+
 const { greet } = Durable.workflow.proxyActivities<typeof activities>({
+  activities: activities,
   startToCloseTimeout: '1 minute',
   retryPolicy: {
     initialInterval: '5 seconds',  // Initial delay between retries
@@ -72,6 +74,10 @@ export class WorkflowService {
   }
 
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
+    if (options.activities) {
+      WorkerService.registerActivities(options.activities)
+    }
+
     const proxy: any = {};
     const keys = Object.keys(WorkerService.activityRegistry);
     if (keys.length) {