@hotmeshio/hotmesh 0.1.15 → 0.1.16

package/build/types/meshflow.d.ts

@@ -0,0 +1,202 @@
+import { WorkflowHandleService } from '../services/meshflow/handle';
+import { LogLevel } from './logger';
+import { RedisClass, RedisOptions } from './redis';
+import { StringAnyType, StringStringType } from './serializer';
+import { StreamData, StreamError } from './stream';
+type WorkflowConfig = {
+    backoffCoefficient?: number;
+    maximumAttempts?: number;
+    maximumInterval?: string;
+    throwOnError?: boolean;
+};
+type WorkflowContext = {
+    canRetry: boolean;
+    COUNTER: {
+        counter: number;
+    };
+    counter: number;
+    cursor: string;
+    replay: StringStringType;
+    namespace: string;
+    interruptionRegistry: any[];
+    originJobId: string;
+    workflowId: string;
+    workflowDimension: string;
+    workflowTopic: string;
+    workflowTrace: string;
+    workflowSpan: string;
+    raw: StreamData;
+    connection: Connection;
+};
+export type WorkflowSearchSchema = Record<string, {
+    type: 'TEXT' | 'NUMERIC' | 'TAG';
+    sortable?: boolean;
+    nostem?: boolean;
+    noindex?: boolean;
+    indexed?: boolean;
+    examples?: string[];
+    nilable?: boolean;
+    primitive?: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    required?: boolean;
+    enum?: string[];
+    pattern?: string;
+    fieldName?: string;
+}>;
+type WorkflowSearchOptions = {
+    index?: string;
+    prefix?: string[];
+    schema?: WorkflowSearchSchema;
+    data?: StringStringType;
+};
+type SearchResults = {
+    count: number;
+    query: string;
+    data: StringStringType[];
+};
+type WorkflowOptions = {
+    namespace?: string;
+    taskQueue?: string;
+    args: any[];
+    workflowId?: string;
+    entity?: string;
+    workflowName?: string;
+    parentWorkflowId?: string;
+    originJobId?: string;
+    workflowTrace?: string;
+    workflowSpan?: string;
+    search?: WorkflowSearchOptions;
+    marker?: StringStringType;
+    config?: WorkflowConfig;
+    expire?: number;
+    signalIn?: boolean;
+    await?: boolean;
+    pending?: number;
+    guid?: string;
+};
+type HookOptions = {
+    namespace?: string;
+    taskQueue?: string;
+    args: any[];
+    entity?: string;
+    workflowId?: string;
+    workflowName?: string;
+    search?: WorkflowSearchOptions;
+    config?: WorkflowConfig;
+};
+type SignalOptions = {
+    taskQueue: string;
+    data: StringAnyType;
+    workflowId: string;
+    workflowName?: string;
+};
+type ActivityWorkflowDataType = {
+    activityName: string;
+    arguments: any[];
+    workflowId: string;
+    workflowTopic: string;
+};
+type WorkflowDataType = {
+    arguments: any[];
+    workflowId: string;
+    workflowTopic: string;
+    workflowDimension?: string;
+    originJobId?: string;
+    canRetry?: boolean;
+};
+type ConnectionConfig = {
+    class: Partial<RedisClass>;
+    options: Partial<RedisOptions>;
+};
+type Connection = ConnectionConfig;
+type ClientConfig = {
+    connection: Connection;
+};
+type Registry = {
+    [key: string]: Function;
+};
+type WorkerConfig = {
+    connection: Connection;
+    namespace?: string;
+    taskQueue: string;
+    workflow: Function | Record<string | symbol, Function>;
+    options?: WorkerOptions;
+    search?: WorkflowSearchOptions;
+    guid?: string;
+};
+type FindWhereQuery = {
+    field: string;
+    is: '=' | '==' | '>=' | '<=' | '[]';
+    value: string | boolean | number | [number, number];
+    type?: string;
+};
+type FindOptions = {
+    workflowName?: string;
+    taskQueue?: string;
+    namespace?: string;
+    index?: string;
+    search?: WorkflowSearchOptions;
+};
+type FindWhereOptions = {
+    options?: FindOptions;
+    count?: boolean;
+    query: FindWhereQuery[];
+    return?: string[];
+    limit?: {
+        start: number;
+        size: number;
+    };
+};
+type FindJobsOptions = {
+    match?: string;
+    namespace?: string;
+    limit?: number;
+    batch?: number;
+    cursor?: string;
+};
+type WorkerOptions = {
+    logLevel?: LogLevel;
+    maximumAttempts?: number;
+    backoffCoefficient?: number;
+    maximumInterval?: string;
+};
+type ContextType = {
+    workflowId: string;
+    workflowTopic: string;
+};
+type FunctionSignature<T> = T extends (...args: infer A) => infer R ? (...args: A) => R : never;
+type ProxyType<ACT> = {
+    [K in keyof ACT]: FunctionSignature<ACT[K]>;
+};
+type ActivityConfig = {
+    expire?: number;
+    startToCloseTimeout?: string;
+    activities?: any;
+    retryPolicy?: {
+        maximumAttempts?: number;
+        backoffCoefficient?: number;
+        maximumInterval?: string;
+        throwOnError?: boolean;
+    };
+};
+type ProxyResponseType<T> = {
+    data?: T;
+    $error?: StreamError;
+    done?: boolean;
+    jc: string;
+    ju: string;
+};
+type ChildResponseType<T> = {
+    data?: T;
+    $error?: StreamError;
+    done?: boolean;
+    jc: string;
+    ju: string;
+};
+interface ClientWorkflow {
+    start(options: WorkflowOptions): Promise<WorkflowHandleService>;
+    signal(signalId: string, data: StringAnyType, namespace?: string): Promise<string>;
+    hook(options: HookOptions): Promise<string>;
+    getHandle(taskQueue: string, workflowName: string, workflowId: string, namespace?: string): Promise<WorkflowHandleService>;
+    search(taskQueue: string, workflowName: string, namespace: string | null, index: string, ...query: string[]): Promise<string[]>;
+}
+export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ClientWorkflow, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, WorkflowContext, };

package/build/types/meshflow.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/types/pipe.d.ts

@@ -1,82 +1,17 @@
-/**
- * Represents a single cell value in a pipeline row
- * If the value is a string, the value will be a literal OR mapping expression
- */
 type PipeItem = string | boolean | number | null | object;
-/**
- * Array of `PipeItem` types.
- */
 type PipeItems = PipeItem[];
-/**
- * Represents a new nested context in the pipeline.
- * As the structure is recursive, the nested pipe may contain an
- * array of `PipeItem[]`, `PipeObject`, OR `ReduceObject` items.
- */
 type PipeObject = {
     '@pipe': Array<PipeItem[] | PipeObject | ReduceObject>;
 };
-/**
- * Reduce is similar to Pipe in that it represents a new context
- * and may include an array of `PipeItem[]`, `PipeObject`, or `ReduceObject`.
- * But it also iterates and produces output. The context variables,
- * `$input`, `$output`, `$item`, `$key`, and `$index` are available.
- * @example
- *
- * // Example of a reduce expression. The optional object is empty and
- * // serves as the $output during iteration. The last step in the iteration
- * // sets $output. if ther are no more iterations, the $output is returned
- * // and provided to the next step in the pipeline.
- *
- * // If data is:
- * // { response: ['a', 'b', 'c'] }
- *
- * // The reduced/transformed expression will be:
- * // { 'a': 0, 'b': 1, 'c': 2 }
- *
- * // Arrays and objects may be iterated over and transformed.
- *
- * //YAML
- * '@pipe':
- *   - ['{data.response}', {}]
- *   - '@reduce':
- *       - '@pipe':
- *           - ['{$output}']
- *       - '@pipe':
- *           - ['{$item}']
- *       - '@pipe':
- *           - ['{$index}']
- *       - ['{@object.set}']
- */
 type ReduceObject = {
     '@reduce': Array<PipeItem[] | PipeObject | ReduceObject>;
 };
-/**
- * Represents a sequence in the pipeline that can include arrays of `PipeItem`, `PipeObject`, or `ReduceObject`.
- */
 type Pipe = (PipeItem[] | PipeObject | ReduceObject)[];
-/**
- * Defines the context of a pipeline operation.
- */
 type PipeContext = {
-    /**
-     * Input of the current iteration.
-     */
     $input: unknown[];
-    /**
-     * Output of the current iteration and the final output for the reducer.
-     */
     $output: unknown;
-    /**
-     * Target item in the iterator.
-     */
     $item: unknown;
-    /**
-     * Array index as string or object key.
-     */
     $key: string;
-    /**
-     * Numeric index of the iterator.
-     */
     $index: number;
 };
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject };

package/build/types/quorum.d.ts

@@ -15,7 +15,6 @@ interface NetworkStat {
     tx_sec: number;
     ms: number;
 }
-/** reveals: memory, cpu, network */
 export interface SystemHealth {
     TotalMemoryGB: string;
     FreeMemoryGB: string;
@@ -24,15 +23,10 @@ export interface SystemHealth {
     NetworkStats: NetworkStat[];
 }
 export type ThrottleOptions = {
-    /** target an engine OR worker by GUID */
     guid?: string;
-    /** target a worker quorum */
     topic?: string;
-    /** entity/noun */
     entity?: string;
-    /** in milliseconds; set to -1 for indefinite throttle */
     throttle: number;
-    /** namespace */
     namespace?: string;
 };
 export interface QuorumProfile {
@@ -121,11 +115,5 @@ export type RollCallOptions = {
 export type SubscriptionOptions = {
     namespace?: string;
 };
-/**
- * The types in this file are used to define those messages that are sent
- * to hotmesh client instances when a new version is about to be activated.
- * These messages serve to coordinate the cache invalidation and switch-over
- * to the new version without any downtime and a coordinating parent server.
- */
 export type QuorumMessage = PingMessage | PongMessage | ActivateMessage | WorkMessage | JobMessage | ThrottleMessage | RollCallMessage | CronMessage;
 export {};

package/build/types/redis.d.ts

@@ -2,9 +2,6 @@
 import { StringStringType } from './serializer';
 import { ReclaimedMessageType } from './stream';
 type MultiResponseFlags = (string | number)[];
-/**
- * Redis types
- */
 interface ConnectionOptions {
     host?: string;
     port?: number;
@@ -144,9 +141,6 @@ interface RedisRedisClientType {
 interface RedisRedisClassType {
     createClient(options: RedisRedisClientOptions): Partial<RedisRedisClientType>;
 }
-/**
- * IORedis types
- */
 interface IORedisClientOptions {
     port?: number;
     host?: string;

package/build/types/stream.d.ts

@@ -1,38 +1,19 @@
-/** Represents a policy for retrying stream operations based on error codes */
 export interface StreamRetryPolicy {
-    /**
-     * Key is error code, value is the retry profile.
-     * Tuple contains: [max retry count, retry type].
-     * 'x' denotes exponential backoff (default). Only 10, 100, 1000, 10000 are allowed retry intervals.
-     */
     [key: string]: [number, 'x'?];
 }
-/** A 3-digit status code representing the outcome of a stream operation */
 export type StreamCode = number;
-/** Describes the structure of a stream error */
 export type StreamError = {
-    /** Descriptive message of the error */
     message: string;
-    /** Numeric code corresponding to the type of error */
     code: number;
-    /** Optional job identifier, used when communicating errors externally */
     job_id?: string;
-    /** Stack trace of the error if unhandled */
     stack?: string;
-    /** Name of the error if unhandled */
     name?: string;
-    /** Custom user-defined error details */
     error?: Record<string, unknown>;
-    /** True if originating via a standard transition message with an `error` status */
     is_stream_error?: boolean;
 };
-/** Enumerated status values for stream operations */
 export declare enum StreamStatus {
-    /** Indicates successful completion of the stream operation */
     SUCCESS = "success",
-    /** Indicates an error occurred during the stream operation */
     ERROR = "error",
-    /** Indicates the stream operation is still pending */
     PENDING = "pending"
 }
 export declare enum StreamDataType {
@@ -46,88 +27,48 @@ export declare enum StreamDataType {
     SIGNAL = "signal",
     INTERRUPT = "interrupt"
 }
-/** Defines the structure of stream data used when passing stream messages (transitions) */
 export interface StreamData {
-    /** Metadata associated with the stream data */
     metadata: {
-        /** Globally unique identifier for the StreamData message to distinguish `retries` from new 'reentry/cycles' */
         guid: string;
-        /** Workflow/job topic */
         topic?: string;
-        /** Workflow/job ID */
         jid?: string;
-        /** Workflow Generational ID (internal GUID) */
         gid?: string;
-        /** Dimensional address indicating the message routing specifics */
         dad?: string;
-        /** Activity ID */
         aid: string;
-        /** OpenTelemetry Trace identifier */
         trc?: string;
-        /** OpenTelemetry Span identifier */
         spn?: string;
-        /** Current try count, used for retry logic */
         try?: number;
-        /**
-         * Indicates if the message should wait for a response.
-         * If explicitly false, the connection is severed immediately
-         * upon verifying (and returning) the Job ID.
-         */
         await?: boolean;
     };
-    /** Type of the data being streamed, optional */
     type?: StreamDataType;
-    /** Actual data being transmitted as a record of key-value pairs */
     data: Record<string, unknown>;
-    /** Policies related to retry logic, optional */
     policies?: {
         retry?: StreamRetryPolicy;
     };
-    /** Status of the stream, default assumed as 'success' */
     status?: StreamStatus;
-    /** HTTP-like status code for the stream, default assumed as 200 */
     code?: number;
-    /** Error stack trace */
     stack?: string;
 }
-/** Extends StreamData for responses, allowing for inheritance of the base properties */
 export type StreamDataResponse = StreamData;
 export declare enum StreamRole {
     WORKER = "worker",
     ENGINE = "engine",
     SYSTEM = "system"
 }
-/**
- * Represents a type for messages that have been reclaimed from a stream.
- * Each item is a tuple containing a messageId and its details.
- */
 export type ReclaimedMessageType = [
-    /** The stream ID, typically formatted as `<timestamp>-<count>` */
     messageId: string,
-    /** Details of the message, consisting of a key and its value */
     details: [
-        /** Key is always 'message' */
         key: string,
-        /** Value is a stringified representation of StreamData */
         value: string
     ]
 ][];
-/** Configuration parameters for a stream */
 export type StreamConfig = {
-    /** Namespace under which the stream operates */
     namespace: string;
-    /** Application identifier */
     appId: string;
-    /** Globally unique identifier for the stream */
     guid: string;
-    /** Role associated with the stream */
     role: StreamRole;
-    /** Default throttle (read from KeyType.THROTTLE_RATE) */
     throttle: number;
-    /** Optional topic for the stream */
     topic?: string;
-    /** Delay before a message can be reclaimed, defaults to 60,000 milliseconds */
     reclaimDelay?: number;
-    /** Maximum number of reclaims allowed, defaults to 3. Values greater throw an error */
     reclaimCount?: number;
 };

package/build/types/stream.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamRole = exports.StreamDataType = exports.StreamStatus = void 0;
-/** Enumerated status values for stream operations */
 var StreamStatus;
 (function (StreamStatus) {
-    /** Indicates successful completion of the stream operation */
     StreamStatus["SUCCESS"] = "success";
-    /** Indicates an error occurred during the stream operation */
     StreamStatus["ERROR"] = "error";
-    /** Indicates the stream operation is still pending */
     StreamStatus["PENDING"] = "pending";
 })(StreamStatus = exports.StreamStatus || (exports.StreamStatus = {}));
 var StreamDataType;

package/index.ts

@@ -1,6 +1,25 @@
-import { Durable } from './services/durable';
-import { HotMeshService as HotMesh } from './services/hotmesh';
+import { MeshCall } from './services/meshcall';
+import { MeshData } from './services/meshdata';
+import { HotMesh } from './services/hotmesh';
+import { ClientService } from './services/meshflow/client';
+import { WorkerService } from './services/meshflow/worker';
+import { WorkflowService } from './services/meshflow/workflow';
+import { ConnectionService } from './services/meshflow/connection';
 import { HotMeshConfig } from './types/hotmesh';
 
-export { Durable, HotMesh, HotMeshConfig };
+const MeshFlow = {
+  Client: ClientService,
+  Worker: WorkerService,
+  workflow: WorkflowService,
+  Connection: ConnectionService,
+};
+
+export {
+  HotMesh,
+  MeshCall,
+  MeshData,
+  MeshFlow,
+  HotMeshConfig,
+};
+
 export * as Types from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -26,20 +26,20 @@
     "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:basic": "NODE_ENV=test jest ./tests/durable/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:collision": "NODE_ENV=test jest ./tests/durable/collision/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:hello": "HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:interrupt": "NODE_ENV=test jest ./tests/durable/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:durable:unknown": "NODE_ENV=test jest ./tests/durable/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow": "NODE_ENV=test jest ./tests/meshflow/*/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:basic": "NODE_ENV=test jest ./tests/meshflow/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:collision": "NODE_ENV=test jest ./tests/meshflow/collision/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:fatal": "NODE_ENV=test jest ./tests/meshflow/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:goodbye": "NODE_ENV=test jest ./tests/meshflow/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:hello": "HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/meshflow/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:hook": "NODE_ENV=test jest ./tests/meshflow/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:interrupt": "NODE_ENV=test jest ./tests/meshflow/interrupt/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:loopactivity": "NODE_ENV=test jest ./tests/meshflow/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:nested": "NODE_ENV=test jest ./tests/meshflow/nested/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:retry": "NODE_ENV=test jest ./tests/meshflow/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:sleep": "NODE_ENV=test jest ./tests/meshflow/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:signal": "NODE_ENV=test jest ./tests/meshflow/signal/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshflow:unknown": "NODE_ENV=test jest ./tests/meshflow/unknown/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:pending": "NODE_ENV=test jest ./tests/functional/pending/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:functional": "NODE_ENV=test jest ./tests/functional/*/index.test.ts --detectOpenHandles --forceExit --verbose",
@@ -63,6 +63,8 @@
     "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:meshdata": "NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshdata/index.test.ts --forceExit --verbose --detectOpenHandles",
+    "test:meshcall": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/meshcall/index.test.ts --forceExit --verbose --detectOpenHandles",
     "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose"
   },
   "keywords": [
@@ -102,6 +104,7 @@
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "ts-node-dev": "^2.0.0",
+    "typedoc": "^0.26.4",
     "typescript": "^5.0.4"
   },
   "peerDependencies": {

package/typedoc.json

@@ -0,0 +1,38 @@
+{
+  "entryPoints": [
+    "modules/enums.ts",
+    "modules/errors.ts",
+    "modules/key.ts",
+    "modules/utils.ts",
+    "services/hotmesh/index.ts",
+    "services/meshcall/index.ts",
+    "services/meshdata/index.ts",
+    "services/meshflow/index.ts",
+    "services/meshflow/client.ts",
+    "services/meshflow/handle.ts",
+    "services/meshflow/search.ts",
+    "services/meshflow/worker.ts",
+    "services/meshflow/workflow.ts",
+    "services/meshflow/connection.ts",
+    "types/*.ts"
+  ],
+  "highlightLanguages": [
+    "bash",
+    "console",
+    "css",
+    "html",
+    "javascript",
+    "json",
+    "jsonc",
+    "json5",
+    "tsx",
+    "typescript",
+    "yaml"
+  ],
+  "exclude": ["types/index.ts"],
+  "out": "docs/hotmesh",
+  "name": "",
+  "excludePrivate": true,
+  "theme": "default",
+  "customCss": "docs/css/custom.css"
+}

package/types/error.ts

@@ -1,4 +1,4 @@
-export type DurableChildErrorType = {
+export type MeshFlowChildErrorType = {
   arguments: string[];
   await?: boolean;
   backoffCoefficient?: number;
@@ -14,7 +14,7 @@ export type DurableChildErrorType = {
   workflowTopic: string;
 };
 
-export type DurableWaitForAllErrorType = {
+export type MeshFlowWaitForAllErrorType = {
   items: string[];
   workflowId: string;
   workflowTopic: string;
@@ -25,7 +25,7 @@ export type DurableWaitForAllErrorType = {
   workflowDimension: string;
 };
 
-export type DurableProxyErrorType = {
+export type MeshFlowProxyErrorType = {
   arguments: string[];
   activityName: string;
   backoffCoefficient?: number;
@@ -40,14 +40,14 @@ export type DurableProxyErrorType = {
   workflowTopic: string;
 };
 
-export type DurableWaitForErrorType = {
+export type MeshFlowWaitForErrorType = {
   signalId: string;
   index: number;
   workflowDimension: string;
   workflowId: string;
 };
 
-export type DurableSleepErrorType = {
+export type MeshFlowSleepErrorType = {
   duration: number;
   index: number;
   workflowDimension: string;

package/types/exporter.ts

@@ -87,7 +87,7 @@ export interface TransitionType {
   updated: string;
 }
 
-export interface DurableJobExport {
+export interface MeshFlowJobExport {
   data?: StringAnyType;
   state?: StringAnyType;
   status?: number;