@hotmeshio/hotmesh 0.8.0 → 0.10.0

package/build/services/{memflow → durable}/client.js

@@ -11,7 +11,7 @@ const search_1 = require("./search");
 const handle_1 = require("./handle");
 const factory_1 = require("./schemas/factory");
 /**
- * The MemFlow `Client` service is functionally
+ * The Durable `Client` service is functionally
  * equivalent to the Temporal `Client` service.
  * Start a new workflow execution by calling
  * `workflow.start`. Note the direct connection to
@@ -83,7 +83,7 @@ class ClientService {
             //resolve, activate, and return the client
             const resolvedClient = await hotMeshClient;
             if (!readonly) {
-                resolvedClient.engine.logger.info('memflow-readonly-client', {
+                resolvedClient.engine.logger.info('durable-readonly-client', {
                     guid: resolvedClient.engine.guid,
                     appId: targetNS,
                 });
@@ -114,7 +114,7 @@ class ClientService {
             return await searchClient.sendIndexedQuery(index, query);
         };
         /**
-         * The MemFlow `Client` service is functionally
+         * The Durable `Client` service is functionally
          * equivalent to the Temporal `Client` service.
          * Starting a workflow is the primary use case and
          * is accessed by calling workflow.start().
@@ -145,9 +145,9 @@ class ClientService {
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMesh.guid(),
                     workflowTopic: workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MEMFLOW_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
-                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MEMFLOW_MAX_INTERVAL),
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL),
                 };
                 const context = { metadata: { trc, spn }, data: {} };
                 const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context, {
@@ -163,7 +163,7 @@ class ClientService {
              */
             signal: async (signalId, data, namespace) => {
                 const topic = `${namespace ?? factory_1.APP_ID}.wfs.signal`;
-                return await (await this.getHotMeshClient(topic, namespace)).hook(topic, { id: signalId, data });
+                return await (await this.getHotMeshClient(topic, namespace)).signal(topic, { id: signalId, data });
             },
             /**
              * Spawns an a new, isolated execution cycle within the same job.
@@ -191,13 +191,13 @@ class ClientService {
                     arguments: [...options.args],
                     id: options.workflowId,
                     workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_MEMFLOW_EXP_BACKOFF,
-                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MEMFLOW_MAX_ATTEMPTS,
-                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MEMFLOW_MAX_INTERVAL),
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+                    maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL),
                 };
                 //seed search data before entering
                 const hotMeshClient = await this.getHotMeshClient(taskQueue, options.namespace);
-                const msgId = await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
+                const msgId = await hotMeshClient.signal(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
                 //todo: commit search data BEFORE enqueuing hook
                 if (options.search?.data) {
                     const searchSessionId = `-search-${hotmesh_1.HotMesh.guid()}-0`;
@@ -237,7 +237,7 @@ class ClientService {
              * await client.workflow.search(
              *   'someTaskQueue'
              *   'someWorkflowName',
-             *   'memflow',
+             *   'durable',
              *   'user',
              *   ...args,
              * );
@@ -251,7 +251,7 @@ class ClientService {
                     return await this.search(hotMeshClient, index, query);
                 }
                 catch (error) {
-                    hotMeshClient.engine.logger.error('memflow-client-search-err', {
+                    hotMeshClient.engine.logger.error('durable-client-search-err', {
                         error,
                     });
                     throw error;
@@ -314,7 +314,7 @@ class ClientService {
                 await hotMesh.activate(version);
             }
             catch (error) {
-                hotMesh.engine.logger.error('memflow-client-activate-err', {
+                hotMesh.engine.logger.error('durable-client-activate-err', {
                     error,
                 });
                 throw error;
@@ -326,7 +326,7 @@ class ClientService {
                 await hotMesh.activate(version);
             }
             catch (error) {
-                hotMesh.engine.logger.error('memflow-client-deploy-activate-err', {
+                hotMesh.engine.logger.error('durable-client-deploy-activate-err', {
                     error,
                 });
                 throw error;

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

@@ -1,10 +1,10 @@
-import { Connection } from '../../types/memflow';
+import { Connection } from '../../types/durable';
 import { ProviderConfig, ProvidersConfig } from '../../types/provider';
 /**
  * The Connection service is used to declare the class
  * and connection options but does not connect quite yet. Connection
  * happens at a later lifecycle stage when a workflow
- * is started by the MemFlow Client module (`(new MemFlow.Client())).start()`).
+ * is started by the Durable Client module (`(new Durable.Client())).start()`).
  *
  * The config options optionall support a multi-connection setup
  * where the `store` connection explicitly defined along with `stream`, `sub`, etc.

package/build/services/{memflow → durable}/connection.js

@@ -5,7 +5,7 @@ exports.ConnectionService = void 0;
  * The Connection service is used to declare the class
  * and connection options but does not connect quite yet. Connection
  * happens at a later lifecycle stage when a workflow
- * is started by the MemFlow Client module (`(new MemFlow.Client())).start()`).
+ * is started by the Durable Client module (`(new Durable.Client())).start()`).
  *
  * The config options optionall support a multi-connection setup
  * where the `store` connection explicitly defined along with `stream`, `sub`, etc.

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

@@ -1,6 +1,6 @@
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { ExportOptions, MemFlowJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
+import { ExportOptions, DurableJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
 import { ProviderClient, ProviderTransaction } from '../../types/provider';
 import { StringStringType, Symbols } from '../../types/serializer';
 declare class ExporterService {
@@ -11,17 +11,17 @@ declare class ExporterService {
     private static symbols;
     constructor(appId: string, store: StoreService<ProviderClient, ProviderTransaction>, logger: ILogger);
     /**
-     * Convert the job hash from its compiles format into a MemFlowJobExport object with
+     * Convert the job hash from its compiles format into a DurableJobExport object with
      * facets that describe the workflow in terms relevant to narrative storytelling.
      */
-    export(jobId: string, options?: ExportOptions): Promise<MemFlowJobExport>;
+    export(jobId: string, options?: ExportOptions): Promise<DurableJobExport>;
     /**
-     * Inflates the job data into a MemFlowJobExport object
+     * Inflates the job data into a DurableJobExport object
      * @param jobHash - the job data
      * @param dependencyList - the list of dependencies for the job
      * @returns - the inflated job data
      */
-    inflate(jobHash: StringStringType, options: ExportOptions): MemFlowJobExport;
+    inflate(jobHash: StringStringType, options: ExportOptions): DurableJobExport;
     resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null;
     /**
      * Inflates the key
@@ -30,7 +30,7 @@ declare class ExporterService {
      * @private
      */
     inflateKey(key: string): string;
-    filterFields(fullObject: MemFlowJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<MemFlowJobExport>;
+    filterFields(fullObject: DurableJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<DurableJobExport>;
     inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>): void;
     sortEntriesByCreated(obj: {
         [key: string]: TransitionType;

package/build/services/{memflow → durable}/exporter.js

@@ -10,7 +10,7 @@ class ExporterService {
         this.store = store;
     }
     /**
-     * Convert the job hash from its compiles format into a MemFlowJobExport object with
+     * Convert the job hash from its compiles format into a DurableJobExport object with
      * facets that describe the workflow in terms relevant to narrative storytelling.
      */
     async export(jobId, options = {}) {
@@ -23,7 +23,7 @@ class ExporterService {
         return jobExport;
     }
     /**
-     * Inflates the job data into a MemFlowJobExport object
+     * Inflates the job data into a DurableJobExport object
      * @param jobHash - the job data
      * @param dependencyList - the list of dependencies for the job
      * @returns - the inflated job data

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

@@ -1,5 +1,5 @@
 import { HotMesh } from '../hotmesh';
-import { MemFlowJobExport, ExportOptions } from '../../types/exporter';
+import { DurableJobExport, ExportOptions } from '../../types/exporter';
 import { JobInterruptOptions } from '../../types/job';
 import { StreamError } from '../../types/stream';
 import { ExporterService } from './exporter';
@@ -7,7 +7,7 @@ import { ExporterService } from './exporter';
  * The WorkflowHandleService provides methods to interact with a running
  * workflow. This includes exporting the workflow, sending signals, and
  * querying the state of the workflow. It is instanced/accessed via the
- * MemFlow.Client class.
+ * Durable.Client class.
  *
  * @example
  * ```typescript
@@ -43,11 +43,11 @@ export declare class WorkflowHandleService {
     /**
      * Exports the workflow state to a JSON object.
      */
-    export(options?: ExportOptions): Promise<MemFlowJobExport>;
+    export(options?: ExportOptions): Promise<DurableJobExport>;
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having
-     * executed `MemFlow.workflow.waitFor`. The workflow
+     * executed `Durable.workflow.waitFor`. The workflow
      * will awaken if no other signals are pending.
      */
     signal(signalId: string, data: Record<any, any>): Promise<void>;

package/build/services/{memflow → durable}/handle.js

@@ -6,7 +6,7 @@ const exporter_1 = require("./exporter");
  * The WorkflowHandleService provides methods to interact with a running
  * workflow. This includes exporting the workflow, sending signals, and
  * querying the state of the workflow. It is instanced/accessed via the
- * MemFlow.Client class.
+ * Durable.Client class.
  *
  * @example
  * ```typescript
@@ -46,11 +46,11 @@ class WorkflowHandleService {
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having
-     * executed `MemFlow.workflow.waitFor`. The workflow
+     * executed `Durable.workflow.waitFor`. The workflow
      * will awaken if no other signals are pending.
      */
     async signal(signalId, data) {
-        await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, {
+        await this.hotMesh.signal(`${this.hotMesh.appId}.wfs.signal`, {
             id: signalId,
             data,
         });

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

@@ -1,4 +1,4 @@
-import { ContextType, WorkflowInterceptor } from '../../types/memflow';
+import { ContextType, WorkflowInterceptor, ActivityInterceptor } from '../../types/durable';
 import { guid } from '../../modules/utils';
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
@@ -9,9 +9,9 @@ import { WorkflowService } from './workflow';
 import { WorkflowHandleService } from './handle';
 import { didInterrupt } from './workflow/interruption';
 /**
- * The MemFlow service provides a Temporal-compatible workflow framework backed by
- * Postgres. It offers durable execution, entity-based memory management,
- * and composable workflows.
+ * The Durable service provides a Temporal-compatible workflow framework backed
+ * by Postgres. It offers entity-based memory management and composable,
+ * fault-tolerant workflows.
  *
  * ## Core Features
  *
@@ -19,7 +19,7 @@ import { didInterrupt } from './workflow/interruption';
  * Each workflow has a durable JSONB entity that serves as its memory:
  * ```typescript
  * export async function researchAgent(query: string) {
- *   const agent = await MemFlow.workflow.entity();
+ *   const agent = await Durable.workflow.entity();
  *
  *   // Initialize entity state
  *   await agent.set({
@@ -38,14 +38,14 @@ import { didInterrupt } from './workflow/interruption';
  * Spawn and coordinate multiple perspectives/phases:
  * ```typescript
  * // Launch parallel research perspectives
- * await MemFlow.workflow.execHook({
+ * await Durable.workflow.execHook({
  *   taskQueue: 'research',
  *   workflowName: 'optimisticView',
  *   args: [query],
  *   signalId: 'optimistic-complete'
  * });
  *
- * await MemFlow.workflow.execHook({
+ * await Durable.workflow.execHook({
  *   taskQueue: 'research',
  *   workflowName: 'skepticalView',
  *   args: [query],
@@ -54,8 +54,8 @@ import { didInterrupt } from './workflow/interruption';
  *
  * // Wait for both perspectives
  * await Promise.all([
- *   MemFlow.workflow.waitFor('optimistic-complete'),
- *   MemFlow.workflow.waitFor('skeptical-complete')
+ *   Durable.workflow.waitFor('optimistic-complete'),
+ *   Durable.workflow.waitFor('skeptical-complete')
  * ]);
  * ```
  *
@@ -63,7 +63,7 @@ import { didInterrupt } from './workflow/interruption';
  * Define and execute durable activities with automatic retry:
  * ```typescript
  * // Default: activities use workflow's task queue
- * const activities = MemFlow.workflow.proxyActivities<{
+ * const activities = Durable.workflow.proxyActivities<{
  *   analyzeDocument: typeof analyzeDocument;
  *   validateFindings: typeof validateFindings;
  * }>({
@@ -83,7 +83,7 @@ import { didInterrupt } from './workflow/interruption';
  * Register activity workers explicitly before workflows start:
  * ```typescript
  * // Register shared activity pool for interceptors
- * await MemFlow.registerActivityWorker({
+ * await Durable.registerActivityWorker({
  *   connection: {
  *     class: Postgres,
  *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -92,7 +92,7 @@ import { didInterrupt } from './workflow/interruption';
  * }, sharedActivities, 'shared-activities');
  *
  * // Register custom activity pool for specific use cases
- * await MemFlow.registerActivityWorker({
+ * await Durable.registerActivityWorker({
  *   connection: {
  *     class: Postgres,
  *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -105,7 +105,7 @@ import { didInterrupt } from './workflow/interruption';
  * Build complex workflows through composition:
  * ```typescript
  * // Start a child workflow
- * const childResult = await MemFlow.workflow.execChild({
+ * const childResult = await Durable.workflow.execChild({
  *   taskQueue: 'analysis',
  *   workflowName: 'detailedAnalysis',
  *   args: [data],
@@ -117,7 +117,7 @@ import { didInterrupt } from './workflow/interruption';
  * });
  *
  * // Fire-and-forget child workflow
- * await MemFlow.workflow.startChild({
+ * await Durable.workflow.startChild({
  *   taskQueue: 'notifications',
  *   workflowName: 'sendUpdates',
  *   args: [updates]
@@ -128,7 +128,7 @@ import { didInterrupt } from './workflow/interruption';
  * Add cross-cutting concerns through interceptors that run as durable functions:
  * ```typescript
  * // First register shared activity worker for interceptors
- * await MemFlow.registerActivityWorker({
+ * await Durable.registerActivityWorker({
  *   connection: {
  *     class: Postgres,
  *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -137,11 +137,11 @@ import { didInterrupt } from './workflow/interruption';
  * }, { auditLog }, 'interceptor-activities');
  *
  * // Add audit interceptor that uses activities with explicit taskQueue
- * MemFlow.registerInterceptor({
+ * Durable.registerInterceptor({
  *   async execute(ctx, next) {
  *     try {
  *       // Interceptors use explicit taskQueue to prevent per-workflow queues
- *       const { auditLog } = MemFlow.workflow.proxyActivities<typeof activities>({
+ *       const { auditLog } = Durable.workflow.proxyActivities<typeof activities>({
  *         activities: { auditLog },
  *         taskQueue: 'interceptor-activities', // Explicit shared queue
  *         retryPolicy: { maximumAttempts: 3 }
@@ -156,7 +156,7 @@ import { didInterrupt } from './workflow/interruption';
  *       return result;
  *     } catch (err) {
  *       // CRITICAL: Always check for HotMesh interruptions
- *       if (MemFlow.didInterrupt(err)) {
+ *       if (Durable.didInterrupt(err)) {
  *         throw err; // Rethrow for replay system
  *       }
  *       throw err;
@@ -165,15 +165,71 @@ import { didInterrupt } from './workflow/interruption';
  * });
  * ```
  *
+ * ### 7. Activity Interceptors
+ * Wrap individual proxied activity calls with cross-cutting logic.
+ * Unlike workflow interceptors (which wrap the entire workflow), activity
+ * interceptors execute around each `proxyActivities` call. They run inside
+ * the workflow's execution context and have access to all Durable workflow
+ * methods (`proxyActivities`, `sleepFor`, `waitFor`, `execChild`, etc.).
+ * Multiple activity interceptors execute in onion order (first registered
+ * is outermost).
+ * ```typescript
+ * // Simple logging interceptor
+ * Durable.registerActivityInterceptor({
+ *   async execute(activityCtx, workflowCtx, next) {
+ *     console.log(`Activity ${activityCtx.activityName} starting`);
+ *     try {
+ *       const result = await next();
+ *       console.log(`Activity ${activityCtx.activityName} completed`);
+ *       return result;
+ *     } catch (err) {
+ *       if (Durable.didInterrupt(err)) throw err;
+ *       console.error(`Activity ${activityCtx.activityName} failed`);
+ *       throw err;
+ *     }
+ *   }
+ * });
+ *
+ * // Interceptor that calls its own proxy activities
+ * await Durable.registerActivityWorker({
+ *   connection: {
+ *     class: Postgres,
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
+ *   taskQueue: 'audit-activities'
+ * }, { auditLog }, 'audit-activities');
+ *
+ * Durable.registerActivityInterceptor({
+ *   async execute(activityCtx, workflowCtx, next) {
+ *     try {
+ *       const { auditLog } = Durable.workflow.proxyActivities<{
+ *         auditLog: (id: string, action: string) => Promise<void>;
+ *       }>({
+ *         taskQueue: 'audit-activities',
+ *         retryPolicy: { maximumAttempts: 3 }
+ *       });
+ *
+ *       await auditLog(workflowCtx.get('workflowId'), `before:${activityCtx.activityName}`);
+ *       const result = await next();
+ *       await auditLog(workflowCtx.get('workflowId'), `after:${activityCtx.activityName}`);
+ *       return result;
+ *     } catch (err) {
+ *       if (Durable.didInterrupt(err)) throw err;
+ *       throw err;
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * ## Basic Usage Example
  *
  * ```typescript
- * import { Client, Worker, MemFlow } from '@hotmeshio/hotmesh';
+ * import { Client, Worker, Durable } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
  * import * as activities from './activities';
  *
  * // (Optional) Register shared activity workers for interceptors
- * await MemFlow.registerActivityWorker({
+ * await Durable.registerActivityWorker({
  *   connection: {
  *     class: Postgres,
  *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -204,28 +260,28 @@ import { didInterrupt } from './workflow/interruption';
  *   args: ['input data'],
  *   taskQueue: 'default',
  *   workflowName: 'example',
- *   workflowId: MemFlow.guid()
+ *   workflowId: Durable.guid()
  * });
  *
  * // Get result
  * const result = await handle.result();
  *
  * // Cleanup
- * await MemFlow.shutdown();
+ * await Durable.shutdown();
  * ```
  */
-declare class MemFlowClass {
+declare class DurableClass {
     /**
      * @private
      */
     constructor();
     /**
-     * The MemFlow `Client` service is functionally
+     * The Durable `Client` service is functionally
      * equivalent to the Temporal `Client` service.
      */
     static Client: typeof ClientService;
     /**
-     * The MemFlow `Connection` service is functionally
+     * The Durable `Connection` service is functionally
      * equivalent to the Temporal `Connection` service.
      */
     static Connection: typeof ConnectionService;
@@ -241,11 +297,11 @@ declare class MemFlowClass {
      * The Handle provides methods to interact with a running
      * workflow. This includes exporting the workflow, sending signals, and
      * querying the state of the workflow. An instance of the Handle service
-     * is typically accessed via the MemFlow.Client class (workflow.getHandle).
+     * is typically accessed via the Durable.Client class (workflow.getHandle).
      */
     static Handle: typeof WorkflowHandleService;
     /**
-     * The MemFlow `Worker` service is functionally
+     * The Durable `Worker` service is functionally
      * equivalent to the Temporal `Worker` service.
      */
     static Worker: typeof WorkerService;
@@ -261,7 +317,7 @@ declare class MemFlowClass {
      *   async sendEmail(to: string, msg: string) { /* ... *\/ }
      * };
      *
-     * await MemFlow.registerActivityWorker({
+     * await Durable.registerActivityWorker({
      *   connection: {
      *     class: Postgres,
      *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
@@ -271,7 +327,7 @@ declare class MemFlowClass {
      *
      * // Workflow worker (can be on different server)
      * async function orderWorkflow(amount: number) {
-     *   const { processPayment, sendEmail } = MemFlow.workflow.proxyActivities<{
+     *   const { processPayment, sendEmail } = Durable.workflow.proxyActivities<{
      *     processPayment: (amount: number) => Promise<string>;
      *     sendEmail: (to: string, msg: string) => Promise<void>;
      *   }>({
@@ -284,7 +340,7 @@ declare class MemFlowClass {
      *   return result;
      * }
      *
-     * await MemFlow.Worker.create({
+     * await Durable.Worker.create({
      *   connection: { class: Postgres, options: { connectionString: '...' } },
      *   taskQueue: 'orders',
      *   workflow: orderWorkflow
@@ -293,7 +349,7 @@ declare class MemFlowClass {
      */
     static registerActivityWorker: typeof WorkerService.registerActivityWorker;
     /**
-     * The MemFlow `workflow` service is functionally
+     * The Durable `workflow` service is functionally
      * equivalent to the Temporal `Workflow` service
      * with additional methods for managing workflows,
      * including: `execChild`, `waitFor`, `sleep`, etc
@@ -303,7 +359,7 @@ declare class MemFlowClass {
      * Checks if an error is a HotMesh reserved error type that indicates
      * a workflow interruption rather than a true error condition.
      *
-     * @see {@link utils/interruption.didInterrupt} for detailed documentation
+     * @see {@link didInterrupt} for detailed documentation
      */
     static didInterrupt: typeof didInterrupt;
     private static interceptorService;
@@ -313,9 +369,45 @@ declare class MemFlowClass {
      */
     static registerInterceptor(interceptor: WorkflowInterceptor): void;
     /**
-     * Clear all registered workflow interceptors
+     * Clear all registered interceptors (both workflow and activity)
      */
     static clearInterceptors(): void;
+    /**
+     * Register an activity interceptor that wraps individual proxied
+     * activity calls within workflows. Interceptors execute in registration
+     * order (first registered is outermost) using the onion pattern.
+     *
+     * Activity interceptors run inside the workflow's execution context
+     * and have access to all Durable workflow methods (`proxyActivities`,
+     * `sleepFor`, `waitFor`, `execChild`, etc.). The `activityCtx` parameter
+     * provides `activityName`, `args`, and `options` for the call being
+     * intercepted. The `workflowCtx` map provides workflow metadata
+     * (`workflowId`, `workflowName`, `namespace`, etc.).
+     *
+     * @param interceptor The activity interceptor to register
+     *
+     * @example
+     * ```typescript
+     * Durable.registerActivityInterceptor({
+     *   async execute(activityCtx, workflowCtx, next) {
+     *     const start = Date.now();
+     *     try {
+     *       const result = await next();
+     *       console.log(`${activityCtx.activityName} took ${Date.now() - start}ms`);
+     *       return result;
+     *     } catch (err) {
+     *       if (Durable.didInterrupt(err)) throw err;
+     *       throw err;
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    static registerActivityInterceptor(interceptor: ActivityInterceptor): void;
+    /**
+     * Clear all registered activity interceptors
+     */
+    static clearActivityInterceptors(): void;
     /**
      * Generate a unique identifier for workflow IDs
      */
@@ -326,5 +418,5 @@ declare class MemFlowClass {
      */
     static shutdown(): Promise<void>;
 }
-export { MemFlowClass as MemFlow };
+export { DurableClass as Durable };
 export type { ContextType };