@hotmeshio/hotmesh 0.5.5 → 0.5.6

package/README.md

@@ -4,30 +4,18 @@
 
 ![beta release](https://img.shields.io/badge/release-beta-blue.svg) ![made with typescript](https://img.shields.io/badge/built%20with-typescript-lightblue.svg)
 
-HotMesh removes the repetitive glue of building durable agents, pipelines, and long‑running workflows. Instead of you designing queues, schedulers, cache layers, and ad‑hoc state stores for each agent or pipeline, HotMesh standardizes the pattern:
-
-* **Entity (Core Memory)**: The authoritative JSONB document + its indexable “surface” fields.
-* **Hooks (Durable Units of Work)**: Re‑entrant, idempotent functions that *maintain* the entity over time.
-* **Workflow (Coordinator)**: The thin orchestration entry that seeds state, spawns hooks, and optionally synthesizes results.
-* **Commands (State Mutation API)**: Atomic `set / merge / append / increment / tag / signal` updates with optimistic invariants handled by Postgres transactions.
-
-You focus on *what should change in memory*; HotMesh handles *how it changes safely and durably.*
+HotMesh removes the repetitive glue of building durable agents, pipelines, and long‑running workflows. You focus on *what should change*; HotMesh handles *how it changes safely and durably.*
 
 ---
 
-## Why It’s Easier with HotMesh
+## Why Choose HotMesh
 
-| Problem You Usually Solve Manually                  | HotMesh Built‑In                          | Impact                                         |
-| --------------------------------------------------- | ----------------------------------------- | ---------------------------------------------- |
-| Designing per‑agent persistence and caches          | Unified JSONB entity + typed accessors    | One memory model across agents/pipelines       |
-| Preventing race conditions on shared state          | Transactional hook writes                 | Safe parallel maintenance                      |
-| Coordinating multi-perspective / multi-step work    | Hook spawning + signals                   | Decomposed work without orchestration glue     |
-| Schema evolution / optional fields                  | Flexible JSONB + selective indexes        | Add / adapt state incrementally                |
-| Querying live pipeline / agent status               | SQL over materialized surfaces            | Operational observability using standard tools |
-| Avoiding duplicate side-effects during retry/replay | Deterministic re‑entry + idempotent hooks | Simplifies error handling                      |
-| Per‑tenant isolation                                | Schema (or prefix) scoping                | Clean multi‑tenant boundary                    |
-| Background progression / fan‑out                    | `execHook` + signals                      | Natural concurrency without queue plumbing     |
 
+- **One memory model** across all your agents and pipelines. No more designing custom persistence for each workflow.
+- **Automatic reliability** with transactional safety, replay protection, and crash recovery built-in.
+- **Natural concurrency** through isolated hooks that can run in parallel without coordination overhead.
+- **Operational transparency** using standard SQL to query live pipeline status and agent memory.
+- **Multi-tenant ready** with clean schema isolation and flexible indexing.
 ---
 
 ## Core Abstractions

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.5.5",
+    "version": "0.5.6",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -31,7 +31,8 @@
         "test:memflow:basic": "HMSH_LOGLEVEL=info NODE_ENV=test jest ./tests/memflow/basic/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:collision": "NODE_ENV=test jest ./tests/memflow/collision/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:fatal": "NODE_ENV=test jest ./tests/memflow/fatal/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:goodbye": "NODE_ENV=test jest ./tests/memflow/goodbye/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:goodbye": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/goodbye/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:interceptor": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/interceptor/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:entity": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/entity/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:agent": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/agent/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:hello": "HMSH_TELEMETRY=debug HMSH_LOGLEVEL=debug HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/memflow/helloworld/postgres.test.ts --detectOpenHandles --forceExit --verbose",

package/build/services/activities/trigger.js

@@ -8,8 +8,8 @@ const pipe_1 = require("../pipe");
 const reporter_1 = require("../reporter");
 const serializer_1 = require("../serializer");
 const telemetry_1 = require("../telemetry");
-const activity_1 = require("./activity");
 const mapper_1 = require("../mapper");
+const activity_1 = require("./activity");
 class Trigger extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);

package/build/services/connector/factory.js

@@ -90,7 +90,8 @@ class ConnectorService {
                 //if connecting as a poolClient for subscription, auto connect the client
                 const bAutoConnect = field === 'sub';
                 // Use taskQueue-based connection pooling for PostgreSQL
-                clientInstance = await postgres_1.PostgresConnection.getOrCreateTaskQueueConnection(id, taskQueue, providerClass, options, { connect: bAutoConnect, provider: providerName });
+                clientInstance =
+                    await postgres_1.PostgresConnection.getOrCreateTaskQueueConnection(id, taskQueue, providerClass, options, { connect: bAutoConnect, provider: providerName });
                 break;
             default:
                 throw new Error(`Unknown provider type: ${providerType}`);

package/build/services/connector/providers/postgres.js

@@ -23,13 +23,13 @@ class PostgresConnection extends __1.AbstractConnection {
         const taskQueueDetails = Array.from(this.taskQueueConnections.entries()).map(([key, connection]) => ({
             key,
             connectionId: connection.getConnectionId() || 'unknown',
-            reusedCount: connection.reusedCount || 0
+            reusedCount: connection.reusedCount || 0,
         }));
         return {
             totalPoolClients: this.poolClientInstances.size,
             totalConnections: this.connectionInstances.size,
             taskQueueConnections: this.taskQueueConnections.size,
-            taskQueueDetails
+            taskQueueDetails,
         };
     }
     /**
@@ -41,7 +41,7 @@ class PostgresConnection extends __1.AbstractConnection {
         if (logger) {
             logger.info('postgres-connection-stats', {
                 ...stats,
-                message
+                message,
             });
         }
         else {
@@ -54,8 +54,12 @@ class PostgresConnection extends __1.AbstractConnection {
     static getPoolingEffectiveness() {
         const stats = this.getConnectionStats();
         const totalReuses = stats.taskQueueDetails.reduce((sum, detail) => sum + detail.reusedCount, 0);
-        const averageReusesPerPool = stats.taskQueueConnections > 0 ? totalReuses / stats.taskQueueConnections : 0;
-        const poolingEfficiency = stats.totalConnections > 0 ? (stats.taskQueueConnections / stats.totalConnections) * 100 : 0;
+        const averageReusesPerPool = stats.taskQueueConnections > 0
+            ? totalReuses / stats.taskQueueConnections
+            : 0;
+        const poolingEfficiency = stats.totalConnections > 0
+            ? stats.taskQueueConnections / stats.totalConnections * 100
+            : 0;
         return {
             totalConnections: stats.totalConnections,
             taskQueuePools: stats.taskQueueConnections,
@@ -164,7 +168,8 @@ class PostgresConnection extends __1.AbstractConnection {
         if (this.taskQueueConnections.has(connectionKey)) {
             const existingConnection = this.taskQueueConnections.get(connectionKey);
             // Track reuse count for monitoring
-            existingConnection.reusedCount = (existingConnection.reusedCount || 0) + 1;
+            existingConnection.reusedCount =
+                (existingConnection.reusedCount || 0) + 1;
             this.logger.debug('postgres-connection-reused', {
                 connectionKey,
                 taskQueue,

package/build/services/memflow/client.js

@@ -69,7 +69,7 @@ class ClientService {
             }
             //init, but don't await
             const readonly = this.connection.readonly ?? undefined;
-            let hotMeshClient = hotmesh_1.HotMesh.init({
+            const hotMeshClient = hotmesh_1.HotMesh.init({
                 appId: targetNS,
                 taskQueue,
                 logLevel: enums_1.HMSH_LOGLEVEL,
@@ -126,7 +126,9 @@ class ClientService {
              */
             start: async (options) => {
                 const taskQueueName = options.taskQueue ?? options.entity;
-                const workflowName = options.taskQueue ? options.workflowName : (options.entity ?? options.workflowName);
+                const workflowName = options.taskQueue
+                    ? options.workflowName
+                    : options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
                 //hotmesh `topic` is equivalent to `queue+workflowname` pattern in other systems

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

@@ -1,4 +1,4 @@
-import { ContextType } from '../../types/memflow';
+import { ContextType, WorkflowInterceptor } from '../../types/memflow';
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
 import { Search } from './search';
@@ -8,60 +8,170 @@ import { WorkflowService } from './workflow';
 import { WorkflowHandleService } from './handle';
 import { didInterrupt } from './workflow/interruption';
 /**
- * The MemFlow service is a collection of services that
- * emulate Temporal's capabilities, but instead are
- * backed by Postgres or Redis/ValKey. The following lifecycle example
- * demonstrates how to start a new workflow, subscribe
- * to the result, and shutdown the system.
+ * The MemFlow service provides a Temporal-compatible workflow framework backed by
+ * Postgres or Redis/ValKey. It offers durable execution, entity-based memory management,
+ * and composable workflows.
  *
- * @example
+ * ## Core Features
+ *
+ * ### 1. Entity-Based Memory Model
+ * 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();
+ *
+ *   // Initialize entity state
+ *   await agent.set({
+ *     query,
+ *     findings: [],
+ *     status: 'researching'
+ *   });
+ *
+ *   // Update state atomically
+ *   await agent.merge({ status: 'analyzing' });
+ *   await agent.append('findings', newFinding);
+ * }
+ * ```
+ *
+ * ### 2. Hook Functions & Workflow Coordination
+ * Spawn and coordinate multiple perspectives/phases:
  * ```typescript
- * import { Client, Worker, MemFlow, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres} from 'pg';
- * import * as workflows from './workflows';
+ * // Launch parallel research perspectives
+ * await MemFlow.workflow.execHook({
+ *   taskQueue: 'research',
+ *   workflowName: 'optimisticView',
+ *   args: [query],
+ *   signalId: 'optimistic-complete'
+ * });
+ *
+ * await MemFlow.workflow.execHook({
+ *   taskQueue: 'research',
+ *   workflowName: 'skepticalView',
+ *   args: [query],
+ *   signalId: 'skeptical-complete'
+ * });
  *
- * //1) Initialize the worker
+ * // Wait for both perspectives
+ * await Promise.all([
+ *   MemFlow.workflow.waitFor('optimistic-complete'),
+ *   MemFlow.workflow.waitFor('skeptical-complete')
+ * ]);
+ * ```
+ *
+ * ### 3. Durable Activities & Proxies
+ * Define and execute durable activities with automatic retry:
+ * ```typescript
+ * const activities = MemFlow.workflow.proxyActivities<{
+ *   analyzeDocument: typeof analyzeDocument;
+ *   validateFindings: typeof validateFindings;
+ * }>({
+ *   activities: { analyzeDocument, validateFindings },
+ *   retryPolicy: {
+ *     maximumAttempts: 3,
+ *     backoffCoefficient: 2
+ *   }
+ * });
+ *
+ * // Activities are durable and automatically retried
+ * const analysis = await activities.analyzeDocument(data);
+ * const validation = await activities.validateFindings(analysis);
+ * ```
+ *
+ * ### 4. Workflow Composition
+ * Build complex workflows through composition:
+ * ```typescript
+ * // Start a child workflow
+ * const childResult = await MemFlow.workflow.execChild({
+ *   taskQueue: 'analysis',
+ *   workflowName: 'detailedAnalysis',
+ *   args: [data],
+ *   // Child workflow config
+ *   config: {
+ *     maximumAttempts: 5,
+ *     backoffCoefficient: 2
+ *   }
+ * });
+ *
+ * // Fire-and-forget child workflow
+ * await MemFlow.workflow.startChild({
+ *   taskQueue: 'notifications',
+ *   workflowName: 'sendUpdates',
+ *   args: [updates]
+ * });
+ * ```
+ *
+ * ### 5. Workflow Interceptors
+ * Add cross-cutting concerns through interceptors that run as durable functions:
+ * ```typescript
+ * // Add audit interceptor that uses MemFlow functions
+ * MemFlow.registerInterceptor({
+ *   async execute(ctx, next) {
+ *     try {
+ *       // Interceptors can use MemFlow functions and participate in replay
+ *       const entity = await MemFlow.workflow.entity();
+ *       await entity.append('auditLog', {
+ *         action: 'started',
+ *         timestamp: new Date().toISOString()
+ *       });
+ *
+ *       // Rate limiting with durable sleep
+ *       await MemFlow.workflow.sleepFor('100 milliseconds');
+ *
+ *       const result = await next();
+ *
+ *       await entity.append('auditLog', {
+ *         action: 'completed',
+ *         timestamp: new Date().toISOString()
+ *       });
+ *
+ *       return result;
+ *     } catch (err) {
+ *       // CRITICAL: Always check for HotMesh interruptions
+ *       if (MemFlow.didInterrupt(err)) {
+ *         throw err; // Rethrow for replay system
+ *       }
+ *       throw err;
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * ## Basic Usage Example
+ *
+ * ```typescript
+ * import { Client, Worker, MemFlow } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
+ *
+ * // Initialize worker
  * await Worker.create({
  *   connection: {
  *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
  *   taskQueue: 'default',
- *   namespace: 'memflow',
- *   workflow: workflows.example,
- *   options: {
- *     backoffCoefficient: 2,
- *     maximumAttempts: 1_000,
- *     maximumInterval: '5 seconds'
- *   }
+ *   workflow: workflows.example
  * });
  *
- * //2) initialize the client
+ * // Initialize client
  * const client = new Client({
  *   connection: {
  *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
  *   }
  * });
  *
- * //3) start a new workflow
+ * // Start workflow
  * const handle = await client.workflow.start({
- *   args: ['HotMesh', 'es'],
+ *   args: ['input data'],
  *   taskQueue: 'default',
  *   workflowName: 'example',
- *   workflowId: HotMesh.guid(),
- *   namespace: 'memflow',
+ *   workflowId: MemFlow.guid()
  * });
  *
- * //4) subscribe to the eventual result
- * console.log('\nRESPONSE', await handle.result(), '\n');
- * //logs '¡Hola, HotMesh!'
+ * // Get result
+ * const result = await handle.result();
  *
- * //5) Shutdown (typically on sigint)
+ * // Cleanup
  * await MemFlow.shutdown();
  * ```
  */
@@ -114,6 +224,16 @@ declare class MemFlowClass {
      * @see {@link utils/interruption.didInterrupt} for detailed documentation
      */
     static didInterrupt: typeof didInterrupt;
+    private static interceptorService;
+    /**
+     * Register a workflow interceptor
+     * @param interceptor The interceptor to register
+     */
+    static registerInterceptor(interceptor: WorkflowInterceptor): void;
+    /**
+     * Clear all registered workflow interceptors
+     */
+    static clearInterceptors(): void;
     /**
      * Shutdown everything. All connections, workers, and clients will be closed.
      * Include in your signal handlers to ensure a clean shutdown.

package/build/services/memflow/index.js

@@ -10,61 +10,172 @@ const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
 const handle_1 = require("./handle");
 const interruption_1 = require("./workflow/interruption");
+const interceptor_1 = require("./interceptor");
 /**
- * The MemFlow service is a collection of services that
- * emulate Temporal's capabilities, but instead are
- * backed by Postgres or Redis/ValKey. The following lifecycle example
- * demonstrates how to start a new workflow, subscribe
- * to the result, and shutdown the system.
+ * The MemFlow service provides a Temporal-compatible workflow framework backed by
+ * Postgres or Redis/ValKey. It offers durable execution, entity-based memory management,
+ * and composable workflows.
  *
- * @example
+ * ## Core Features
+ *
+ * ### 1. Entity-Based Memory Model
+ * 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();
+ *
+ *   // Initialize entity state
+ *   await agent.set({
+ *     query,
+ *     findings: [],
+ *     status: 'researching'
+ *   });
+ *
+ *   // Update state atomically
+ *   await agent.merge({ status: 'analyzing' });
+ *   await agent.append('findings', newFinding);
+ * }
+ * ```
+ *
+ * ### 2. Hook Functions & Workflow Coordination
+ * Spawn and coordinate multiple perspectives/phases:
+ * ```typescript
+ * // Launch parallel research perspectives
+ * await MemFlow.workflow.execHook({
+ *   taskQueue: 'research',
+ *   workflowName: 'optimisticView',
+ *   args: [query],
+ *   signalId: 'optimistic-complete'
+ * });
+ *
+ * await MemFlow.workflow.execHook({
+ *   taskQueue: 'research',
+ *   workflowName: 'skepticalView',
+ *   args: [query],
+ *   signalId: 'skeptical-complete'
+ * });
+ *
+ * // Wait for both perspectives
+ * await Promise.all([
+ *   MemFlow.workflow.waitFor('optimistic-complete'),
+ *   MemFlow.workflow.waitFor('skeptical-complete')
+ * ]);
+ * ```
+ *
+ * ### 3. Durable Activities & Proxies
+ * Define and execute durable activities with automatic retry:
+ * ```typescript
+ * const activities = MemFlow.workflow.proxyActivities<{
+ *   analyzeDocument: typeof analyzeDocument;
+ *   validateFindings: typeof validateFindings;
+ * }>({
+ *   activities: { analyzeDocument, validateFindings },
+ *   retryPolicy: {
+ *     maximumAttempts: 3,
+ *     backoffCoefficient: 2
+ *   }
+ * });
+ *
+ * // Activities are durable and automatically retried
+ * const analysis = await activities.analyzeDocument(data);
+ * const validation = await activities.validateFindings(analysis);
+ * ```
+ *
+ * ### 4. Workflow Composition
+ * Build complex workflows through composition:
+ * ```typescript
+ * // Start a child workflow
+ * const childResult = await MemFlow.workflow.execChild({
+ *   taskQueue: 'analysis',
+ *   workflowName: 'detailedAnalysis',
+ *   args: [data],
+ *   // Child workflow config
+ *   config: {
+ *     maximumAttempts: 5,
+ *     backoffCoefficient: 2
+ *   }
+ * });
+ *
+ * // Fire-and-forget child workflow
+ * await MemFlow.workflow.startChild({
+ *   taskQueue: 'notifications',
+ *   workflowName: 'sendUpdates',
+ *   args: [updates]
+ * });
+ * ```
+ *
+ * ### 5. Workflow Interceptors
+ * Add cross-cutting concerns through interceptors that run as durable functions:
  * ```typescript
- * import { Client, Worker, MemFlow, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres} from 'pg';
- * import * as workflows from './workflows';
+ * // Add audit interceptor that uses MemFlow functions
+ * MemFlow.registerInterceptor({
+ *   async execute(ctx, next) {
+ *     try {
+ *       // Interceptors can use MemFlow functions and participate in replay
+ *       const entity = await MemFlow.workflow.entity();
+ *       await entity.append('auditLog', {
+ *         action: 'started',
+ *         timestamp: new Date().toISOString()
+ *       });
+ *
+ *       // Rate limiting with durable sleep
+ *       await MemFlow.workflow.sleepFor('100 milliseconds');
+ *
+ *       const result = await next();
+ *
+ *       await entity.append('auditLog', {
+ *         action: 'completed',
+ *         timestamp: new Date().toISOString()
+ *       });
  *
- * //1) Initialize the worker
+ *       return result;
+ *     } catch (err) {
+ *       // CRITICAL: Always check for HotMesh interruptions
+ *       if (MemFlow.didInterrupt(err)) {
+ *         throw err; // Rethrow for replay system
+ *       }
+ *       throw err;
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * ## Basic Usage Example
+ *
+ * ```typescript
+ * import { Client, Worker, MemFlow } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
+ *
+ * // Initialize worker
  * await Worker.create({
  *   connection: {
  *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *   },
  *   taskQueue: 'default',
- *   namespace: 'memflow',
- *   workflow: workflows.example,
- *   options: {
- *     backoffCoefficient: 2,
- *     maximumAttempts: 1_000,
- *     maximumInterval: '5 seconds'
- *   }
+ *   workflow: workflows.example
  * });
  *
- * //2) initialize the client
+ * // Initialize client
  * const client = new Client({
  *   connection: {
  *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
+ *     options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
  *   }
  * });
  *
- * //3) start a new workflow
+ * // Start workflow
  * const handle = await client.workflow.start({
- *   args: ['HotMesh', 'es'],
+ *   args: ['input data'],
  *   taskQueue: 'default',
  *   workflowName: 'example',
- *   workflowId: HotMesh.guid(),
- *   namespace: 'memflow',
+ *   workflowId: MemFlow.guid()
  * });
  *
- * //4) subscribe to the eventual result
- * console.log('\nRESPONSE', await handle.result(), '\n');
- * //logs '¡Hola, HotMesh!'
+ * // Get result
+ * const result = await handle.result();
  *
- * //5) Shutdown (typically on sigint)
+ * // Cleanup
  * await MemFlow.shutdown();
  * ```
  */
@@ -73,6 +184,26 @@ class MemFlowClass {
      * @private
      */
     constructor() { }
+    /**
+     * Register a workflow interceptor
+     * @param interceptor The interceptor to register
+     */
+    static registerInterceptor(interceptor) {
+        MemFlowClass.interceptorService.register(interceptor);
+    }
+    /**
+     * Clear all registered workflow interceptors
+     */
+    static clearInterceptors() {
+        MemFlowClass.interceptorService.clear();
+    }
+    /**
+     * Get the interceptor service instance
+     * @internal
+     */
+    static getInterceptorService() {
+        return MemFlowClass.interceptorService;
+    }
     /**
      * Shutdown everything. All connections, workers, and clients will be closed.
      * Include in your signal handlers to ensure a clean shutdown.
@@ -128,3 +259,4 @@ MemFlowClass.workflow = workflow_1.WorkflowService;
  * @see {@link utils/interruption.didInterrupt} for detailed documentation
  */
 MemFlowClass.didInterrupt = interruption_1.didInterrupt;
+MemFlowClass.interceptorService = new interceptor_1.InterceptorService();