@hotmeshio/hotmesh 0.0.1

package/services/connector/clients/ioredis.ts

@@ -0,0 +1,57 @@
+import {
+  RedisClientOptions,
+  RedisClassType,
+  RedisClientType } from '../../../types/ioredisclient';
+
+class RedisConnection {
+  private connection: any | null = null;
+  private static instances: Map<string, RedisConnection> = new Map();
+  private id: string | null = null;
+
+  private static clientOptions: RedisClientOptions = {
+    host: 'localhost',
+    port: 6379,
+    //password: config.REDIS_PASSWORD,
+    //db: config.REDIS_DATABASE,
+  };
+
+  private async createConnection(Redis: RedisClassType, options: RedisClientOptions): Promise<any> {
+    return new Redis(options);
+  }
+
+  public getClient(): RedisClientType {
+    if (!this.connection) {
+      throw new Error('Redis client is not connected');
+    }
+    return this.connection;
+  }
+
+  public async disconnect(): Promise<void> {
+    if (this.connection) {
+      await this.connection.quit();
+      this.connection = null;
+    }
+    if (this.id) {
+      RedisConnection.instances.delete(this.id);
+    }
+  }
+
+  public static async connect(id: string, Redis: RedisClassType, options?: RedisClientOptions): Promise<RedisConnection> {
+    if (this.instances.has(id)) {
+      return this.instances.get(id) as RedisConnection;
+    }
+    const instance = new RedisConnection();
+    const opts = options ? { ...options } : { ...this.clientOptions };
+    instance.connection = await instance.createConnection(Redis, opts);
+    instance.id = id;
+    this.instances.set(id, instance);
+    return instance;
+  }
+
+  public static async disconnectAll(): Promise<void> {
+    await Promise.all(Array.from(this.instances.values()).map((instance) => instance.disconnect()));
+    this.instances.clear();
+  }
+}
+
+export { RedisConnection };

package/services/connector/clients/redis.ts

@@ -0,0 +1,72 @@
+import {
+  RedisClientType,
+  RedisClientOptions,
+  RedisClassType } from '../../../types/redisclient';
+
+class RedisConnection {
+  private connection: RedisClientType | null = null;
+  private static instances: Map<string, RedisConnection> = new Map();
+  private id: string | null = null;
+
+  private static clientOptions: RedisClientOptions = {
+    socket: {
+      host: 'localhost',
+      port: 6379,
+      tls: false,
+    },
+    //password: config.REDIS_PASSWORD,
+    //database: config.REDIS_DATABASE,
+  };
+
+  private async createConnection(Redis: RedisClassType, options: RedisClientOptions): Promise<RedisClientType> {
+    return new Promise((resolve, reject) => {
+      const client = Redis.createClient(options);
+
+      client.on('error', (error: any) => {
+        reject(error);
+      });
+
+      client.on('ready', () => {
+        resolve(client);
+      });
+
+      client.connect();
+    });
+  }
+
+  public getClient(): RedisClientType {
+    if (!this.connection) {
+      throw new Error('Redis client is not connected');
+    }
+    return this.connection;
+  }
+
+  public async disconnect(): Promise<void> {
+    if (this.connection) {
+      await this.connection.quit();
+      this.connection = null;
+    }
+    if (this.id) {
+      RedisConnection.instances.delete(this.id);
+    }
+  }
+
+  public static async connect(id: string, Redis: RedisClassType, options?: RedisClientOptions): Promise<RedisConnection> {
+    if (this.instances.has(id)) {
+      return this.instances.get(id)!;
+    }
+    const instance = new RedisConnection();
+    const opts = options ? { ...options } : { ...this.clientOptions };
+    instance.connection = await instance.createConnection(Redis, opts);
+    instance.id = id;
+    this.instances.set(id, instance);
+    return instance;
+  }
+
+  public static async disconnectAll(): Promise<void> {
+    await Promise.all(Array.from(this.instances.values()).map((instance) => instance.disconnect()));
+    this.instances.clear();
+  }
+}
+
+export { RedisConnection, RedisClientType };

package/services/connector/index.ts

@@ -0,0 +1,44 @@
+import { nanoid } from 'nanoid';
+
+import { identifyRedisTypeFromClass } from '../../modules/utils';
+import { RedisConnection as IORedisConnection } from '../connector/clients/ioredis';
+import { RedisConnection } from '../connector/clients/redis';
+import {
+  RedisClassType as IORedisClassType,
+  RedisClientOptions as IORedisClientOptions } from '../../types/ioredisclient';
+import {
+  HotMeshEngine,
+  HotMeshWorker } from '../../types/hotmesh';
+import { RedisClass, RedisOptions } from '../../types/redis';
+import {
+  RedisClassType,
+  RedisClientOptions } from '../../types/redisclient';
+
+export class ConnectorService {
+  //1) Initialize `store`, `stream`, and `subscription` Redis clients.
+  //2) Bind to the target if not already present
+  static async initRedisClients(Redis: RedisClass, options: RedisOptions, target: HotMeshEngine | HotMeshWorker): Promise<void> {
+    if (!target.store || !target.stream || !target.sub) {
+      const instances = [];
+      if (identifyRedisTypeFromClass(Redis) === 'redis') {
+        for (let i = 1; i <= 3; i++) {
+          instances.push(RedisConnection.connect(
+            nanoid(),
+            Redis as RedisClassType,
+            options as RedisClientOptions));
+        }
+      } else {
+        for (let i = 1; i <= 3; i++) {
+          instances.push(IORedisConnection.connect(
+            nanoid(),
+            Redis as IORedisClassType,
+            options as IORedisClientOptions));
+        }
+      }
+      const [store, stream, sub] = await Promise.all(instances);
+      target.store = target.store || store.getClient();
+      target.stream = target.stream || stream.getClient();
+      target.sub = target.sub || sub.getClient();
+    }
+  }
+}

package/services/dimension/README.md

@@ -0,0 +1,73 @@
+# Optimizing Cycle Management Through Shared Collation State
+Activity state is managed using a 15-digit integer. For all non-trigger activities, this value is initialized by the parent activity/preceding in the DAG. (Triggers are initialized in a 'completed' state, since their execution only reflects the  completion of the Leg 2 Duplex.)
+
+>Presetting the value for subsequent generations is critical to establishing return receipt checks, so that the system can guarantee durability and idempotency in the result of system failure during handoff.
+
+The first three digits of the 15-digit integer track and convey the activity lifecycle status. Supporting 3 states using any 3 integers is the only critical requirement for the chosen integers. As long as the backend system supports decrement and increment commands that return the modified integer value, the system can durably track state using the strategy described here.  In the reference implementation, the digit `9` is “pending” and `8` is “complete”. Additional digits can be employed to convey additional states. 
+
+The remaining 12 digits offer 1 million distinct dimensional threads for activity expansion. Dimensional Threads isolate and track those activities in the workflow that run in a cycle. They ensure that no naming collisions occur, even if the same activity is run multiple times. Each time duplex leg 2 of an activity returns with its payload, it can traverse the primary execution tree that remains (the remaining nodes in the graph); however, if the message includes a ‘pending’ status, it means that the channel will remain open, necessitating a dimensional execution thread be added to the flow, so that subsequent incoming messages can be tracked. This pattern likewise exists for `iterator` and `mark/goto` activities in that every adjacent activity that follows in the DAG will be uniquely addressed using a sequential dimensional thread that reflects its location in the collection being iterated.
+
+In the following series, [S] represents interactions with the STREAM while [D] represents interactions with the backend DATA STORE. The job begins with the trigger ( the entry point for the rooted tree). Every activity runs as a duplexed exchange with the request and response channels fully decoupled. 
+
+The trigger is unique, however, in that it does not execute Leg 1. This is because the outside caller is responsible for Leg 1, including generating the input data to be sent to the trigger to kick off the workflow.
+
+TRIGGER LEG 2
+
+```bash
+                  [D] a  A  | SET IF UNIQUE <JOBID> (ENSURE UNIQUE JOB ID)
+  888000001000001 [D] a  B  | SET TRIGGER STATE (SET TO 888000001000001)
+                  [S] b  C  | [SPAWN ADJACENT (CHILD) NODES]
+  999000000000000 [D] a  E  | PRESET SPAWNED ADJACENT NODE(S) ACTIVITY STATE
+                         F    => RETURN JOB ID TO CALLER
+WORKER ACTIVITY LEG 1
+                  [S] a a  | [DEQUEUE ACTIVITY]
+  999000000000000           *ACTIVITY STATUS WAS PRESET BY THE PARENT NODE*
+  ^-------------- [D] b c  | UPDATE ACTIVITY STATUS (DECREMENT to 899*)
+                             => FIX or CANCEL `IF < /^8\d+$/` [ACK/DELETE]
+                  [S] c d  | [ENQUEUE WORKER REQUEST]
+   ^------------- [D] b e  | UPDATE ACTIVITY STATUS (DECREMENT to 889*)
+                  [S] a f  | [ACK/DELETE]
+WORKER (SYNCHRONOUS | VARIANT 1 OF 2)
+                  [S] a  g  | [DEQUEUE WORKER REQUEST]
+  ^^^------------ [D] b  h  | QUERY ACTIVITY Status (CHECK IF JOB ACTIVE)
+                              => CANCEL `IF != /^889\d+$/` => [ACK/DELETE]
+                      X  X    => EXEC WORKER
+                  [S] d  j  | [ENQUEUE WORKER RESPONSE]
+                  [S] a  k  | [ACK/DELETE]
+WORKER (ASYNCHRONOUS | VARIANT 2 OF 2)
+                  [S] a  g  | [DEQUEUE WORKER REQUEST]
+  ^^^------------ [D] b  h  | QUERY ACTIVITY Status (CHECK IF JOB ACTIVE)
+                              => CANCEL `IF != /^889\d+$/` => [ACK/DELETE]
+                      X  X    => SAVE JOB METADATA | START WORKER
+                  [S] a  k  | [ACK/DELETE]
+                              => => =>
+                      X  X    => => => STOP WORKER (ALL DONE)
+                  [S] d  j  | [ENQUEUE WORKER RESPONSE]
+WORKER ACTIVITY LEG 2 (PROCESS PENDING | VARIANT 1 of 3)
+                  [S] a  l  | [DEQUEUE WORKER RESPONSE]
+     ^^^^^^------ [D] b  m  | INCREMENT DIMENSIONAL THREAD ENTRY COUNT by 1
+                              => CANCEL `IF != /^889\d+$/` => [ACK/DELETE]
+                  [S] c  n  | [ENQUEUE ADJACENT (CHILD) NODES]
+           ^^^^^^ [D] b  o  | INCREMENT DIMENSIONAL THREAD EXIT COUNT by 1
+  999000000000000 [D] b  q  | PRESET SPAWNED ADJACENT NODE(S) STATE
+                  [S] a  s  | [ACK/DELETE]
+WORKER ACTIVITY LEG 2 (PROCESS SUCCESS [OR CAUGHT ERROR] | VARIANT 2 of 3)
+                  [S] a  l  | [DEQUEUE WORKER RESPONSE]
+     ^^^^^^------ [D] b  m  | INCREMENT DIMENSIONAL THREAD ENTRY COUNT by 1
+                              => CANCEL `IF != /^889\d+$/` => [ACK/DELETE]
+                  [S] c  n  | [ENQUEUE ADJACENT (CHILD) NODES]
+           ^^^^^^ [D] b  o  | INCREMENT DIMENSIONAL THREAD EXIT COUNT by 1
+    ^------------ [D] b  p  | UPDATE ACTIVITY STATUS (DECREMENT to 888*)
+  999000000000000 [D] b  q  | PRESET SPAWNED ADJACENT NODE(S) STATE
+                  [S] d  r  | [ENQUEUE `JOB CLEANUP TASKS` IF JOB STATE = 0]
+                  [S] a  s  | [ACK/DELETE]
+WORKER ACTIVITY LEG 2 (PROCESS UNCAUGHT ERROR | VARIANT 3 of 3)
+                  [S] a  l  | [DEQUEUE WORKER RESPONSE]
+     ^^^^^^------ [D] b  m  | INCREMENT DIMENSIONAL THREAD ENTRY COUNT by 1
+                              => CANCEL `IF != /^\d{2}9\d+$/` => [ACK/DELETE]
+    ^------------ [D] b  p  | UPDATE ACTIVITY STATUS (DECREMENT to 887*)
+                  [S] d  r  | [ENQUEUE `JOB CLEANUP TASKS`]
+                  [S] a  s  | [ACK/DELETE]
+```
+
+Streams are used when executing an activity (such as transitioning to a child activity) as they guarantee that the child activity will be fully created and initialized before the request is marked for deletion. Even if the system has a catastrophic failure, the chain of custody can be guaranteed through the use of streams when the system comes online. If, for example, the system crashed during activity processing, the event history will reveal exactly where in the process it occurred, so that it is possible to restore state while still guaranteeing idempotency.

package/services/dimension/index.ts

@@ -0,0 +1,39 @@
+import { HotMeshGraph } from "../../types/hotmesh";
+
+class DimensionService {
+
+  //max int digit count that supports `hincrby`
+  static targetLength = 15; 
+
+  /**
+   * entry point for compiler-type activities. This is called by the compiler
+   * to bind the sorted activity IDs to the trigger activity. These are then used
+   * at runtime by the activities to track job/activity status.
+   * @param graphs
+   */
+  static compile(graphs: HotMeshGraph[]) {
+
+  }
+
+  /**
+   * All activities exist on a dimensional plane. Zero
+   * is the default and is implied if no dimension is
+   * present in the hash item key. EVERY value in the
+   * job ledger is dimensionalized even if the dimension
+   * is not present. The key, `AaA`, might not contain
+   * a dimensional index, but it is still implicitly
+   * dimensionalized as `AaA,0` (assuming a trigger).
+   * A value of `AxY,0,0,0,0,1,0,0` would reflect that
+   * an ancestor activity was dimensionalized beyond
+   * the default. The dimensional string must
+   * be included if not zero. There is likely a preceding
+   * sibling dimension, so it would not need to include
+   * the suffix, so these addresses are equivalent:
+   * `AxY,0,0,0,0,0,0,0` == `AxY` for said sibling.
+   */
+  static getSeed(index = 0): string {
+    return `,${index}`;
+  }
+}
+
+export { DimensionService };

package/services/durable/asyncLocalStorage.ts

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+export const asyncLocalStorage = new AsyncLocalStorage<Map<string, any>>();

package/services/durable/client.ts

@@ -0,0 +1,116 @@
+import { WorkflowHandleService } from "./handle";
+import { HotMeshService as HotMesh } from "../hotmesh";
+import { ClientConfig, Connection, WorkflowOptions } from "../../types/durable";
+import { getWorkflowYAML } from "./factory";
+import { JobState } from "../../types/job";
+
+/*
+Here is an example of how the methods in this file are used:
+
+./client.ts
+
+import { Durable } from '@hotmeshio/hotmesh';
+import Redis from 'ioredis';
+import { example } from './workflows';
+import { nanoid } from 'nanoid';
+
+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-' + nanoid(),
+  });
+
+  console.log(`Started workflow ${handle.workflowId}`);
+  console.log(await handle.result());
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+*/
+
+export class ClientService {
+
+  connection: Connection;
+  options: WorkflowOptions;
+  static instances = new Map<string, HotMesh | Promise<HotMesh>>();
+
+  constructor(config: ClientConfig) {
+    this.connection = config.connection;
+  }
+
+  getHotMesh = async (worflowTopic: string) => {
+    if (ClientService.instances.has(worflowTopic)) {
+      return await ClientService.instances.get(worflowTopic);
+    }
+
+    const hotMesh = HotMesh.init({
+      appId: worflowTopic,
+      engine: {
+        redis: {
+          class: this.connection.class,
+          options: this.connection.options,
+        }
+      }
+    });
+    ClientService.instances.set(worflowTopic, hotMesh);
+    await this.activateWorkflow(await hotMesh, worflowTopic);
+    return hotMesh;
+  }
+
+  workflow = {
+    start: async (options: WorkflowOptions): Promise<WorkflowHandleService> => {
+      const taskQueueName = options.taskQueue;
+      const workflowName = options.workflowName;
+      const trc = options.workflowTrace;
+      const spn = options.workflowSpan;
+      const workflowTopic = `${taskQueueName}-${workflowName}`;
+      const hotMesh = await this.getHotMesh(workflowTopic);
+      const payload = {
+        arguments: [...options.args],
+        workflowId: options.workflowId,
+      }
+      const context = { metadata: { trc, spn }, data: {}};
+      const jobId = await hotMesh.pub(workflowTopic, payload, context as JobState);
+      return new WorkflowHandleService(hotMesh, workflowTopic, jobId);
+    },
+  };
+
+  async activateWorkflow(hotMesh: HotMesh, workflowTopic: string): Promise<void> {
+    const version = '1';
+    const app = await hotMesh.engine.store.getApp(workflowTopic);
+    const appVersion = app?.version as unknown as number;
+    if(isNaN(appVersion)) {
+      try {
+        await hotMesh.deploy(getWorkflowYAML(workflowTopic, version));
+        await hotMesh.activate(version);
+      } catch (err) {
+        hotMesh.engine.logger.error('durable-client-workflow-activation-err', err);
+        throw err;
+      }
+    }
+  }
+
+  static async shutdown(): Promise<void> {
+    for (const [key, value] of ClientService.instances) {
+      const hotMesh = await value;
+      await hotMesh.stop();
+    }
+  }
+}

package/services/durable/connection.ts

@@ -0,0 +1,50 @@
+import { Connection, ConnectionConfig } from "../../types/durable";
+
+/*
+Here is an example of how the methods in this file are used:
+
+./client.ts
+
+import { Durable } from '@hotmeshio/hotmesh';
+import Redis from 'ioredis';
+import { nanoid } from 'nanoid';
+
+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(example, {
+    taskQueue: 'hello-world',
+    args: ['HotMesh'],
+    workflowName: 'example',
+    workflowId: nanoid(),
+  });
+
+  console.log(`Started workflow ${handle.workflowId}`);
+  console.log(await handle.result());
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+*/
+
+export class ConnectionService {
+  static async connect(config: ConnectionConfig): Promise<Connection> {
+    return {
+      class: config.class,
+      options: { ...config.options },
+     } as Connection;
+  }
+}

package/services/durable/factory.ts

@@ -0,0 +1,124 @@
+const getWorkflowYAML = (topic: string, version = '1') => {
+  return `app:
+  id: ${topic}
+  version: '${version}'
+  graphs:
+    - subscribes: ${topic}
+      publishes: ${topic}
+      expire: 120
+      input:
+        schema:
+          type: object
+          properties:
+            workflowId:
+              type: string
+            arguments:
+              type: array
+      output:
+        schema:
+          type: object
+          properties:
+            response:
+              type: any
+
+      activities:
+        t1:
+          type: trigger
+          stats:
+            id: '{$self.input.data.workflowId}'
+        a1:
+          type: worker
+          topic: ${topic}
+          input:
+            schema:
+              type: object
+              properties:
+                workflowId:
+                  type: string
+                arguments:
+                  type: array
+            maps:
+              workflowId: '{t1.output.data.workflowId}'
+              arguments: '{t1.output.data.arguments}'
+          output:
+            schema:
+              type: object
+              properties:
+                response:
+                  type: any
+          job:
+            maps:
+              response: '{$self.output.data.response}'
+      transitions:
+        t1:
+          - to: a1`;
+}
+
+const getActivityYAML = (topic: string, version = '1') => {
+  return `app:
+  id: ${topic}
+  version: '${version}'
+  graphs:
+    - subscribes: ${topic}
+      input:
+        schema:
+          type: object
+          properties:
+            workflowId:
+              type: string
+            workflowTopic:
+              type: string
+            activityName:
+              type: array
+            arguments:
+              type: array
+      output:
+        schema:
+          type: object
+          properties:
+            response:
+              type: any
+
+      activities:
+        t1:
+          type: trigger
+          stats:
+            id: '{$self.input.data.workflowId}'
+        a1:
+          type: worker
+          topic: ${topic}
+          input:
+            schema:
+              type: object
+              properties:
+                workflowId:
+                  type: string
+                workflowTopic:
+                  type: string
+                activityName:
+                  type: array
+                arguments:
+                  type: array
+            maps:
+              workflowId: '{t1.output.data.workflowId}'
+              workflowTopic: '{t1.output.data.workflowTopic}'
+              activityName: '{t1.output.data.activityName}'
+              arguments: '{t1.output.data.arguments}'
+          output:
+            schema:
+              type: object
+              properties:
+                response:
+                  type: any
+          job:
+            maps:
+              response: '{$self.output.data.response}'
+      transitions:
+        t1:
+          - to: a1`;
+}
+
+export {
+  getActivityYAML,
+  getWorkflowYAML
+};

package/services/durable/handle.ts

@@ -0,0 +1,43 @@
+import { JobOutput } from "../../types/job";
+import { HotMeshService as HotMesh } from "../hotmesh";
+
+export class WorkflowHandleService {
+  hotMesh: HotMesh;
+  workflowTopic: string;
+  workflowId: string;
+
+  constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string) {
+    this.workflowTopic = workflowTopic;
+    this.workflowId = workflowId;
+    this.hotMesh = hotMesh;
+  }
+
+  async result(): Promise<any> {
+    let status = await this.hotMesh.getStatus(this.workflowId);
+    const topic = `${this.workflowTopic}.${this.workflowId}`;
+  
+    if (status == 0) {
+      return (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response;
+    }
+  
+    return new Promise((resolve, reject) => {
+      let isResolved = false;
+      //common fulfill/unsubscribe
+      const complete = async (response?: any) => {
+        if (isResolved) return;
+        isResolved = true;
+        this.hotMesh.unsub(topic);
+        resolve(response || (await this.hotMesh.getState(this.workflowTopic, this.workflowId)).data?.response);
+      };
+      this.hotMesh.sub(topic, async (topic: string, message: JobOutput) => {
+        await complete(message.data?.response);
+      });
+      setTimeout(async () => {
+        status = await this.hotMesh.getStatus(this.workflowId);
+        if (status == 0) {
+          await complete();
+        }
+      }, 0);
+    });
+  }
+}

package/services/durable/index.ts

@@ -0,0 +1,60 @@
+import { ClientService } from './client';
+import { ConnectionService } from './connection';
+import { NativeConnectionService } from './native';
+import { WorkerService } from './worker';
+import { WorkflowService } from './workflow';
+import { ContextType } from '../../types/durable';
+
+/**
+ * As a durable integration platform, HotMesh
+ * can model and emulate other durable systems
+ * (like Temporal). As you review the code in
+ * this file, note the following:
+ * 
+ * 1) There is no central governing server.
+ * HotMesh is a client-side SDK that connects to Redis
+ * using CQRS principles to implicitly drive
+ * orchestrations using a headless quorum. Stream
+ * semantics guarantee that all events are
+ * processed by the quorum of connected clients.
+ * 
+ * 2) Every developer-defined `workflow` function
+ * is assigned a HotMesh workflow (which runs in
+ * the background) to support it.
+ * 
+ * If the HotMesh workflow is not yet defined,
+ * it will be deployed and activated on-the-fly.
+ * (The generated DAG will have one Trigger Activity
+ * and one Worker Activity.) The Worker Activity
+ * is configured to catch execution errors and
+ * return them, using a 'pending' status to
+ * indicate that the workflow is still running.
+ * It is possible for workflow activities to throw
+ * errors that will force the entire workflow to
+ * fail. This is not the case here. The workflow will
+ * continue to run until it is completed or cancelled.
+ * 
+ * 2) Every developer-defined `activity` function
+ * is assigned a HotMesh workflow (which runs in
+ * the background) to support it.
+ * 
+ * (The generated DAG will have one Trigger Activity and one
+ * Worker Activity.) The JOB ID for Worker Activity executions
+ * is derived from the containing JOB ID,
+ * allowing Activity state to be 'replayed' when the workflow
+ * is run again. The Activity Function Runner (activity proxy)
+ * is configured similar to how the workflow worker is and will
+ * catch execution errors and return them to the caller, using a
+ * 'pending' status to indicate that the activity is still running.
+ * This allows the activity to be retried until it succeeds.
+ */
+
+export const Durable = {
+  Client: ClientService,
+  Connection: ConnectionService,
+  NativeConnection: NativeConnectionService,
+  Worker: WorkerService,
+  workflow: WorkflowService,
+};
+
+export type { ContextType };