@hotmeshio/hotmesh 0.4.0 → 0.4.2

package/build/services/memflow/workflow/contextMethods.d.ts

@@ -0,0 +1,14 @@
+import { Context } from './common';
+/**
+ * Returns a context session handle for interacting with the workflow's JSONB context storage.
+ * @returns {Promise<Context>} A context session for workflow data.
+ *
+ * @example
+ * ```typescript
+ * const context = await workflow.context();
+ * await context.set({ user: { id: 123 } });
+ * await context.merge({ user: { name: "John" } });
+ * const user = await context.get("user");
+ * ```
+ */
+export declare function context(): Promise<Context>;

package/build/services/memflow/workflow/contextMethods.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.context = void 0;
+const common_1 = require("./common");
+/**
+ * Returns a context session handle for interacting with the workflow's JSONB context storage.
+ * @returns {Promise<Context>} A context session for workflow data.
+ *
+ * @example
+ * ```typescript
+ * const context = await workflow.context();
+ * await context.set({ user: { id: 123 } });
+ * await context.merge({ user: { name: "John" } });
+ * const user = await context.get("user");
+ * ```
+ */
+async function context() {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowId = store.get('workflowId');
+    const workflowDimension = store.get('workflowDimension') ?? '';
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const COUNTER = store.get('counter');
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    const contextSessionId = `-context${workflowDimension}-${execIndex}`;
+    return new common_1.Context(workflowId, hotMeshClient, contextSessionId);
+}
+exports.context = context;

package/build/services/memflow/workflow/didRun.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines if a replayed execution result already exists for the given prefix.
+ * @private
+ * @param {string} prefix - Identifier prefix (e.g., 'proxy', 'child', 'start', 'wait', etc.)
+ * @returns {Promise<[boolean, number, any]>} A tuple: [alreadyRan, executionIndex, restoredData]
+ */
+export declare function didRun(prefix: string): Promise<[boolean, number, any]>;

package/build/services/memflow/workflow/didRun.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.didRun = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+/**
+ * Determines if a replayed execution result already exists for the given prefix.
+ * @private
+ * @param {string} prefix - Identifier prefix (e.g., 'proxy', 'child', 'start', 'wait', etc.)
+ * @returns {Promise<[boolean, number, any]>} A tuple: [alreadyRan, executionIndex, restoredData]
+ */
+async function didRun(prefix) {
+    const { COUNTER, replay, workflowDimension } = (0, context_1.getContext)();
+    const execIndex = COUNTER.counter = COUNTER.counter + 1;
+    const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+    if (sessionId in replay) {
+        const restored = common_1.SerializerService.fromString(replay[sessionId]);
+        return [true, execIndex, restored];
+    }
+    return [false, execIndex, null];
+}
+exports.didRun = didRun;

package/build/services/memflow/workflow/emit.d.ts

@@ -0,0 +1,11 @@
+import { StringAnyType } from './common';
+/**
+ * Emits events to the event bus provider. Topics are prefixed with the quorum namespace.
+ *
+ * @param {StringAnyType} events - A mapping of topic => message to publish.
+ * @param {{ once: boolean }} [config={ once: true }] - If `once` is true, events are emitted only once.
+ * @returns {Promise<boolean>} True after emission completes.
+ */
+export declare function emit(events: StringAnyType, config?: {
+    once: boolean;
+}): Promise<boolean>;

package/build/services/memflow/workflow/emit.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emit = void 0;
+const common_1 = require("./common");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+/**
+ * Emits events to the event bus provider. Topics are prefixed with the quorum namespace.
+ *
+ * @param {StringAnyType} events - A mapping of topic => message to publish.
+ * @param {{ once: boolean }} [config={ once: true }] - If `once` is true, events are emitted only once.
+ * @returns {Promise<boolean>} True after emission completes.
+ */
+async function emit(events, config = { once: true }) {
+    const store = common_1.asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
+    const connection = store.get('connection');
+    const namespace = store.get('namespace');
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (!config.once || await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'emit')) {
+        for (const [topic, message] of Object.entries(events)) {
+            await hotMeshClient.quorum.pub({ topic, message });
+        }
+    }
+    return true;
+}
+exports.emit = emit;

package/build/services/memflow/workflow/enrich.d.ts

@@ -0,0 +1,9 @@
+import { StringStringType } from './common';
+/**
+ * Adds custom user data to the backend workflow record (writes to HASH).
+ * Runs exactly once during workflow execution.
+ *
+ * @param {StringStringType} fields - Key-value fields to enrich the workflow record.
+ * @returns {Promise<boolean>} True when enrichment is completed.
+ */
+export declare function enrich(fields: StringStringType): Promise<boolean>;

package/build/services/memflow/workflow/enrich.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrich = void 0;
+const searchMethods_1 = require("./searchMethods");
+/**
+ * Adds custom user data to the backend workflow record (writes to HASH).
+ * Runs exactly once during workflow execution.
+ *
+ * @param {StringStringType} fields - Key-value fields to enrich the workflow record.
+ * @returns {Promise<boolean>} True when enrichment is completed.
+ */
+async function enrich(fields) {
+    const searchSession = await (0, searchMethods_1.search)();
+    await searchSession.set(fields);
+    return true;
+}
+exports.enrich = enrich;

package/build/services/memflow/workflow/execChild.d.ts

@@ -0,0 +1,18 @@
+import { WorkflowOptions } from './common';
+/**
+ * Spawns a child workflow and awaits the result, or if `await` is false, returns immediately.
+ * @template T
+ * @param {WorkflowOptions} options - Workflow options.
+ * @returns {Promise<T>} Result of the child workflow.
+ */
+export declare function execChild<T>(options: WorkflowOptions): Promise<T>;
+/**
+ * Alias for execChild.
+ */
+export declare const executeChild: typeof execChild;
+/**
+ * Spawns a child workflow and returns the child Job ID without awaiting its completion.
+ * @param {WorkflowOptions} options - Workflow options.
+ * @returns {Promise<string>} The child job ID.
+ */
+export declare function startChild(options: WorkflowOptions): Promise<string>;

package/build/services/memflow/workflow/execChild.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startChild = exports.executeChild = exports.execChild = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const didRun_1 = require("./didRun");
+/**
+ * Constructs the payload necessary to spawn a child workflow.
+ * @private
+ */
+function getChildInterruptPayload(context, options, execIndex) {
+    const { workflowId, originJobId, workflowDimension, expire } = context;
+    let childJobId;
+    if (options.workflowId) {
+        childJobId = options.workflowId;
+    }
+    else if (options.entity) {
+        childJobId = `${options.entity}-${(0, common_1.guid)()}-${workflowDimension}-${execIndex}`;
+    }
+    else {
+        childJobId = `-${options.workflowName}-${(0, common_1.guid)()}-${workflowDimension}-${execIndex}`;
+    }
+    const parentWorkflowId = workflowId;
+    const taskQueueName = options.taskQueue ?? options.entity;
+    const workflowName = options.entity ?? options.workflowName;
+    const workflowTopic = `${taskQueueName}-${workflowName}`;
+    return {
+        arguments: [...(options.args || [])],
+        await: options?.await ?? true,
+        backoffCoefficient: options?.config?.backoffCoefficient ?? common_1.HMSH_MEMFLOW_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),
+        originJobId: originJobId ?? workflowId,
+        expire: options.expire ?? expire,
+        persistent: options.persistent,
+        signalIn: options.signalIn,
+        parentWorkflowId,
+        workflowDimension: workflowDimension,
+        workflowId: childJobId,
+        workflowTopic,
+    };
+}
+/**
+ * Spawns a child workflow and awaits the result, or if `await` is false, returns immediately.
+ * @template T
+ * @param {WorkflowOptions} options - Workflow options.
+ * @returns {Promise<T>} Result of the child workflow.
+ */
+async function execChild(options) {
+    const isStartChild = options.await === false;
+    const prefix = isStartChild ? 'start' : 'child';
+    const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)(prefix);
+    const context = (0, context_1.getContext)();
+    const { canRetry, interruptionRegistry } = context;
+    if (didRunAlready) {
+        if (result?.$error && (!result.$error.is_stream_error || !canRetry)) {
+            if (options?.config?.throwOnError !== false) {
+                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);
+                }
+                else if (code === common_1.HMSH_CODE_MEMFLOW_MAXED) {
+                    throw new common_1.MemFlowMaxedError(message, stack);
+                }
+                else if (code === common_1.HMSH_CODE_MEMFLOW_TIMEOUT) {
+                    throw new common_1.MemFlowTimeoutError(message, stack);
+                }
+                else {
+                    throw new common_1.MemFlowRetryError(message, stack);
+                }
+            }
+            return result.$error;
+        }
+        else if (!result?.$error) {
+            return result.data;
+        }
+    }
+    const interruptionMessage = getChildInterruptPayload(context, options, execIndex);
+    interruptionRegistry.push({
+        code: common_1.HMSH_CODE_MEMFLOW_CHILD,
+        ...interruptionMessage,
+    });
+    await (0, common_1.sleepImmediate)();
+    throw new common_1.MemFlowChildError(interruptionMessage);
+}
+exports.execChild = execChild;
+/**
+ * Alias for execChild.
+ */
+exports.executeChild = execChild;
+/**
+ * Spawns a child workflow and returns the child Job ID without awaiting its completion.
+ * @param {WorkflowOptions} options - Workflow options.
+ * @returns {Promise<string>} The child job ID.
+ */
+async function startChild(options) {
+    return execChild({ ...options, await: false });
+}
+exports.startChild = startChild;

package/build/services/memflow/workflow/execHook.d.ts

@@ -0,0 +1,65 @@
+import { HookOptions } from './common';
+/**
+ * Extended hook options that include signal configuration
+ */
+export interface ExecHookOptions extends HookOptions {
+    /** Signal ID to send after hook execution */
+    signalId: string;
+}
+/**
+ * Executes a hook function and awaits the signal response.
+ * This is a convenience method that combines `hook()` and `waitFor()` operations.
+ *
+ * **Signal Injection**: The `signalId` is automatically injected as the LAST argument
+ * to the hooked function. The hooked function should check for this signal parameter
+ * and emit the signal when processing is complete.
+ *
+ * This behaves like `execChild` but targets the existing workflow instead of
+ * spawning a new workflow.
+ *
+ * @template T
+ * @param {ExecHookOptions} options - Hook configuration with signal ID.
+ * @returns {Promise<T>} The signal result from the hooked function.
+ *
+ * @example
+ * ```typescript
+ * // Execute a hook and await its signal response
+ * const result = await MemFlow.workflow.execHook({
+ *   taskQueue: 'processing',
+ *   workflowName: 'processData',
+ *   args: ['user123', 'batch-process'],
+ *   signalId: 'processing-complete'
+ * });
+ *
+ * // The hooked function receives the signal as the last argument:
+ * export async function processData(userId: string, processType: string, signalInfo?: { signal: string }) {
+ *   // ... do processing work ...
+ *   const result = { userId, processType, status: 'completed' };
+ *
+ *   // Check if called via execHook (signalInfo will be present)
+ *   if (signalInfo?.signal) {
+ *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Alternative pattern - check if last arg is signal object
+ * export async function myHookFunction(arg1: string, arg2: number, ...rest: any[]) {
+ *   // ... process arg1 and arg2 ...
+ *   const result = { processed: true, data: [arg1, arg2] };
+ *
+ *   // Check if last argument is a signal object
+ *   const lastArg = rest[rest.length - 1];
+ *   if (lastArg && typeof lastArg === 'object' && lastArg.signal) {
+ *     await MemFlow.workflow.signal(lastArg.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ */
+export declare function execHook<T>(options: ExecHookOptions): Promise<T>;

package/build/services/memflow/workflow/execHook.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHook = void 0;
+const hook_1 = require("./hook");
+const waitFor_1 = require("./waitFor");
+/**
+ * Executes a hook function and awaits the signal response.
+ * This is a convenience method that combines `hook()` and `waitFor()` operations.
+ *
+ * **Signal Injection**: The `signalId` is automatically injected as the LAST argument
+ * to the hooked function. The hooked function should check for this signal parameter
+ * and emit the signal when processing is complete.
+ *
+ * This behaves like `execChild` but targets the existing workflow instead of
+ * spawning a new workflow.
+ *
+ * @template T
+ * @param {ExecHookOptions} options - Hook configuration with signal ID.
+ * @returns {Promise<T>} The signal result from the hooked function.
+ *
+ * @example
+ * ```typescript
+ * // Execute a hook and await its signal response
+ * const result = await MemFlow.workflow.execHook({
+ *   taskQueue: 'processing',
+ *   workflowName: 'processData',
+ *   args: ['user123', 'batch-process'],
+ *   signalId: 'processing-complete'
+ * });
+ *
+ * // The hooked function receives the signal as the last argument:
+ * export async function processData(userId: string, processType: string, signalInfo?: { signal: string }) {
+ *   // ... do processing work ...
+ *   const result = { userId, processType, status: 'completed' };
+ *
+ *   // Check if called via execHook (signalInfo will be present)
+ *   if (signalInfo?.signal) {
+ *     await MemFlow.workflow.signal(signalInfo.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Alternative pattern - check if last arg is signal object
+ * export async function myHookFunction(arg1: string, arg2: number, ...rest: any[]) {
+ *   // ... process arg1 and arg2 ...
+ *   const result = { processed: true, data: [arg1, arg2] };
+ *
+ *   // Check if last argument is a signal object
+ *   const lastArg = rest[rest.length - 1];
+ *   if (lastArg && typeof lastArg === 'object' && lastArg.signal) {
+ *     await MemFlow.workflow.signal(lastArg.signal, result);
+ *   }
+ *
+ *   return result;
+ * }
+ * ```
+ */
+async function execHook(options) {
+    // Create hook options with signal field added to args
+    const hookOptions = {
+        ...options,
+        args: [...options.args, { signal: options.signalId }]
+    };
+    // Execute the hook with the signal information
+    await (0, hook_1.hook)(hookOptions);
+    // Wait for the signal response and return it
+    return await (0, waitFor_1.waitFor)(options.signalId);
+}
+exports.execHook = execHook;

package/build/services/memflow/workflow/hook.d.ts

@@ -0,0 +1,9 @@
+import { HookOptions } from './common';
+/**
+ * Spawns a hook from the main thread or a hook thread.
+ * If entity/workflowName are not provided, defaults to the current workflow.
+ *
+ * @param {HookOptions} options - Hook configuration options.
+ * @returns {Promise<string>} The resulting hook/stream ID.
+ */
+export declare function hook(options: HookOptions): Promise<string>;

package/build/services/memflow/workflow/hook.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hook = void 0;
+const common_1 = require("./common");
+const context_1 = require("./context");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+/**
+ * Spawns a hook from the main thread or a hook thread.
+ * If entity/workflowName are not provided, defaults to the current workflow.
+ *
+ * @param {HookOptions} options - Hook configuration options.
+ * @returns {Promise<string>} The resulting hook/stream ID.
+ */
+async function hook(options) {
+    const { workflowId, connection, namespace, workflowTopic } = (0, context_1.getContext)();
+    const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
+        connection,
+        namespace,
+    });
+    if (await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'hook')) {
+        const targetWorkflowId = options.workflowId ?? workflowId;
+        let targetTopic;
+        if (options.entity || (options.taskQueue && options.workflowName)) {
+            targetTopic = `${options.taskQueue ?? options.entity}-${options.entity ?? options.workflowName}`;
+        }
+        else {
+            targetTopic = workflowTopic;
+        }
+        // DEFENSIVE CHECK: Prevent infinite loops
+        if (targetTopic === workflowTopic && !options.entity && !options.taskQueue) {
+            throw new Error(`MemFlow 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` +
+                `Current workflow topic: ${workflowTopic}\n` +
+                `Target topic would be: ${targetTopic}\n` +
+                `Provided options: ${JSON.stringify({
+                    workflowName: options.workflowName,
+                    taskQueue: options.taskQueue,
+                    entity: options.entity
+                }, null, 2)}`);
+        }
+        const payload = {
+            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),
+        };
+        return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, common_1.StreamStatus.PENDING, 202);
+    }
+}
+exports.hook = hook;

package/build/services/memflow/workflow/index.d.ts

@@ -0,0 +1,74 @@
+import { getContext } from './context';
+import { didRun } from './didRun';
+import { isSideEffectAllowed } from './isSideEffectAllowed';
+import { trace } from './trace';
+import { enrich } from './enrich';
+import { emit } from './emit';
+import { execChild, startChild } from './execChild';
+import { execHook } from './execHook';
+import { proxyActivities } from './proxyActivities';
+import { search } from './searchMethods';
+import { random } from './random';
+import { signal } from './signal';
+import { hook } from './hook';
+import { interrupt } from './interrupt';
+import { all } from './all';
+import { sleepFor } from './sleepFor';
+import { waitFor } from './waitFor';
+import { HotMesh } from './common';
+import { context } from './contextMethods';
+/**
+ * The WorkflowService class provides a set of static methods to be used within a workflow function.
+ * These methods ensure deterministic replay, persistence of state, and error handling across
+ * re-entrant workflow executions.
+ *
+ * By refactoring the original single-file implementation into submodules,
+ * we maintain clear separation of concerns and improved maintainability,
+ * while preserving type information and full functionality.
+ *
+ * @example
+ * ```typescript
+ * import { MemFlow } from '@hotmeshio/hotmesh';
+ *
+ * export async function waitForExample(): Promise<[boolean, number]> {
+ *   const [s1, s2] = await Promise.all([
+ *     MemFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
+ *     MemFlow.workflow.waitFor<number>('my-sig-nal-2')
+ *   ]);
+ *   return [s1, s2];
+ * }
+ * ```
+ */
+export declare class WorkflowService {
+    /**
+     * @private
+     * The constructor is private to prevent instantiation;
+     * all methods are static.
+     */
+    private constructor();
+    static getContext: typeof getContext;
+    static didRun: typeof didRun;
+    static isSideEffectAllowed: typeof isSideEffectAllowed;
+    static trace: typeof trace;
+    static enrich: typeof enrich;
+    static emit: typeof emit;
+    static execChild: typeof execChild;
+    static executeChild: typeof execChild;
+    static startChild: typeof startChild;
+    static execHook: typeof execHook;
+    static proxyActivities: typeof proxyActivities;
+    static search: typeof search;
+    static context: typeof context;
+    static random: typeof random;
+    static signal: typeof signal;
+    static hook: typeof hook;
+    static interrupt: typeof interrupt;
+    static all: typeof all;
+    static sleepFor: typeof sleepFor;
+    static waitFor: typeof waitFor;
+    /**
+     * Return a handle to the HotMesh client hosting the workflow execution.
+     * @returns {Promise<HotMesh>} The HotMesh client instance.
+     */
+    static getHotMesh(): Promise<HotMesh>;
+}

package/build/services/memflow/workflow/index.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const context_1 = require("./context");
+const didRun_1 = require("./didRun");
+const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
+const trace_1 = require("./trace");
+const enrich_1 = require("./enrich");
+const emit_1 = require("./emit");
+const execChild_1 = require("./execChild");
+const execHook_1 = require("./execHook");
+const proxyActivities_1 = require("./proxyActivities");
+const searchMethods_1 = require("./searchMethods");
+const random_1 = require("./random");
+const signal_1 = require("./signal");
+const hook_1 = require("./hook");
+const interrupt_1 = require("./interrupt");
+const all_1 = require("./all");
+const sleepFor_1 = require("./sleepFor");
+const waitFor_1 = require("./waitFor");
+const common_1 = require("./common");
+const contextMethods_1 = require("./contextMethods");
+/**
+ * The WorkflowService class provides a set of static methods to be used within a workflow function.
+ * These methods ensure deterministic replay, persistence of state, and error handling across
+ * re-entrant workflow executions.
+ *
+ * By refactoring the original single-file implementation into submodules,
+ * we maintain clear separation of concerns and improved maintainability,
+ * while preserving type information and full functionality.
+ *
+ * @example
+ * ```typescript
+ * import { MemFlow } from '@hotmeshio/hotmesh';
+ *
+ * export async function waitForExample(): Promise<[boolean, number]> {
+ *   const [s1, s2] = await Promise.all([
+ *     MemFlow.workflow.waitFor<boolean>('my-sig-nal-1'),
+ *     MemFlow.workflow.waitFor<number>('my-sig-nal-2')
+ *   ]);
+ *   return [s1, s2];
+ * }
+ * ```
+ */
+class WorkflowService {
+    /**
+     * @private
+     * The constructor is private to prevent instantiation;
+     * all methods are static.
+     */
+    constructor() { }
+    /**
+     * Return a handle to the HotMesh client hosting the workflow execution.
+     * @returns {Promise<HotMesh>} The HotMesh client instance.
+     */
+    static async getHotMesh() {
+        const store = common_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
+        const connection = store.get('connection');
+        const namespace = store.get('namespace');
+        return await common_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
+            namespace,
+        });
+    }
+}
+WorkflowService.getContext = context_1.getContext;
+WorkflowService.didRun = didRun_1.didRun;
+WorkflowService.isSideEffectAllowed = isSideEffectAllowed_1.isSideEffectAllowed;
+WorkflowService.trace = trace_1.trace;
+WorkflowService.enrich = enrich_1.enrich;
+WorkflowService.emit = emit_1.emit;
+WorkflowService.execChild = execChild_1.execChild;
+WorkflowService.executeChild = execChild_1.executeChild;
+WorkflowService.startChild = execChild_1.startChild;
+WorkflowService.execHook = execHook_1.execHook;
+WorkflowService.proxyActivities = proxyActivities_1.proxyActivities;
+WorkflowService.search = searchMethods_1.search;
+WorkflowService.context = contextMethods_1.context;
+WorkflowService.random = random_1.random;
+WorkflowService.signal = signal_1.signal;
+WorkflowService.hook = hook_1.hook;
+WorkflowService.interrupt = interrupt_1.interrupt;
+WorkflowService.all = all_1.all;
+WorkflowService.sleepFor = sleepFor_1.sleepFor;
+WorkflowService.waitFor = waitFor_1.waitFor;
+exports.WorkflowService = WorkflowService;

package/build/services/memflow/workflow/interrupt.d.ts

@@ -0,0 +1,9 @@
+import { JobInterruptOptions } from './common';
+/**
+ * Interrupts a running job by sending an interruption request.
+ *
+ * @param {string} jobId - The ID of the job to interrupt.
+ * @param {JobInterruptOptions} options - Additional interruption options.
+ * @returns {Promise<string|void>} Result of the interruption, if any.
+ */
+export declare function interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;