@hotmeshio/hotmesh 0.9.0 → 0.10.1

package/build/services/{memflow → durable}/workflow/enrich.d.ts

@@ -14,20 +14,20 @@ import { StringStringType } from './common';
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function onboardingWorkflow(userId: string): Promise<void> {
  *   // Tag the workflow record with queryable metadata
- *   await MemFlow.workflow.enrich({
+ *   await Durable.workflow.enrich({
  *     userId,
  *     stage: 'verification',
  *     startedAt: new Date().toISOString(),
  *   });
  *
- *   const { verifyIdentity } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { verifyIdentity } = Durable.workflow.proxyActivities<typeof activities>();
  *   await verifyIdentity(userId);
  *
- *   await MemFlow.workflow.enrich({ stage: 'complete' });
+ *   await Durable.workflow.enrich({ stage: 'complete' });
  * }
  * ```
  *

package/build/services/{memflow → durable}/workflow/enrich.js

@@ -17,20 +17,20 @@ const searchMethods_1 = require("./searchMethods");
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function onboardingWorkflow(userId: string): Promise<void> {
  *   // Tag the workflow record with queryable metadata
- *   await MemFlow.workflow.enrich({
+ *   await Durable.workflow.enrich({
  *     userId,
  *     stage: 'verification',
  *     startedAt: new Date().toISOString(),
  *   });
  *
- *   const { verifyIdentity } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { verifyIdentity } = Durable.workflow.proxyActivities<typeof activities>();
  *   await verifyIdentity(userId);
  *
- *   await MemFlow.workflow.enrich({ stage: 'complete' });
+ *   await Durable.workflow.enrich({ stage: 'complete' });
  * }
  * ```
  *

package/build/services/{memflow → durable}/workflow/entityMethods.d.ts

@@ -11,10 +11,10 @@ import { Entity } from './common';
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function userProfileWorkflow(userId: string): Promise<UserProfile> {
- *   const entity = await MemFlow.workflow.entity();
+ *   const entity = await Durable.workflow.entity();
  *
  *   // Initialize a structured document
  *   await entity.set({
@@ -40,8 +40,8 @@ import { Entity } from './common';
  * ```typescript
  * // Accumulate state across activities
  * export async function pipelineWorkflow(input: string): Promise<PipelineResult> {
- *   const entity = await MemFlow.workflow.entity();
- *   const { step1, step2, step3 } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const entity = await Durable.workflow.entity();
+ *   const { step1, step2, step3 } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   const r1 = await step1(input);
  *   await entity.merge({ pipeline: { step1: r1 } });

package/build/services/{memflow → durable}/workflow/entityMethods.js

@@ -14,10 +14,10 @@ const common_1 = require("./common");
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function userProfileWorkflow(userId: string): Promise<UserProfile> {
- *   const entity = await MemFlow.workflow.entity();
+ *   const entity = await Durable.workflow.entity();
  *
  *   // Initialize a structured document
  *   await entity.set({
@@ -43,8 +43,8 @@ const common_1 = require("./common");
  * ```typescript
  * // Accumulate state across activities
  * export async function pipelineWorkflow(input: string): Promise<PipelineResult> {
- *   const entity = await MemFlow.workflow.entity();
- *   const { step1, step2, step3 } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const entity = await Durable.workflow.entity();
+ *   const { step1, step2, step3 } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   const r1 = await step1(input);
  *   await entity.merge({ pipeline: { step1: r1 } });

package/build/services/{memflow → durable}/workflow/execChild.d.ts

@@ -3,8 +3,8 @@ import { WorkflowOptions } from './common';
  * Spawns a child workflow and awaits its result. The child runs as an
  * independent job with its own lifecycle, retry policy, and dimensional
  * isolation. If the child fails, the error is propagated to the parent
- * as a typed error (`MemFlowFatalError`, `MemFlowMaxedError`,
- * `MemFlowTimeoutError`, or `MemFlowRetryError`).
+ * as a typed error (`DurableFatalError`, `DurableMaxedError`,
+ * `DurableTimeoutError`, or `DurableRetryError`).
  *
  * On replay, the stored child result is returned immediately without
  * re-spawning the child workflow.
@@ -19,11 +19,11 @@ import { WorkflowOptions } from './common';
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Spawn a child workflow and await its result
  * export async function parentWorkflow(orderId: string): Promise<string> {
- *   const result = await MemFlow.workflow.execChild<{ status: string }>({
+ *   const result = await Durable.workflow.execChild<{ status: string }>({
  *     taskQueue: 'payments',
  *     workflowName: 'processPayment',
  *     args: [orderId, 99.99],
@@ -41,7 +41,7 @@ import { WorkflowOptions } from './common';
  * export async function batchWorkflow(items: string[]): Promise<string[]> {
  *   const results = await Promise.all(
  *     items.map((item) =>
- *       MemFlow.workflow.execChild<string>({
+ *       Durable.workflow.execChild<string>({
  *         taskQueue: 'processors',
  *         workflowName: 'processItem',
  *         args: [item],
@@ -54,7 +54,7 @@ import { WorkflowOptions } from './common';
  *
  * ```typescript
  * // Entity-based child (uses entity name as task queue)
- * const user = await MemFlow.workflow.execChild<UserRecord>({
+ * const user = await Durable.workflow.execChild<UserRecord>({
  *   entity: 'user',
  *   args: [{ name: 'Alice', email: 'alice@example.com' }],
  *   workflowId: 'user-alice',          // deterministic ID
@@ -82,18 +82,18 @@ export declare const executeChild: typeof execChild;
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function dispatchWorkflow(taskId: string): Promise<string> {
  *   // Fire-and-forget: start the child and continue immediately
- *   const childJobId = await MemFlow.workflow.startChild({
+ *   const childJobId = await Durable.workflow.startChild({
  *     taskQueue: 'background',
  *     workflowName: 'longRunningTask',
  *     args: [taskId],
  *   });
  *
  *   // Optionally store the child ID for monitoring
- *   const search = await MemFlow.workflow.search();
+ *   const search = await Durable.workflow.search();
  *   await search.set({ childJobId });
  *
  *   return childJobId;

package/build/services/{memflow → durable}/workflow/execChild.js

@@ -29,10 +29,10 @@ function getChildInterruptPayload(context, options, execIndex) {
     return {
         arguments: [...(options.args || [])],
         await: options?.await ?? true,
-        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_MEMFLOW_EXP_BACKOFF,
+        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_DURABLE_EXP_BACKOFF,
         index: execIndex,
-        maximumAttempts: options?.config?.maximumAttempts ?? common_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
-        maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MEMFLOW_MAX_INTERVAL),
+        maximumAttempts: options?.config?.maximumAttempts ?? common_1.HMSH_DURABLE_MAX_ATTEMPTS,
+        maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_DURABLE_MAX_INTERVAL),
         originJobId: originJobId ?? workflowId,
         entity: options.entity,
         expire: options.expire ?? expire,
@@ -48,8 +48,8 @@ function getChildInterruptPayload(context, options, execIndex) {
  * Spawns a child workflow and awaits its result. The child runs as an
  * independent job with its own lifecycle, retry policy, and dimensional
  * isolation. If the child fails, the error is propagated to the parent
- * as a typed error (`MemFlowFatalError`, `MemFlowMaxedError`,
- * `MemFlowTimeoutError`, or `MemFlowRetryError`).
+ * as a typed error (`DurableFatalError`, `DurableMaxedError`,
+ * `DurableTimeoutError`, or `DurableRetryError`).
  *
  * On replay, the stored child result is returned immediately without
  * re-spawning the child workflow.
@@ -64,11 +64,11 @@ function getChildInterruptPayload(context, options, execIndex) {
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Spawn a child workflow and await its result
  * export async function parentWorkflow(orderId: string): Promise<string> {
- *   const result = await MemFlow.workflow.execChild<{ status: string }>({
+ *   const result = await Durable.workflow.execChild<{ status: string }>({
  *     taskQueue: 'payments',
  *     workflowName: 'processPayment',
  *     args: [orderId, 99.99],
@@ -86,7 +86,7 @@ function getChildInterruptPayload(context, options, execIndex) {
  * export async function batchWorkflow(items: string[]): Promise<string[]> {
  *   const results = await Promise.all(
  *     items.map((item) =>
- *       MemFlow.workflow.execChild<string>({
+ *       Durable.workflow.execChild<string>({
  *         taskQueue: 'processors',
  *         workflowName: 'processItem',
  *         args: [item],
@@ -99,7 +99,7 @@ function getChildInterruptPayload(context, options, execIndex) {
  *
  * ```typescript
  * // Entity-based child (uses entity name as task queue)
- * const user = await MemFlow.workflow.execChild<UserRecord>({
+ * const user = await Durable.workflow.execChild<UserRecord>({
  *   entity: 'user',
  *   args: [{ name: 'Alice', email: 'alice@example.com' }],
  *   workflowId: 'user-alice',          // deterministic ID
@@ -123,17 +123,17 @@ async function execChild(options) {
                 const code = result.$error.code;
                 const message = result.$error.message;
                 const stack = result.$error.stack;
-                if (code === common_1.HMSH_CODE_MEMFLOW_FATAL) {
-                    throw new common_1.MemFlowFatalError(message, stack);
+                if (code === common_1.HMSH_CODE_DURABLE_FATAL) {
+                    throw new common_1.DurableFatalError(message, stack);
                 }
-                else if (code === common_1.HMSH_CODE_MEMFLOW_MAXED) {
-                    throw new common_1.MemFlowMaxedError(message, stack);
+                else if (code === common_1.HMSH_CODE_DURABLE_MAXED) {
+                    throw new common_1.DurableMaxedError(message, stack);
                 }
-                else if (code === common_1.HMSH_CODE_MEMFLOW_TIMEOUT) {
-                    throw new common_1.MemFlowTimeoutError(message, stack);
+                else if (code === common_1.HMSH_CODE_DURABLE_TIMEOUT) {
+                    throw new common_1.DurableTimeoutError(message, stack);
                 }
                 else {
-                    throw new common_1.MemFlowRetryError(message, stack);
+                    throw new common_1.DurableRetryError(message, stack);
                 }
             }
             return result.$error;
@@ -144,12 +144,12 @@ async function execChild(options) {
     }
     const interruptionMessage = getChildInterruptPayload(context, options, execIndex);
     interruptionRegistry.push({
-        code: common_1.HMSH_CODE_MEMFLOW_CHILD,
-        type: 'MemFlowChildError',
+        code: common_1.HMSH_CODE_DURABLE_CHILD,
+        type: 'DurableChildError',
         ...interruptionMessage,
     });
     await (0, common_1.sleepImmediate)();
-    throw new common_1.MemFlowChildError(interruptionMessage);
+    throw new common_1.DurableChildError(interruptionMessage);
 }
 exports.execChild = execChild;
 /**
@@ -167,18 +167,18 @@ exports.executeChild = execChild;
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * export async function dispatchWorkflow(taskId: string): Promise<string> {
  *   // Fire-and-forget: start the child and continue immediately
- *   const childJobId = await MemFlow.workflow.startChild({
+ *   const childJobId = await Durable.workflow.startChild({
  *     taskQueue: 'background',
  *     workflowName: 'longRunningTask',
  *     args: [taskId],
  *   });
  *
  *   // Optionally store the child ID for monitoring
- *   const search = await MemFlow.workflow.search();
+ *   const search = await Durable.workflow.search();
  *   await search.set({ childJobId });
  *
  *   return childJobId;

package/build/services/{memflow → durable}/workflow/execHook.d.ts

@@ -17,8 +17,8 @@ export interface ExecHookOptions extends HookOptions {
  *
  * A `signalId` is automatically generated (or use the one you provide)
  * and injected as the **last argument** to the hooked function as
- * `{ signal: string, $memflow: true }`. The hook function must call
- * `MemFlow.workflow.signal(signalInfo.signal, result)` to deliver
+ * `{ signal: string, $durable: true }`. The hook function must call
+ * `Durable.workflow.signal(signalInfo.signal, result)` to deliver
  * its response back to the waiting workflow.
  *
  * ## Difference from `execChild`
@@ -31,11 +31,11 @@ export interface ExecHookOptions extends HookOptions {
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Orchestrator: spawn a hook and await its result
  * export async function reviewWorkflow(docId: string): Promise<string> {
- *   const verdict = await MemFlow.workflow.execHook<{ approved: boolean }>({
+ *   const verdict = await Durable.workflow.execHook<{ approved: boolean }>({
  *     taskQueue: 'reviewers',
  *     workflowName: 'reviewDocument',
  *     args: [docId],
@@ -49,15 +49,15 @@ export interface ExecHookOptions extends HookOptions {
  * // The hooked function (runs on the 'reviewers' worker)
  * export async function reviewDocument(
  *   docId: string,
- *   signalInfo?: { signal: string; $memflow: boolean },
+ *   signalInfo?: { signal: string; $durable: boolean },
  * ): Promise<{ approved: boolean }> {
- *   const { analyzeDocument } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { analyzeDocument } = Durable.workflow.proxyActivities<typeof activities>();
  *   const score = await analyzeDocument(docId);
  *   const result = { approved: score > 0.8 };
  *
  *   // Signal the waiting workflow with the result
  *   if (signalInfo?.signal) {
- *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *     await Durable.workflow.signal(signalInfo.signal, result);
  *   }
  *   return result;
  * }
@@ -65,7 +65,7 @@ export interface ExecHookOptions extends HookOptions {
  *
  * ```typescript
  * // With explicit signalId for traceability
- * const result = await MemFlow.workflow.execHook<AnalysisResult>({
+ * const result = await Durable.workflow.execHook<AnalysisResult>({
  *   taskQueue: 'analyzers',
  *   workflowName: 'runAnalysis',
  *   args: [datasetId],

package/build/services/{memflow → durable}/workflow/execHook.js

@@ -14,8 +14,8 @@ const interruption_1 = require("./interruption");
  *
  * A `signalId` is automatically generated (or use the one you provide)
  * and injected as the **last argument** to the hooked function as
- * `{ signal: string, $memflow: true }`. The hook function must call
- * `MemFlow.workflow.signal(signalInfo.signal, result)` to deliver
+ * `{ signal: string, $durable: true }`. The hook function must call
+ * `Durable.workflow.signal(signalInfo.signal, result)` to deliver
  * its response back to the waiting workflow.
  *
  * ## Difference from `execChild`
@@ -28,11 +28,11 @@ const interruption_1 = require("./interruption");
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Orchestrator: spawn a hook and await its result
  * export async function reviewWorkflow(docId: string): Promise<string> {
- *   const verdict = await MemFlow.workflow.execHook<{ approved: boolean }>({
+ *   const verdict = await Durable.workflow.execHook<{ approved: boolean }>({
  *     taskQueue: 'reviewers',
  *     workflowName: 'reviewDocument',
  *     args: [docId],
@@ -46,15 +46,15 @@ const interruption_1 = require("./interruption");
  * // The hooked function (runs on the 'reviewers' worker)
  * export async function reviewDocument(
  *   docId: string,
- *   signalInfo?: { signal: string; $memflow: boolean },
+ *   signalInfo?: { signal: string; $durable: boolean },
  * ): Promise<{ approved: boolean }> {
- *   const { analyzeDocument } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { analyzeDocument } = Durable.workflow.proxyActivities<typeof activities>();
  *   const score = await analyzeDocument(docId);
  *   const result = { approved: score > 0.8 };
  *
  *   // Signal the waiting workflow with the result
  *   if (signalInfo?.signal) {
- *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *     await Durable.workflow.signal(signalInfo.signal, result);
  *   }
  *   return result;
  * }
@@ -62,7 +62,7 @@ const interruption_1 = require("./interruption");
  *
  * ```typescript
  * // With explicit signalId for traceability
- * const result = await MemFlow.workflow.execHook<AnalysisResult>({
+ * const result = await Durable.workflow.execHook<AnalysisResult>({
  *   taskQueue: 'analyzers',
  *   workflowName: 'runAnalysis',
  *   args: [datasetId],
@@ -77,11 +77,11 @@ const interruption_1 = require("./interruption");
 async function execHook(options) {
     try {
         if (!options.signalId) {
-            options.signalId = 'memflow-hook-' + crypto.randomUUID();
+            options.signalId = 'durable-hook-' + crypto.randomUUID();
         }
         const hookOptions = {
             ...options,
-            args: [...options.args, { signal: options.signalId, $memflow: true }],
+            args: [...options.args, { signal: options.signalId, $durable: true }],
         };
         // Execute the hook with the signal information
         await (0, hook_1.hook)(hookOptions);

package/build/services/{memflow → durable}/workflow/execHookBatch.d.ts

@@ -20,17 +20,17 @@ export interface BatchHookConfig<T = any> {
  *
  * 1. **Fire all hooks** via `Promise.all` (registers streams immediately).
  * 2. **Await all signals** via `Promise.all` (all `waitFor` registrations
- *    happen together before any `MemFlowWaitForError` is thrown).
+ *    happen together before any `DurableWaitForError` is thrown).
  * 3. **Combine results** into a `{ [key]: result }` map.
  *
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Fan-out to multiple AI agents, gather all perspectives
  * export async function researchWorkflow(query: string): Promise<Summary> {
- *   const perspectives = await MemFlow.workflow.execHookBatch<{
+ *   const perspectives = await Durable.workflow.execHookBatch<{
  *     optimistic: PerspectiveResult;
  *     skeptical: PerspectiveResult;
  *     neutral: PerspectiveResult;
@@ -62,7 +62,7 @@ export interface BatchHookConfig<T = any> {
  *   ]);
  *
  *   // All three results are available as typed properties
- *   const { synthesize } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { synthesize } = Durable.workflow.proxyActivities<typeof activities>();
  *   return await synthesize(
  *     perspectives.optimistic,
  *     perspectives.skeptical,
@@ -73,7 +73,7 @@ export interface BatchHookConfig<T = any> {
  *
  * ```typescript
  * // Parallel validation with different services
- * const checks = await MemFlow.workflow.execHookBatch<{
+ * const checks = await Durable.workflow.execHookBatch<{
  *   fraud: { safe: boolean };
  *   compliance: { approved: boolean };
  * }>([

package/build/services/{memflow → durable}/workflow/execHookBatch.js

@@ -14,17 +14,17 @@ const waitFor_1 = require("./waitFor");
  *
  * 1. **Fire all hooks** via `Promise.all` (registers streams immediately).
  * 2. **Await all signals** via `Promise.all` (all `waitFor` registrations
- *    happen together before any `MemFlowWaitForError` is thrown).
+ *    happen together before any `DurableWaitForError` is thrown).
  * 3. **Combine results** into a `{ [key]: result }` map.
  *
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Fan-out to multiple AI agents, gather all perspectives
  * export async function researchWorkflow(query: string): Promise<Summary> {
- *   const perspectives = await MemFlow.workflow.execHookBatch<{
+ *   const perspectives = await Durable.workflow.execHookBatch<{
  *     optimistic: PerspectiveResult;
  *     skeptical: PerspectiveResult;
  *     neutral: PerspectiveResult;
@@ -56,7 +56,7 @@ const waitFor_1 = require("./waitFor");
  *   ]);
  *
  *   // All three results are available as typed properties
- *   const { synthesize } = MemFlow.workflow.proxyActivities<typeof activities>();
+ *   const { synthesize } = Durable.workflow.proxyActivities<typeof activities>();
  *   return await synthesize(
  *     perspectives.optimistic,
  *     perspectives.skeptical,
@@ -67,7 +67,7 @@ const waitFor_1 = require("./waitFor");
  *
  * ```typescript
  * // Parallel validation with different services
- * const checks = await MemFlow.workflow.execHookBatch<{
+ * const checks = await Durable.workflow.execHookBatch<{
  *   fraud: { safe: boolean };
  *   compliance: { approved: boolean };
  * }>([
@@ -104,7 +104,7 @@ async function execHookBatch(hookConfigs) {
         ...config,
         options: {
             ...config.options,
-            signalId: config.options.signalId || `memflow-hook-${crypto.randomUUID()}`
+            signalId: config.options.signalId || `durable-hook-${crypto.randomUUID()}`
         }
     }));
     // STEP 1: Fire off all hooks (but don't await them)
@@ -114,14 +114,14 @@ async function execHookBatch(hookConfigs) {
             ...config.options,
             args: [...config.options.args, {
                     signal: config.options.signalId,
-                    $memflow: true
+                    $durable: true
                 }]
         };
         return (0, hook_1.hook)(hookOptions);
     }));
     // STEP 2: Await all waitFor operations 
     // This ensures all waitFor registrations happen in the same call stack
-    // before any MemFlowWaitForError is thrown (via setImmediate mechanism)
+    // before any DurableWaitForError is thrown (via setImmediate mechanism)
     const results = await Promise.all(processedConfigs.map(config => (0, waitFor_1.waitFor)(config.options.signalId)));
     // STEP 3: Return results as a keyed object
     return Object.fromEntries(processedConfigs.map((config, i) => [config.key, results[i]]));

package/build/services/{memflow → durable}/workflow/hook.d.ts

@@ -25,11 +25,11 @@ import { HookOptions } from './common';
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Fire-and-forget: spawn a hook without waiting for its result
  * export async function notifyWorkflow(userId: string): Promise<void> {
- *   await MemFlow.workflow.hook({
+ *   await Durable.workflow.hook({
  *     taskQueue: 'notifications',
  *     workflowName: 'sendNotification',
  *     args: [userId, 'Your order has shipped'],
@@ -43,20 +43,20 @@ import { HookOptions } from './common';
  * export async function manualHookPattern(itemId: string): Promise<string> {
  *   const signalId = `process-${itemId}`;
  *
- *   await MemFlow.workflow.hook({
+ *   await Durable.workflow.hook({
  *     taskQueue: 'processors',
  *     workflowName: 'processItem',
  *     args: [itemId, signalId],
  *   });
  *
  *   // Manually wait for the hook to signal back
- *   return await MemFlow.workflow.waitFor<string>(signalId);
+ *   return await Durable.workflow.waitFor<string>(signalId);
  * }
  * ```
  *
  * ```typescript
  * // Hook with retry configuration
- * await MemFlow.workflow.hook({
+ * await Durable.workflow.hook({
  *   taskQueue: 'enrichment',
  *   workflowName: 'enrichProfile',
  *   args: [profileId],

package/build/services/{memflow → durable}/workflow/hook.js

@@ -30,11 +30,11 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  * ## Examples
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  *
  * // Fire-and-forget: spawn a hook without waiting for its result
  * export async function notifyWorkflow(userId: string): Promise<void> {
- *   await MemFlow.workflow.hook({
+ *   await Durable.workflow.hook({
  *     taskQueue: 'notifications',
  *     workflowName: 'sendNotification',
  *     args: [userId, 'Your order has shipped'],
@@ -48,20 +48,20 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  * export async function manualHookPattern(itemId: string): Promise<string> {
  *   const signalId = `process-${itemId}`;
  *
- *   await MemFlow.workflow.hook({
+ *   await Durable.workflow.hook({
  *     taskQueue: 'processors',
  *     workflowName: 'processItem',
  *     args: [itemId, signalId],
  *   });
  *
  *   // Manually wait for the hook to signal back
- *   return await MemFlow.workflow.waitFor<string>(signalId);
+ *   return await Durable.workflow.waitFor<string>(signalId);
  * }
  * ```
  *
  * ```typescript
  * // Hook with retry configuration
- * await MemFlow.workflow.hook({
+ * await Durable.workflow.hook({
  *   taskQueue: 'enrichment',
  *   workflowName: 'enrichProfile',
  *   args: [profileId],
@@ -95,12 +95,12 @@ async function hook(options) {
         if (targetTopic === workflowTopic &&
             !options.entity &&
             !options.taskQueue) {
-            throw new Error(`MemFlow Hook Error: Potential infinite loop detected!\n\n` +
+            throw new Error(`Durable Hook Error: Potential infinite loop detected!\n\n` +
                 `The hook would target the same workflow topic ('${workflowTopic}') as the current workflow, ` +
                 `creating an infinite loop.\n\n` +
                 `To fix this, provide either:\n` +
-                `1. 'taskQueue' parameter: MemFlow.workflow.hook({ taskQueue: 'your-queue', workflowName: '${options.workflowName}', args: [...] })\n` +
-                `2. 'entity' parameter: MemFlow.workflow.hook({ entity: 'your-entity', args: [...] })\n\n` +
+                `1. 'taskQueue' parameter: Durable.workflow.hook({ taskQueue: 'your-queue', workflowName: '${options.workflowName}', args: [...] })\n` +
+                `2. 'entity' parameter: Durable.workflow.hook({ entity: 'your-entity', args: [...] })\n\n` +
                 `Current workflow topic: ${workflowTopic}\n` +
                 `Target topic would be: ${targetTopic}\n` +
                 `Provided options: ${JSON.stringify({
@@ -113,9 +113,9 @@ async function hook(options) {
             arguments: [...options.args],
             id: targetWorkflowId,
             workflowTopic: targetTopic,
-            backoffCoefficient: options.config?.backoffCoefficient || common_1.HMSH_MEMFLOW_EXP_BACKOFF,
-            maximumAttempts: options.config?.maximumAttempts || common_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
-            maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_MEMFLOW_MAX_INTERVAL),
+            backoffCoefficient: options.config?.backoffCoefficient || common_1.HMSH_DURABLE_EXP_BACKOFF,
+            maximumAttempts: options.config?.maximumAttempts || common_1.HMSH_DURABLE_MAX_ATTEMPTS,
+            maximumInterval: (0, common_1.s)(options?.config?.maximumInterval ?? common_1.HMSH_DURABLE_MAX_INTERVAL),
         };
         return await hotMeshClient.signal(`${namespace}.flow.signal`, payload, common_1.StreamStatus.PENDING, 202);
     }

package/build/services/{memflow → durable}/workflow/index.d.ts

@@ -20,7 +20,7 @@ import { waitFor } from './waitFor';
 import { HotMesh } from './common';
 import { entity } from './entityMethods';
 /**
- * The workflow-internal API surface, exposed as `MemFlow.workflow`. Every
+ * The workflow-internal API surface, exposed as `Durable.workflow`. Every
  * method on this class is designed to be called **inside** a workflow
  * function — they participate in deterministic replay and durable state
  * management.
@@ -62,13 +62,13 @@ import { entity } from './entityMethods';
  * ## Example
  *
  * ```typescript
- * import { MemFlow } from '@hotmeshio/hotmesh';
+ * import { Durable } from '@hotmeshio/hotmesh';
  * import * as activities from './activities';
  *
  * export async function orderWorkflow(orderId: string): Promise<string> {
  *   // Proxy activities for durable execution
  *   const { validateOrder, processPayment, sendReceipt } =
- *     MemFlow.workflow.proxyActivities<typeof activities>({
+ *     Durable.workflow.proxyActivities<typeof activities>({
  *       activities,
  *       retryPolicy: { maximumAttempts: 3 },
  *     });
@@ -76,15 +76,15 @@ import { entity } from './entityMethods';
  *   await validateOrder(orderId);
  *
  *   // Durable sleep (survives restarts)
- *   await MemFlow.workflow.sleepFor('5 seconds');
+ *   await Durable.workflow.sleepFor('5 seconds');
  *
  *   const receipt = await processPayment(orderId);
  *
  *   // Store searchable metadata
- *   await MemFlow.workflow.enrich({ orderId, status: 'paid' });
+ *   await Durable.workflow.enrich({ orderId, status: 'paid' });
  *
  *   // Wait for external approval signal
- *   const approval = await MemFlow.workflow.waitFor<{ ok: boolean }>('approve');
+ *   const approval = await Durable.workflow.waitFor<{ ok: boolean }>('approve');
  *   if (!approval.ok) return 'cancelled';
  *
  *   await sendReceipt(orderId, receipt);