FAQ

Run an idempotent cron job

This example demonstrates an idempotent cron that runs daily at midnight. The id makes each cron job unique and ensures that only one instance runs, despite repeated invocations. The cron method returns false if a workflow is already running with the same id.

Optionally set a delay and/or set maxCycles to limit the number of cycles. The interval can be any human-readable time format (e.g., 1 day, 2 hours, 30 minutes, etc) or a standard cron expression.

1. Define the cron function.

   //cron.ts
   import { MeshCall } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   export const runMyCron = async (id: string, interval = '0 0 * * *'): Promise => {
     return await MeshCall.cron({
       topic: 'my.cron.function',
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       },
       callback: async () => {
         //your code here...
       },
       options: { id, interval, maxCycles: 24 }
     });
   };
   

2. Call runMyCron at server startup (or call as needed to run multiple crons).

   //server.ts
   import { runMyCron } from './cron';
   
   runMyCron('myNightlyCron123');
   

Interrupt a cron job

This example demonstrates how to cancel a running cron job.

1. Use the same id and topic that were used to create the cron to cancel it.

   import { MeshCall } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   MeshCall.interrupt({
     topic: 'my.cron.function',
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     options: { id: 'myNightlyCron123' }
   });
   

Call any function in any service

Make interservice calls that behave like HTTP but without the setup and performance overhead. This example demonstrates how to connect and call a function.

1. Call MeshCall.connect and provide a topic to uniquely identify the function.

   //myFunctionWrapper.ts
   import { MeshCall, Types } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   export const connectMyFunction = async () => {
     return await MeshCall.connect({
       topic: 'my.demo.function',
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       },
       callback: async (input: string) => {
         //your code goes here; response must be JSON serializable
         return { hello: input }
       },
     });
   };
   

2. Call connectMyFunction at server startup to connect your function to the mesh.

   //server.ts
   import { connectMyFunction } from './myFunctionWrapper';
   connectMyFunction();
   

3. Call your function from anywhere on the network (or even from the same service). Send any payload as long as it's JSON serializable.

   import { MeshCall } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   const result = await MeshCall.exec({
     topic: 'my.demo.function',
     args: ['something'],
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
   }); //returns `{ hello: 'something'}`
   

Call and cache a function

This solution builds upon the previous example, caching the response. The linked function will only be re/called when the cached result expires. Everything remains the same, except the caller which specifies an id and ttl.

1. Make the call from another service (or even the same service). Include an id and ttl to cache the result for the specified duration.

   import { MeshCall } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   const result = await MeshCall.exec({
     topic: 'my.demo.function',
     args: ['anything'],
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     options: { id: 'myid123', ttl: '15 minutes' },
   }); //returns `{ hello: 'anything'}`
   

2. Flush the cache at any time, using the same topic and cache id.

   import { MeshCall } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   await MeshCall.flush({
     topic: 'my.demo.function',
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     options: { id: 'myid123' },
   });
   

Orchestrate unpredictable activities

When an endpoint is unpredictable, use proxyActivities. HotMesh will retry as necessary until the call succeeds. This example demonstrates a workflow that greets a user in both English and Spanish. Even though both activities throw random errors, the workflow always returns a successful result.

1. Define activities. Note how each throws an error 50% of the time.

   //activities.ts
   export async function greet(name: string): Promise {
     if (Math.random() > 0.5) throw new Error('Random error');
     return `Hello, ${name}!`;
   }
   
   export async function saludar(nombre: string): Promise {
     if (Math.random() > 0.5) throw new Error('Random error');
     return `¡Hola, ${nombre}!`;
   }
   

2. Define the workflow logic.

   //workflows.ts
   import { workflow } from '@hotmeshio/hotmesh';
   import * as activities from './activities';
   
   const { greet, saludar } = workflow
     .proxyActivities({
       activities
     });
   
   export async function example(name: string): Promise<[string, string]> {
     return Promise.all([
       greet(name),
       saludar(name)
     ]);
   }
   

3. Instance a HotMesh client to invoke the workflow.

   //client.ts
   import { Client, HotMesh } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   async function run(): Promise {
     const client = new Client({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       }
     });
   
     const handle = await client.workflow.start<[string,string]>({
       args: ['HotMesh'],
       taskQueue: 'default',
       workflowName: 'example',
       workflowId: HotMesh.guid()
     });
   
     return await handle.result();
     //returns ['Hello HotMesh', '¡Hola, HotMesh!']
   }
   

4. Create a worker and link the workflow function.

   //worker.ts
   import { Worker } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import * as workflows from './workflows';
   
   async function run() {
     const worker = await Worker.create({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       },
       taskQueue: 'default',
       workflow: workflows.example,
     });
   
     await worker.run();
   }
   

Pause and wait for a signal

Pause a function and only awaken when a matching signal is received from the outside.

1. Define the workflow logic. This one waits for the my-sig-nal signal, returning the signal payload ({ hello: 'world' }) when it eventually arrives. Interleave additional logic to meet your use case.

   //waitForWorkflow.ts
   import { workflow } from '@hotmeshio/hotmesh';
   
   export async function waitForExample(): Promise<{hello: string}> {
     return await workflow.waitFor<{hello: string}>('my-sig-nal');
     //continue processing, use the payload, etc...
   }
   

2. Instance a HotMesh client and start a workflow. Use a custom workflow ID (myWorkflow123).

   //client.ts
   import { Client, HotMesh } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   async function run(): Promise {
     const client = new Client({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       }
     });
   
     //start a workflow; it will immediately pause
     await client.workflow.start({
       args: ['HotMesh'],
       taskQueue: 'default',
       workflowName: 'waitForExample',
       workflowId: 'myWorkflow123',
       await: false,
     });
   }
   

3. Create a worker and link the waitForExample workflow function.

   //worker.ts
   import { Worker } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import * as workflows from './waitForWorkflow';
   
   async function run() {
     const worker = await Worker.create({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       },
       taskQueue: 'default',
       workflow: workflows.waitForExample,
     });
   
     await worker.run();
   }
   

4. Send a signal to awaken the paused function; await the function result.

   import { Client } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   const client = new Client({
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     }
   });
   
   //awaken the function by sending a signal
   await client.signal('my-sig-nal', { hello: 'world' });
   
   //get the workflow handle and await the result
   const handle = await client.getHandle({
     taskQueue: 'default',
     workflowId: 'myWorkflow123'
   });
   
   const result = await handle.result();
   //returns { hello: 'world' }
   

Wait for multiple signals (collation)

Use a standard Promise to collate and cache multiple signals. HotMesh will only awaken once all signals have arrived. HotMesh will track up to 25 concurrent signals.

1. Update the workflow logic to await two signals using a promise: my-sig-nal-1 and my-sig-nal-2. Add additional logic to meet your use case.

   //waitForWorkflows.ts
   import { workflow } from '@hotmeshio/hotmesh';
   
   export async function waitForExample(): Promise<[boolean, number]> {
     const [s1, s2] = await Promise.all([
       workflow.waitFor('my-sig-nal-1'),
       workflow.waitFor('my-sig-nal-2')
     ]);
     //do something with the signal payloads (s1, s2)
     return [s1, s2];
   }
   

2. Send two signals to awaken the paused function.

   import { Client } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   const client = new Client({
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     }
   });
   
   //send 2 signals to awaken the function; order is unimportant
   await client.signal('my-sig-nal-2', 12345);
   await client.signal('my-sig-nal-1', true);
   
   //get the workflow handle and await the collated result
   const handle = await client.getHandle({
     taskQueue: 'default',
     workflowId: 'myWorkflow123'
   });
   
   const result = await handle.result();
   //returns [true, 12345]
   

Create a recurring, cyclical workflow

This example calls an activity and then sleeps for a week. It runs indefinitely until it's manually stopped. It takes advantage of durable execution and can safely sleep for months or years.

Container restarts have no impact on actively executing workflows as all state is retained in the backend.

1. Define the workflow logic. This one calls a legacy statusDiagnostic function once a week.

   //recurringWorkflow.ts
   import { workflow } from '@hotmeshio/hotmesh';
   import * as activities from './activities';
   
   const { statusDiagnostic } = workflow
     .proxyActivities({
       activities
     });
   
   export async function recurringExample(someValue: number): Promise {
     do {
       await statusDiagnostic(someValue);
     } while (await workflow.sleepFor('1 week'));
   }
   

2. Instance a HotMesh client and start a workflow. Assign a custom workflow ID (e.g., myRecurring123) if the workflow should be idempotent.

   //client.ts
   import { Client, HotMesh } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   async function run(): Promise {
     const client = new Client({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       }
     });
   
     //start a workflow; it will immediately pause
     await client.workflow.start({
       args: [55],
       taskQueue: 'default',
       workflowName: 'recurringExample',
       workflowId: 'myRecurring123',
       await: false,
     });
   }
   

3. Create a worker and link the recurringExample workflow function.

   //worker.ts
   import { Worker } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import * as workflows from './recurringWorkflow';
   
   async function run() {
     const worker = await Worker.create({
       connection: {
         class: Postgres,
         options: {
           connectionString: 'postgresql://usr:pwd@localhost:5432/db'
         }
       },
       taskQueue: 'default',
       workflow: workflows.recurringExample,
     });
   
     await worker.run();
   }
   

4. Cancel the recurring workflow (myRecurring123) by calling interrupt.

   import { Client } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   
   const client = new Client({
     connection: {
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     }
   });
   
   //get the workflow handle and interrupt it
   const handle = await client.getHandle({
     taskQueue: 'default',
     workflowId: 'myRecurring123'
   });
   
   const result = await handle.interrupt();
   

Create a search index

This example demonstrates how to define a schema and deploy an index for a 'user' entity type.

1. Define the schema for the user entity. This one includes the 3 formats supported by the FT.SEARCH module: TEXT, TAG and NUMERIC.

   //schema.ts
   export const schema: Types.WorkflowSearchOptions = {
     schema: {
       id: { type: 'TAG', sortable: false },
       first: { type: 'TEXT', sortable: false, nostem: true },
       active: { type: 'TAG', sortable: false },
       created: { type: 'NUMERIC', sortable: true },
     },
     index: 'user',
     prefix: ['user'],
   };
   

2. Create the index upon server startup. This one initializes the 'user' index, using the schema defined in the previous step. It's OK to call createSearchIndex multiple times; it will only create the index if it doesn't already exist.

   //server.ts
   import { MeshData } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import { schema } from './schema';
   
   const meshData = new MeshData({
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     schema,
   );
   await meshData.createSearchIndex('user', { namespace: 'meshdata' });
   

Create an indexed, searchable record

This example demonstrates how to create a 'user' workflow backed by the searchable schema from the prior example.

1. Call MeshData connect to initialize a 'user' entity worker. It references a target worker function which will run the workflow. Data fields that are documented in the schema (like active) will be automatically indexed when set on the workflow record.

   //connect.ts
   import { MeshData } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import { schema } from './schema';
   
   export const connectUserWorker = async (): Promise => {
     const meshData = new MeshData({
         class: Postgres,
         options: {
             connectionString: 'postgresql://usr:pwd@localhost:5432/db'
           }
         },
         schema,
       );
     
     await meshData.connect({
       entity: 'user',
       target: async function(name: string): Promise {
         //add custom, searchable data (`active`) and return
         const search = await MeshData.workflow.search();
         await search.set('active', 'yes');
         return `Welcome, ${name}.`;
       },
       options: { namespace: 'meshdata' },
     });
   }
   

2. Wire up the worker at server startup, so it's ready to process incoming requests.

   //server.ts
   import { connectUserWorker } from './connect';
   await connectUserWorker();
   

3. Call MeshData exec to create a 'user' workflow. Searchable data can be set throughout the workflow's lifecycle. This one initializes the workflow with 3 data fields: id, name and timestamp. An additional data field (active) is set within the workflow function in order to demonstrate both mechanisms for reading/writing data to a workflow.

   //exec.ts
   import { MeshData } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import { schema } from './schema';
   
   const meshData = new MeshData({
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     schema,
   );
   
   export const newUser = async (id: string, name: string): Promise => {
     const response = await meshData.exec({
       entity: 'user',
       args: [name],
       options: {
         ttl: 'infinity',
         id,
         search: {
           data: { id, name, timestamp: Date.now() }
         },
         namespace: 'meshdata',
       },
     });
     return response;
   };
   

4. Call the newUser function to create a searchable 'user' record.

   import { newUser } from './exec';
   const response = await newUser('jim123', 'James');
   

Fetch record data

This example demonstrates how to read data fields directly from a workflow.

1. Read data fields directly from the jimbo123 'user' record.

   //read.ts
   import { MeshData } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import { schema } from './schema';
   
   const meshData = new MeshData({
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     schema,
   );
   
   const data = await meshData.get(
     'user',
     'jimbo123',
     { 
       fields: ['id', 'name', 'timestamp', 'active'],
       namespace: 'meshdata'
     },
   );
   

Search record data

This example demonstrates how to search for those workflows where a given condition exists in the data. This one searches for active users. NOTE: The native Redis FT.SEARCH syntax and SQL are currently supported. The JSON abstraction shown here is a convenience method for straight-forward, one-dimensional queries.

1. Search for active users (where the value of the active field is yes).

   //read.ts
   import { MeshData } from '@hotmeshio/hotmesh';
   import { Client as Postgres } from 'pg';
   import { schema } from './schema';
   
   const meshData = new MeshData({
       class: Postgres,
       options: {
         connectionString: 'postgresql://usr:pwd@localhost:5432/db'
       }
     },
     schema,
   );
   
   const results = await meshData.findWhere('user', {
     query: [{ field: 'active', is: '=', value: 'yes' }],
     limit: { start: 0, size: 100 },
     return: ['id', 'name', 'timestamp', 'active']
   });
   

Postgres

Connect Postgres Client

import { Client as PostgresClient } from 'pg';

//provide these credentials to HotMesh
const connection = {
  class: PostgresClient,
  options: {
    connectionString: 'postgresql://usr:pwd@localhost:5432/db'
  }
};

Connect Postgres Pool

import { Pool as PostgresPool } from 'pg';

const PostgresPoolClient = new PostgresPool({
  connectionString: 'postgresql://usr:pwd@localhost:5432/db'
});

//provide these credentials to HotMesh
const connection = {
  class: PostgresPoolClient,
  options: {}
};

Redis

Redis/IORedis

import * as Redis from 'redis';
//OR `import Redis from 'ioredis';`

const connection = {
  class: Redis,
  options: {
    url: 'redis://:your_password@localhost:6379',
  }
};

NATS

NATS PubSub

Add NATS for improved PubSub support, including patterned subscriptions. Note the explicit channel subscription in the example below. The NATS provider supports version 2.0 of the NATS client (the latest version). See ./package.json for details.

import { Client as Postgres } from 'pg';
import { connect as NATS } from 'nats';

const connection = {
  store: {
    class: Postgres,
    options: {
      connectionString: 'postgresql://usr:pwd@localhost:5432/db',
    }
  },
  stream: {
    class: Postgres,
    options: {
      connectionString: 'postgresql://usr:pwd@localhost:5432/db',
    }
  },
  sub: {
    class: NATS,
    options: { servers: ['nats:4222'] }
  },
};

What is HotMesh?

HotMesh is a microservice orchestration solution similar to Temporal, but requiring only a backend database (Postgres, Redis, etc). Instead of a central app server, HotMesh uses decentralized stateless message routers.

What are the benefits of HotMesh's data-centric approach?

HotMesh allows real-time data aggregation in every workflow. With its channel-first design, you can monitor analytics, events (pub-sub), and telemetry in real-time.

How does scaling work in HotMesh?

Scaling is as easy as scaling your database. No app server means no multi-body problems—just a straightforward, linear scaling process. Your overhead is limited to your database's proxy or sharding strategy. Simple scales.

Is HotMesh compatible with existing Temporal SDKs?

Yes! HotMesh clones all Temporal APIs. If you're familiar with Temporal, you'll feel right at home. Here are some common lifecycle patterns. The term 'MeshFlow' is used instead of Temporal, but the syntax is the same.

import { Client as PostgresClient } from 'pg';
import { Meshflow, Worker, Client } from '@hotmeshio/hotmesh';

import * as workflows from './workflows';

// 1) Initialize a worker (typically done at server startup)
await Worker.create({
  //configure the connection
  connection: {
    class: PostgresClient,
    options: {
      connectionString: 'postgresql://usr:pwd@localhost:5432/db'
    }
  },
  namespace: 'meshflow',
  taskQueue: 'default',

  //link your worker function!
  workflow: function (name) {
    return `Hello, ${name}!`;
  },

  //configure retry/backoff policy
  options: {
    backoffCoefficient: 2,
    maximumAttempts: 1_000,
    maximumInterval: '5 seconds'
  }
});

// 2) Instance a client
const client = new Client({
  connection: {
    class: PostgresClient,
    options: {
      connectionString: 'postgresql://usr:pwd@localhost:5432/db'
    }
  },
});

//3) Start a new workflow (add searchable, indexed data)
const workflowId = HotMesh.guid();
const handle = await client.workflow.start({
  namespace: 'meshflow',
  taskQueue: 'default',
  workflowName: 'example',
  workflowId,
  args: ['HotMesh'],
  expire: 3_600,
  //add searchable, indexed data
  search: {
    data: {
      '$entity': 'default',
      id : workflowId,
    },
  },
});

//4) subscribe to the eventual result  ('Hello, HotMesh!')
console.log('\nRESPONSE', await handle.result(), '\n');

//5) Shutdown routers (typically on sigint/sigterm)
await MeshFlow.shutdown();

What databases and backends does HotMesh support?

HotMesh works with multimodal backends capable of handling streams (queues), stores (process ledgers), and events (pub/sub). Postgres and Redis are both fully supported as standalone backends. NATS can be added for advanced Pub/Sub as it supports patterned subscriptions. Take advantage of the NATS network and broadcast workflow status in real time.

Is HotMesh truly serverless?

Absolutely. With no central app server, HotMesh operates as a decentralized swarm of routers. Scale your database, and you've scaled your application. It's serverless in the truest sense—no servers, just services. Install the HotMesh NPM package in those services in need of orchestration.

What languages are supported in HotMesh?

HotMesh runs on TypeScript. Python is likely the next language. (But Rust-based routers would be ridiculously fast!)

How does HotMesh handle upgrades and pluggability?

HotMesh's routers are connected via pub/sub and can act as a quorum. This allows the collective to decide when and how to upgrade. The architecture supports pluggable backends, so you can configure routers with different technologies like Postgres, NATS, or Redis based on your needs.

What's the business advantage?

By removing the app server, HotMesh adopts a channel-first approach that makes it easy to extend the product in ways that materially impact your business. Every running workflow mimics Temporal's APIs but also provides additional methods: emit, enrich, and trace.

The emit method broadcasts events to your chosen event provider (NATS, Redis, Postgres, etc.). It's fully pub/sub, allowing you to subscribe to real-time events and drive just-in-time business decisions—valuable for C-suite executives, marketing, and product teams. If you already have an event sink or aggregator like NATS, there's no setup required.

The enrich method adds any name/value pair to the workflow's database record, enabling you to enrich your data store with valuable information on the fly.

The trace method sends attribute sets to the OpenTelemetry sink, providing robust tracing capabilities and triggered alarms in your chosen sink.

Here's how you can use these methods in your workflows:

export async function example(): Promise<[string, string, string, number]> {
  // Send 'trace' to the OpenTelemetry sink (happens just once)
  await MeshFlow.workflow.trace({
    name: 'example',
    version: 1,
    complete: true,
  });

  // Send 'enrich' to the Database Backend (enriches record with name/value)
  await MeshFlow.workflow.enrich({
    name: 'example',
    version: '1',
    complete: 'true',
  });

  // Send 'emit' event to the Event Bus (emits events via the Pub/Sub Backend)
  await MeshFlow.workflow.emit({
    'my.dog': { everything: 'goes' },
    'my.dog.cat': { anything: 'works' },
  });

  return await Promise.all([
    greet('1'),
    greet('2'),
    greet('3'),
    MeshFlow.workflow.sleepFor('5 seconds'),
  ]);
}
            

Leverage these methods for real-time data and actionable insights. C-Suite, Marketing, Product, and Operations all benefit from the channel-first approach.

What's the vision?

HotMesh represents a new generation of data-first applications where orchestration is a natural extension of the database layer rather than a separate concern.

This approach aligns with broader industry trends toward infrastructure consolidation, serverless architectures, data-centric operations, AI/ML integration, and cost optimization. The result is orchestration that's simpler to deploy, easier to maintain, more cost-effective to scale, and naturally integrated with an organization's data infrastructure.

Who's behind this?

HotMesh is the passion project of Luke Birdeau. He's been developing HotMesh as a side hobby, and is always happy for input and help from the community. He enjoys cooking, walking, and talking about himself in the third person.

Is HotMesh Open Source?

HotMesh is released under an Apache 2.0 license with commercial restrictions. It's free in nearly every sense of the word. The goal is to allow people to use it, plug into it, and benefit from it. However, to prevent unauthorized reselling or rebranding, certain commercial restrictions apply.

What's the license?

HotMesh is licensed under a standard Apache 2.0 license with commercial restrictions. It specifically targets integration vendors:

[Y]ou are not permitted to use the Work, or any modified or derivative version of the Work, for the purpose of offering the Work, or any 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 in a manner that would compete with the Licensor's services. Any such use requires explicit written permission from the Licensor.

Definitely not a lawyer, but also not a big fan of the limited license options in the GitHub pulldown menu.

How can I contribute?

Contributions are welcome! If you're interested in adding to the temporal pattern coverage or improving HotMesh in any way, please refer to the contribution guidelines on GitHub. Your input and help are highly appreciated.

How can I get in touch?

Have questions, need support, or want to connect? Join the HotMesh Discord Channel .