@hotmeshio/hotmesh 0.5.3 → 0.5.5

package/README.md

@@ -1,52 +1,135 @@
 # HotMesh
 
-**🧠 Workflow That Remembers**
+**Durable Memory + Coordinated Execution**
 
-![beta release](https://img.shields.io/badge/release-beta-blue.svg)  ![made with typescript](https://img.shields.io/badge/built%20with-typescript-lightblue.svg)
+![beta release](https://img.shields.io/badge/release-beta-blue.svg) ![made with typescript](https://img.shields.io/badge/built%20with-typescript-lightblue.svg)
 
-HotMesh brings a **memory model** to your automation: durable entities that hold context, support concurrency, and evolve across runs. Built on PostgreSQL, it treats your database not just as storage—but as the runtime hub for agents, pipelines, and long-lived processes.
+HotMesh removes the repetitive glue of building durable agents, pipelines, and long‑running workflows. Instead of you designing queues, schedulers, cache layers, and ad‑hoc state stores for each agent or pipeline, HotMesh standardizes the pattern:
 
-Use HotMesh to:
+* **Entity (Core Memory)**: The authoritative JSONB document + its indexable “surface” fields.
+* **Hooks (Durable Units of Work)**: Re‑entrant, idempotent functions that *maintain* the entity over time.
+* **Workflow (Coordinator)**: The thin orchestration entry that seeds state, spawns hooks, and optionally synthesizes results.
+* **Commands (State Mutation API)**: Atomic `set / merge / append / increment / tag / signal` updates with optimistic invariants handled by Postgres transactions.
 
-* **Store Evolving State** – Retain memory/state between executions
-* **Coordinate Distributed Work** – Safely allow multiple workers to act on shared state
-* **Track and Replay** – Full audit history and replay support by default
+You focus on *what should change in memory*; HotMesh handles *how it changes safely and durably.*
+
+---
+
+## Why It’s Easier with HotMesh
+
+| Problem You Usually Solve Manually                  | HotMesh Built‑In                          | Impact                                         |
+| --------------------------------------------------- | ----------------------------------------- | ---------------------------------------------- |
+| Designing per‑agent persistence and caches          | Unified JSONB entity + typed accessors    | One memory model across agents/pipelines       |
+| Preventing race conditions on shared state          | Transactional hook writes                 | Safe parallel maintenance                      |
+| Coordinating multi-perspective / multi-step work    | Hook spawning + signals                   | Decomposed work without orchestration glue     |
+| Schema evolution / optional fields                  | Flexible JSONB + selective indexes        | Add / adapt state incrementally                |
+| Querying live pipeline / agent status               | SQL over materialized surfaces            | Operational observability using standard tools |
+| Avoiding duplicate side-effects during retry/replay | Deterministic re‑entry + idempotent hooks | Simplifies error handling                      |
+| Per‑tenant isolation                                | Schema (or prefix) scoping                | Clean multi‑tenant boundary                    |
+| Background progression / fan‑out                    | `execHook` + signals                      | Natural concurrency without queue plumbing     |
+
+---
+
+## Core Abstractions
+
+### 1. Entities
+
+Durable JSONB documents representing *process memory*. Each entity:
+
+* Has a stable identity (`workflowId` / logical key).
+* Evolves via atomic commands.
+* Is versioned implicitly by transactional history.
+* Can be partially indexed for targeted query performance.
+
+> **Design Note:** Treat entity shape as *contractual surface* + *freeform interior*. Index only the minimal surface required for lookups or dashboards.
+
+### 2. Hooks
+
+Re‑entrant, idempotent, interruptible units of work that *maintain* an entity. Hooks can:
+
+* Start, stop, or be re‑invoked without corrupting state.
+* Run concurrently (Postgres ensures isolation on write).
+* Emit signals to let coordinators or sibling hooks know a perspective / phase completed.
+
+### 3. Workflow Coordinators
+
+Thin entrypoints that:
+
+* Seed initial entity state.
+* Fan out perspective / phase hooks.
+* Optionally synthesize or finalize.
+* Return a snapshot (often the final entity state) — *the workflow result is just memory*.
+
+### 4. Commands (Entity Mutation Primitives)
+
+| Command     | Purpose                                   | Example                                          |
+| ----------- | ----------------------------------------- | ------------------------------------------------ |
+| `set`       | Replace full value (first write or reset) | `await e.set({ user: { id: 123, name: "John" } })` |
+| `merge`     | Deep JSON merge                           | `await e.merge({ user: { email: "john@example.com" } })` |
+| `append`    | Append to an array field                  | `await e.append('items', { id: 1, name: "New Item" })` |
+| `prepend`   | Add to start of array field              | `await e.prepend('items', { id: 0, name: "First Item" })` |
+| `remove`    | Remove item from array by index          | `await e.remove('items', 0)` |
+| `increment` | Numeric counters / progress               | `await e.increment('counter', 5)` |
+| `toggle`    | Toggle boolean value                      | `await e.toggle('settings.enabled')` |
+| `setIfNotExists` | Set value only if path doesn't exist | `await e.setIfNotExists('user.id', 123)` |
+| `delete`    | Remove field at specified path           | `await e.delete('user.email')` |
+| `get`       | Read value at path (or full entity)      | `await e.get('user.email')` |
+| `signal`    | Mark hook milestone / unlock waiters      | `await MemFlow.workflow.signal('phase-x', data)` |
+
+The Entity module also provides static methods for cross-entity querying:
+
+```typescript
+// Find entities matching conditions
+const activeUsers = await Entity.find('user', { 
+  status: 'active',
+  country: 'US' 
+});
+
+// Find by specific field condition
+const highValueOrders = await Entity.findByCondition(
+  'order',
+  'total_amount',
+  1000,
+  '>=',
+  hotMeshClient
+);
+
+// Find single entity by ID
+const user = await Entity.findById('user', 'user123', hotMeshClient);
+
+// Create optimized index for queries
+await Entity.createIndex('user', 'email', hotMeshClient);
+```
 
 ---
 
 ## Table of Contents
 
 1. [Quick Start](#quick-start)
-2. [Permanent Memory Architecture](#permanent-memory-architecture)
+2. [Memory Architecture](#memory-architecture)
 3. [Durable AI Agents](#durable-ai-agents)
-4. [Building Pipelines with State](#building-pipelines-with-state)
-5. [Documentation & Links](#documentation--links)
+4. [Stateful Pipelines](#stateful-pipelines)
+5. [Indexing Strategy](#indexing-strategy)
+6. [Operational Notes](#operational-notes)
+7. [Documentation & Links](#documentation--links)
 
 ---
 
 ## Quick Start
 
-### Prerequisites
-
-* PostgreSQL (or Supabase)
-* Node.js 16+
-
 ### Install
 
 ```bash
 npm install @hotmeshio/hotmesh
 ```
 
-### Connect to a Database
-
-HotMesh leverages Temporal.io's developer-friendly syntax for authoring workers, workflows, and clients. The `init` and `start` methods should look familiar.
-
+### Minimal Setup
 ```ts
 import { MemFlow } from '@hotmeshio/hotmesh';
 import { Client as Postgres } from 'pg';
 
 async function main() {
-  // MemFlow will auto-provision the database upon init
+  // Auto-provisions required tables/index scaffolding on first run
   const mf = await MemFlow.init({
     appId: 'my-app',
     engine: {
@@ -57,302 +140,188 @@ async function main() {
     }
   });
 
-  // Start a workflow with an assigned ID and arguments
+  // Start a durable research agent (entity-backed workflow)
   const handle = await mf.workflow.start({
     entity: 'research-agent',
     workflowName: 'researchAgent',
     workflowId: 'agent-session-jane-001',
-    args: ['What are the long-term impacts of renewable energy subsidies?'],
+    args: ['Long-term impacts of renewable energy subsidies'],
     taskQueue: 'agents'
   });
 
-  console.log('Result:', await handle.result());
+  console.log('Final Memory Snapshot:', await handle.result());
 }
 
 main().catch(console.error);
 ```
 
-### System Benefits
-
-* **No Setup Required** – Tables and indexes are provisioned automatically
-* **Shared State** – Every worker shares access to the same entity memory
-* **Coordination by Design** – PostgreSQL handles consistency and isolation
-* **Tenant Isolation** – Each app maintains its own schema
-* **Scalable Defaults** – Partitioned tables and index support included
+### Value Checklist (What You Did *Not* Have To Do)
+- Create tables / migrations
+- Define per-agent caches
+- Implement optimistic locking
+- Build a queue fan‑out mechanism
+- Hand-roll replay protection
 
 ---
 
-## Permanent Memory Architecture
-
-Every workflow in HotMesh is backed by an "entity": a versioned, JSONB record that tracks its memory and state transitions.
-
-* **Entities** – Represent long-lived state for a workflow or agent
-* **Commands** – Modify state with methods like `set`, `merge`, `append`, `increment`
-* **Consistency** – All updates are transactional with Postgres
-* **Replay Safety** – Protects against duplicated side effects during re-execution
-* **Partial Indexing** – Optimized querying of fields within large JSON structures
+## Memory Architecture
+Each workflow = **1 durable entity**. Hooks are stateless functions *shaped by* that entity's evolving JSON. You can inspect or modify it at any time using ordinary SQL or the provided API.
 
-### Example: Partial Index for Premium Users
+### Programmatic Indexing
+```ts
+// Create index for premium research agents
+await MemFlow.Entity.createIndex('research-agent', 'isPremium', hotMeshClient);
+
+// Find premium agents needing verification
+const agents = await MemFlow.Entity.find('research-agent', {
+  isPremium: true,
+  needsVerification: true
+}, hotMeshClient);
+```
 
+### Direct SQL Access
 ```sql
--- Index only those user entities that are marked as premium
-CREATE INDEX idx_user_premium ON your_app.jobs (id)
-WHERE entity = 'user' AND (context->>'isPremium')::boolean = true;
+-- Same index via SQL (more control over index type/conditions)
+CREATE INDEX idx_research_agents_premium ON my_app.jobs (id)
+WHERE entity = 'research-agent' AND (context->>'isPremium')::boolean = true;
+
+-- Ad hoc query example
+SELECT id, context->>'status' as status, context->>'confidence' as confidence
+FROM my_app.jobs
+WHERE entity = 'research-agent'
+  AND (context->>'isPremium')::boolean = true
+  AND (context->>'confidence')::numeric > 0.8;
 ```
 
-This index improves performance for filtered queries while reducing index size.
+**Guidelines:**
+1. *Model intent, not mechanics.* Keep ephemeral calculation artifacts minimal; store derived values only if reused.
+2. *Index sparingly.* Each index is a write amplification cost. Start with 1–2 selective partial indexes.
+3. *Keep arrays append‑only where possible.* Supports audit and replay semantics cheaply.
+4. *Choose your tool:* Use Entity methods for standard queries, raw SQL for complex analytics or custom indexes.
 
 ---
 
 ## Durable AI Agents
+Agents become simpler: the *agent* is the memory record; hooks supply perspectives, verification, enrichment, or lifecycle progression.
 
-Agents often require memory—context that persists between invocations, spans multiple perspectives, or outlives a single process.
-
-The following example builds a "research agent" that executes hooks with different perspectives and then synthesizes. The data-first approach sets up initial state and then uses temporary hook functions to augment over the lifecycle of the entity record.
-
-### Research Agent Example
-
-#### Main Coordinator Agent
-
+### Coordinator (Research Agent)
 ```ts
-export async function researchAgent(query: string): Promise<any> {
-  const agent = await MemFlow.workflow.entity();
+export async function researchAgent(query: string) {
+  const entity = await MemFlow.workflow.entity();
 
-  // Set up shared memory for this agent session
-  const initialState = {
+  const initial = {
     query,
     findings: [],
     perspectives: {},
     confidence: 0,
     verification: {},
     status: 'researching',
-    startTime: new Date().toISOString(),
-  }
-  await agent.set<typeof initialState>(initialState);
-
-  // Launch perspective hooks in parallel
-  await MemFlow.workflow.execHook({
-    taskQueue: 'agents',
-    workflowName: 'optimisticPerspective',
-    args: [query],
-    signalId: 'optimistic-complete'
-  });
-
-  await MemFlow.workflow.execHook({
-    taskQueue: 'agents',
-    workflowName: 'skepticalPerspective',
-    args: [query],
-    signalId: 'skeptical-complete'
-  });
+    startTime: new Date().toISOString()
+  };
+  await entity.set<typeof initial>(initial);
 
-  await MemFlow.workflow.execHook({
-    taskQueue: 'agents',
-    workflowName: 'verificationHook',
-    args: [query],
-    signalId: 'verification-complete'
-  });
-
-  await MemFlow.workflow.execHook({
-    taskQueue: 'perspectives',
-    workflowName: 'synthesizePerspectives',
-    args: [],
-    signalId: 'synthesis-complete',
-  });
+  // Fan-out perspectives
+  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'optimisticPerspective', args: [query], signalId: 'optimistic-complete' });
+  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'skepticalPerspective', args: [query], signalId: 'skeptical-complete' });
+  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'verificationHook', args: [query], signalId: 'verification-complete' });
+  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'synthesizePerspectives', args: [], signalId: 'synthesis-complete' });
 
-  // return analysis, verification, and synthesis
-  return await agent.get();
+  return await entity.get();
 }
 ```
 
-> 💡 A complete implementation of this Research Agent example with tests, OpenAI integration, and multi-perspective analysis can be found in the [agent test suite](https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/agent).
-
-#### Perspective Hooks
-
+### Synthesis Hook
 ```ts
-// Optimistic hook looks for affirming evidence
-export async function optimisticPerspective(query: string, config: {signal: string}): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-  const findings = await searchForSupportingEvidence(query);
-  await entity.merge({ perspectives: { optimistic: { findings, confidence: 0.8 }}});
-  //signal the caller to notify all done
-  await MemFlow.workflow.signal(config.signal, {});
-}
-
-// Skeptical hook seeks out contradictions and counterpoints
-export async function skepticalPerspective(query: string, config: {signal: string}): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-  const counterEvidence = await searchForCounterEvidence(query);
-  await entity.merge({ perspectives: { skeptical: { counterEvidence, confidence: 0.6 }}});
-  await MemFlow.workflow.signal(config.signal, {});
-}
-
-// Other hooks...
-```
-
-#### Synthesis Hook
+export async function synthesizePerspectives({ signal }: { signal: string }) {
+  const e = await MemFlow.workflow.entity();
+  const ctx = await e.get();
 
-```ts
-// Synthesis hook aggregates different viewpoints
-export async function synthesizePerspectives(config: {signal: string}): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-  const context = await entity.get();
-
-  const result = await analyzePerspectives(context.perspectives);
-
-  await entity.merge({
+  const synthesized = await analyzePerspectives(ctx.perspectives);
+  await e.merge({
     perspectives: {
       synthesis: {
-        finalAssessment: result,
-        confidence: calculateConfidence(context.perspectives)
+        finalAssessment: synthesized,
+        confidence: calculateConfidence(ctx.perspectives)
       }
     },
     status: 'completed'
   });
-  await MemFlow.workflow.signal(config.signal, {});
+  await MemFlow.workflow.signal(signal, {});
 }
 ```
 
----
-
-## Building Pipelines with State
+> **Pattern:** Fan-out hooks that write *adjacent* subtrees (e.g., `perspectives.optimistic`, `perspectives.skeptical`). A final hook merges a compact synthesis object. Avoid cross-hook mutation of the same nested branch.
 
-HotMesh treats pipelines as long-lived records. Every pipeline run is stateful, resumable, and traceable.
+---
 
-### Setup a Data Pipeline
+## Stateful Pipelines
+Pipelines are identical in structure to agents: a coordinator seeds memory; phase hooks advance state; the entity is the audit trail.
 
+### Document Processing Pipeline (Coordinator)
 ```ts
-export async function dataPipeline(source: string): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-
-  // Initial policy and tracking setup
-  await entity.set({
-    source,
-    pipeline: { version: 1, policy: { refreshInterval: '24 hours' } },
-    changeLog: []
-  });
-
-  // Trigger the recurring orchestration pipeline
-  await MemFlow.workflow.execHook({
-    taskQueue: 'pipeline',
-    workflowName: 'runPipeline',
-    args: [true]
-  });
-}
-```
-
-### Orchestration Hook
+export async function documentProcessingPipeline() {
+  const pipeline = await MemFlow.workflow.entity();
 
-```ts
-export async function runPipeline(repeat = false): Promise<void> {
-  do {
-    // Perform transformation step
+  const initial = {
+    documentId: `doc-${Date.now()}`,
+    status: 'started',
+    startTime: new Date().toISOString(),
+    imageRefs: [],
+    extractedInfo: [],
+    validationResults: [],
+    finalResult: null,
+    processingSteps: [],
+    errors: [],
+    pageSignals: {}
+  };
+  await pipeline.set<typeof initial>(initial);
+
+  await pipeline.merge({ status: 'loading-images' });
+  await pipeline.append('processingSteps', 'image-load-started');
+  const imageRefs = await activities.loadImagePages();
+  if (!imageRefs?.length) throw new Error('No image references found');
+  await pipeline.merge({ imageRefs });
+  await pipeline.append('processingSteps', 'image-load-completed');
+
+  // Page hooks
+  for (const [i, ref] of imageRefs.entries()) {
+    const page = i + 1;
     await MemFlow.workflow.execHook({
-      taskQueue: 'transform',
-      workflowName: 'cleanData',
-      args: []
-    });
-
-    if (repeat) {
-      // Schedule next execution
-      await MemFlow.workflow.execHook({
-        taskQueue: 'scheduler',
-        workflowName: 'scheduleRefresh',
-        args: []
-      });
-    }
-  } while (repeat)
-}
-
-/**
- * Hook to clean and transform data
- */
-export async function cleanData(signalInfo?: { signal: string }): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-  
-  // Simulate data cleaning
-  await entity.merge({
-    status: 'cleaning',
-    lastCleanedAt: new Date().toISOString()
-  });
-
-  // Add to changelog
-  await entity.append('changeLog', {
-    action: 'clean',
-    timestamp: new Date().toISOString()
-  });
-
-  // Signal completion if called via execHook
-  if (signalInfo?.signal) {
-    await MemFlow.workflow.signal(signalInfo.signal, { 
-      status: 'cleaned',
-      timestamp: new Date().toISOString()
-    });
-  }
-}
-
-/**
- * Hook to schedule the next refresh based on policy
- */
-export async function scheduleRefresh(signalInfo?: { signal: string }): Promise<void> {
-  const entity = await MemFlow.workflow.entity();
-  
-  // Get refresh interval from policy
-  const currentEntity = await entity.get();
-  const refreshInterval = currentEntity.pipeline.policy.refreshInterval;
-  
-  // Sleep for the configured interval
-  await MemFlow.workflow.sleepFor(refreshInterval);
-  
-  // Update status after sleep
-  await entity.merge({
-    status: 'ready_for_refresh',
-    nextRefreshAt: new Date().toISOString()
-  });
-
-  // Add to changelog
-  await entity.append('changeLog', {
-    action: 'schedule_refresh',
-    timestamp: new Date().toISOString(),
-    nextRefresh: new Date().toISOString()
-  });
-
-  // Signal completion if called via execHook
-  if (signalInfo?.signal) {
-    await MemFlow.workflow.signal(signalInfo.signal, {
-      status: 'scheduled',
-      nextRefresh: new Date().toISOString()
+      taskQueue: 'pipeline',
+      workflowName: 'pageProcessingHook',
+      args: [ref, page, initial.documentId],
+      signalId: `page-${page}-complete`
     });
   }
-}
-```
 
-### Trigger from Outside
+  // Validation
+  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'validationHook', args: [initial.documentId], signalId: 'validation-complete' });
+  // Approval
+  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'approvalHook', args: [initial.documentId], signalId: 'approval-complete' });
+  // Notification
+  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'notificationHook', args: [initial.documentId], signalId: 'processing-complete' });
 
-```ts
-// External systems can trigger a single pipeline run
-export async function triggerRefresh() {
-  const client = new MemFlow.Client({/*...*/});
-
-  await client.workflow.hook({
-    workflowId: 'pipeline-123',
-    taskQueue: 'pipeline',
-    workflowName: 'runPipeline',
-    args: []
-  });
+  await pipeline.merge({ status: 'completed', completedAt: new Date().toISOString() });
+  await pipeline.append('processingSteps', 'pipeline-completed');
+  return await pipeline.get();
 }
 ```
 
-> 💡 A complete implementation of this Pipeline example with OpenAI Vision integration, processing hooks, and document workflow automation can be found in the [pipeline test suite](https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/pipeline).
+**Operational Characteristics:**
+- *Replay Friendly*: Each hook can be retried; pipeline memory records invariant progress markers (`processingSteps`).
+- *Parallelizable*: Pages fan out naturally without manual queue wiring.
+- *Auditable*: Entire lifecycle captured in a single evolving JSON record.
 
 ---
 
 ## Documentation & Links
-
-* SDK Reference – [hotmeshio.github.io/sdk-typescript](https://hotmeshio.github.io/sdk-typescript)
-* Examples – [github.com/hotmeshio/samples-typescript](https://github.com/hotmeshio/samples-typescript)
+* **SDK Reference** – https://hotmeshio.github.io/sdk-typescript
+* **Agent Example Tests** – https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/agent
+* **Pipeline Example Tests** – https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/pipeline
+* **Sample Projects** – https://github.com/hotmeshio/samples-typescript
 
 ---
 
 ## License
-
-Apache 2.0 – See `LICENSE` for details.
+Apache 2.0 with commercial restrictions* – see `LICENSE`.
+>*NOTE: It's open source with one commercial exception: Build, sell, and share solutions made with HotMesh. But don't white-label the orchestration core and repackage it as your own workflow-as-a-service.

package/build/index.d.ts

@@ -10,8 +10,6 @@ import { WorkerService as Worker } from './services/memflow/worker';
 import { WorkflowService as workflow } from './services/memflow/workflow';
 import { WorkflowHandleService as WorkflowHandle } from './services/memflow/handle';
 import { proxyActivities } from './services/memflow/workflow/proxyActivities';
-import { MeshData } from './services/meshdata';
-import { MeshOS } from './services/meshos';
 import * as Errors from './modules/errors';
 import * as Utils from './modules/utils';
 import * as Enums from './modules/enums';
@@ -22,5 +20,5 @@ import { RedisConnection as ConnectorIORedis } from './services/connector/provid
 import { RedisConnection as ConnectorRedis } from './services/connector/providers/redis';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 export { Connector, //factory
-ConnectorIORedis, ConnectorNATS, ConnectorPostgres, ConnectorRedis, HotMesh, HotMeshConfig, MeshCall, MeshData, MemFlow, MeshOS, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
+ConnectorIORedis, ConnectorNATS, ConnectorPostgres, ConnectorRedis, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
 export * as Types from './types';

package/build/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MeshOS = exports.MemFlow = exports.MeshData = exports.MeshCall = exports.HotMesh = exports.ConnectorRedis = exports.ConnectorPostgres = exports.ConnectorNATS = exports.ConnectorIORedis = exports.Connector = void 0;
+exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorRedis = exports.ConnectorPostgres = exports.ConnectorNATS = exports.ConnectorIORedis = exports.Connector = void 0;
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
 const meshcall_1 = require("./services/meshcall");
@@ -46,10 +46,6 @@ const handle_1 = require("./services/memflow/handle");
 Object.defineProperty(exports, "WorkflowHandle", { enumerable: true, get: function () { return handle_1.WorkflowHandleService; } });
 const proxyActivities_1 = require("./services/memflow/workflow/proxyActivities");
 Object.defineProperty(exports, "proxyActivities", { enumerable: true, get: function () { return proxyActivities_1.proxyActivities; } });
-const meshdata_1 = require("./services/meshdata");
-Object.defineProperty(exports, "MeshData", { enumerable: true, get: function () { return meshdata_1.MeshData; } });
-const meshos_1 = require("./services/meshos");
-Object.defineProperty(exports, "MeshOS", { enumerable: true, get: function () { return meshos_1.MeshOS; } });
 const Errors = __importStar(require("./modules/errors"));
 exports.Errors = Errors;
 const Utils = __importStar(require("./modules/utils"));

package/build/modules/enums.d.ts

@@ -108,3 +108,7 @@ export declare const HMSH_EXPIRE_DURATION: number;
 export declare const HMSH_FIDELITY_SECONDS: number;
 export declare const HMSH_SCOUT_INTERVAL_SECONDS: number;
 export declare const HMSH_GUID_SIZE: number;
+/**
+ * Default task queue name used when no task queue is specified
+ */
+export declare const DEFAULT_TASK_QUEUE = "default";

package/build/modules/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_IS_CLUSTER = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
+exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_IS_CLUSTER = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
 /**
  * Determines the log level for the application. The default is 'info'.
  */
@@ -132,3 +132,7 @@ exports.HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS
 exports.HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;
 // UTILS
 exports.HMSH_GUID_SIZE = Math.min(parseInt(process.env.HMSH_GUID_SIZE, 10) || 22, 32);
+/**
+ * Default task queue name used when no task queue is specified
+ */
+exports.DEFAULT_TASK_QUEUE = 'default';