@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/exporter/index.js

@@ -1 +1,126 @@
-'use strict';const L=b;function a(){const S=['inflateDependencyData','other','join','__esModule','appId','5035696PIejKJ','12AgKuWg','getRaw','entries','hook','split','match','../serializer','symbols','51HMkfoB','fromString','flow','8755600xaIfNo','replace','20407370AfMGkx','restoreHierarchy','VALSEP','1973005aLvfid','export','6762QqmdLY','11900358tuTUyh','getAllSymbols','../../modules/key','inflate','SerializerService','store','215844wvKONE','defineProperty','8trPiYV','../../modules/utils','inflateKey','forEach'];a=function(){return S;};return a();}(function(c,d){const K=b,e=c();while(!![]){try{const f=parseInt(K(0x1d1))/0x1*(parseInt(K(0x1db))/0x2)+parseInt(K(0x1bd))/0x3*(-parseInt(K(0x1bf))/0x4)+-parseInt(K(0x1d9))/0x5*(-parseInt(K(0x1c9))/0x6)+parseInt(K(0x1d4))/0x7+-parseInt(K(0x1c8))/0x8+parseInt(K(0x1dc))/0x9+-parseInt(K(0x1d6))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xafed8));function b(c,d){const e=a();return b=function(f,g){f=f-0x1bc;let h=e[f];return h;},b(c,d);}Object[L(0x1be)](exports,L(0x1c6),{'value':!0x0}),exports['ExporterService']=void 0x0;const key_1=require(L(0x1de)),utils_1=require(L(0x1c0)),serializer_1=require(L(0x1cf));class ExporterService{constructor(c,d,f){const M=L;this[M(0x1c7)]=c,this['logger']=f,this[M(0x1bc)]=d;}async[L(0x1da)](c,d={}){const N=L;this[N(0x1d0)]||(this[N(0x1d0)]=this[N(0x1bc)][N(0x1dd)](),this[N(0x1d0)]=await this['symbols']);const f=await this['store'][N(0x1ca)](c);return this[N(0x1df)](f,[]);}[L(0x1c1)](c){const O=L;return c in this[O(0x1d0)]?this[O(0x1d0)][c]:c;}[L(0x1df)](c,d){const P=L,f={},g=this['inflateDependencyData'](d,{'hooks':{},'main':{'cursor':-0x1,'items':[]}}),h=/^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;return Object[P(0x1cb)](c)[P(0x1c2)](([j,k])=>{const Q=P,m=j[Q(0x1ce)](h);if(m){const [p,q,u]=m,v=this[Q(0x1c1)](q),w=''+u[Q(0x1d5)](/,/g,'/'),x=serializer_1[Q(0x1e0)]['fromString'](k);f[w+'/'+v]=x;}else 0x3===j['length']&&(f[this[Q(0x1c1)](j)]=serializer_1[Q(0x1e0)][Q(0x1d2)](k));}),{'dependencies':g,'process':(0x0,utils_1[P(0x1d7)])(f),'status':c[':']};}[L(0x1c3)](c,d){const f=/([0-9,]+)-(\d+)$/,g=/-(\d+)$/;return c['map']((j,k)=>{const R=b,[m,q,v,w,...x]=j['split'](key_1[R(0x1d8)]),z=x['join'](key_1[R(0x1d8)]),A=z[R(0x1ce)](f);let B,C,D='';if(A){const [E,F,G]=A;D=F[R(0x1cd)](',')[R(0x1c5)]('/'),B=D+'['+G+']',C=R(0x1cc);}else{const H=z[R(0x1ce)](g);if(H){const [I,J]=H;B='['+J+']',C=R(0x1d3);}else B='/',C=R(0x1c4);}return{'type':m,'topic':q,'gid':v,'jid':z};});}}exports['ExporterService']=ExporterService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExporterService = void 0;
+const key_1 = require("../../modules/key");
+const utils_1 = require("../../modules/utils");
+const serializer_1 = require("../serializer");
+/**
+ * Downloads job data from Redis (hscan, hmget, hgetall)
+ * Expands process data and includes dependency list
+ */
+class ExporterService {
+    constructor(appId, store, logger) {
+        this.appId = appId;
+        this.logger = logger;
+        this.store = store;
+    }
+    /**
+     * Convert the job hash into a JobExport object.
+     * This object contains various facets that describe the interaction
+     * in terms relevant to narrative storytelling.
+     */
+    async export(jobId, options = {}) {
+        if (!this.symbols) {
+            this.symbols = this.store.getAllSymbols();
+            this.symbols = await this.symbols;
+        }
+        const depData = []; // await this.store.getDependencies(jobId);
+        const jobData = await this.store.getRaw(jobId);
+        const jobExport = this.inflate(jobData, depData);
+        return jobExport;
+    }
+    /**
+     * Inflates the key from Redis, 3-character symbol
+     * into a human-readable JSON path, reflecting the
+     * tree-like structure of the unidimensional Hash
+     */
+    inflateKey(key) {
+        return key in this.symbols ? this.symbols[key] : key;
+    }
+    /**
+     * Inflates the job data from Redis into a JobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
+     */
+    inflate(jobHash, dependencyList) {
+        //the list of actions taken in the workflow and hook functions
+        const actions = {
+            hooks: {},
+            main: {
+                cursor: -1,
+                items: [],
+            },
+        };
+        const process = {};
+        const dependencies = this.inflateDependencyData(dependencyList, actions);
+        const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
+        Object.entries(jobHash).forEach(([key, value]) => {
+            const match = key.match(regex);
+            if (match) {
+                //activity process state
+                const [_, letters, numbers] = match;
+                const path = this.inflateKey(letters);
+                const dimensions = `${numbers.replace(/,/g, '/')}`;
+                const resolved = serializer_1.SerializerService.fromString(value);
+                process[`${dimensions}/${path}`] = resolved;
+            }
+            else if (key.length === 3) {
+                //job state
+                process[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
+            }
+        });
+        return {
+            dependencies,
+            process: (0, utils_1.restoreHierarchy)(process),
+            status: jobHash[':'],
+        };
+    }
+    /**
+     * Inflates the dependency data from Redis into a JobExport object by
+     * organizing the dimensional isolate in sch a way asto interleave
+     * into a story
+     * @param data - the dependency data from Redis
+     * @returns - the organized dependency data
+     */
+    inflateDependencyData(data, actions) {
+        const hookReg = /([0-9,]+)-(\d+)$/;
+        const flowReg = /-(\d+)$/;
+        return data.map((dependency, index) => {
+            const [action, topic, gid, _pd, ...jid] = dependency.split(key_1.VALSEP);
+            const jobId = jid.join(key_1.VALSEP);
+            const match = jobId.match(hookReg);
+            let prefix;
+            let type;
+            let dimensionKey = '';
+            if (match) {
+                //hook-originating dependency
+                const [_, dimension, counter] = match;
+                dimensionKey = dimension.split(',').join('/');
+                prefix = `${dimensionKey}[${counter}]`;
+                type = 'hook';
+            }
+            else {
+                const match = jobId.match(flowReg);
+                if (match) {
+                    //main workflow-originating dependency
+                    const [_, counter] = match;
+                    prefix = `[${counter}]`;
+                    type = 'flow';
+                }
+                else {
+                    //'other' types like signal cleanup
+                    prefix = '/';
+                    type = 'other';
+                }
+            }
+            return {
+                type: action,
+                topic,
+                gid,
+                jid: jobId,
+            };
+        });
+    }
+}
+exports.ExporterService = ExporterService;

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

@@ -10,48 +10,191 @@ import { StringAnyType, StringStringType } from '../../types/serializer';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 /**
- * This example shows the full lifecycle of a HotMesh engine instance,
- * including: initialization, deployment, activation and execution.
+ * HotMesh is a distributed, reentrant process orchestration engine that transforms
+ * Redis, Postgres, or NATS into a resilient service mesh capable of running
+ * fault-tolerant workflows across multiple services and systems.
  *
- * Engine routers are self-managing, but subscribe to the 'quorum' channel
- * to establish consensus as necessary for distributed processing.
- * Completed workflows are always soft-deleted with a configurable
- * retention period.
+ * ## Core Concepts
+ *
+ * **Distributed Quorum Architecture**: HotMesh operates as a distributed quorum
+ * where multiple engine and worker instances coordinate using CQRS principles.
+ * Each member reads from assigned topic queues and writes results to other queues,
+ * creating emergent workflow orchestration without a central controller.
+ *
+ * **Reentrant Process Engine**: Unlike traditional workflow engines, HotMesh
+ * provides built-in retry logic, idempotency, and failure recovery. Your business
+ * logic doesn't need to handle timeouts or retries - the engine manages all of that.
+ *
+ * **Multi-Provider Support**: Supports Redis/ValKey, Postgres, and NATS as backend
+ * providers, allowing you to leverage existing infrastructure investments.
+ *
+ * ## Key Features
+ *
+ * - **Fault Tolerance**: Automatic retry, timeout, and failure recovery
+ * - **Distributed Execution**: No single point of failure
+ * - **Multi-Provider**: Redis, Postgres, NATS backend support
+ * - **YAML-Driven**: Model-driven development with declarative workflow definitions
+ * - **OpenTelemetry**: Built-in observability and tracing
+ * - **Durable State**: Workflow state persists across system restarts
+ * - **Pattern Matching**: Pub/sub with wildcard pattern support
+ * - **Throttling**: Dynamic flow control and backpressure management
+ *
+ * ## Architecture
+ *
+ * HotMesh consists of several specialized modules:
+ * - **HotMesh**: Core orchestration engine (this class)
+ * - **MemFlow**: Temporal.io-compatible workflow framework
+ * - **MeshCall**: Durable function execution (Temporal-like clone)
+ *
+ * ## Lifecycle Overview
+ *
+ * 1. **Initialize**: Create HotMesh instance with provider configuration
+ * 2. **Deploy**: Upload YAML workflow definitions to the backend
+ * 3. **Activate**: Coordinate quorum to enable the workflow version
+ * 4. **Execute**: Publish events to trigger workflow execution
+ * 5. **Monitor**: Track progress via OpenTelemetry and built-in observability
+ *
+ * ## Basic Usage
  *
  * @example
  * ```typescript
- * import { Client as Postgres } from 'pg';
  * import { HotMesh } from '@hotmeshio/hotmesh';
+ * import Redis from 'ioredis';
  *
+ * // Initialize with Redis backend
  * const hotMesh = await HotMesh.init({
- *   appId: 'abc',
+ *   appId: 'my-app',
  *   engine: {
  *     connection: {
- *       class: Postgres,
- *       options: {
- *         connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *       }
+ *       class: Redis,
+ *       options: { host: 'localhost', port: 6379 }
  *     }
  *   }
  * });
  *
+ * // Deploy workflow definition
  * await hotMesh.deploy(`
  * app:
- *   id: abc
+ *   id: my-app
  *   version: '1'
  *   graphs:
- *     - subscribes: abc.test
+ *     - subscribes: order.process
  *       activities:
- *         t1:
- *           type: trigger
+ *         validate:
+ *           type: worker
+ *           topic: order.validate
+ *         approve:
+ *           type: hook
+ *           topic: order.approve
+ *         fulfill:
+ *           type: worker
+ *           topic: order.fulfill
+ *       transitions:
+ *         validate:
+ *           - to: approve
+ *         approve:
+ *           - to: fulfill
  * `);
  *
+ * // Activate the workflow version
  * await hotMesh.activate('1');
  *
- * await hotMesh.pubsub('abc.test');
+ * // Execute workflow (fire-and-forget)
+ * const jobId = await hotMesh.pub('order.process', {
+ *   orderId: '12345',
+ *   amount: 99.99
+ * });
+ *
+ * // Execute workflow and wait for result
+ * const result = await hotMesh.pubsub('order.process', {
+ *   orderId: '12345',
+ *   amount: 99.99
+ * });
+ * ```
+ *
+ * ## Postgres Backend Example
+ *
+ * @example
+ * ```typescript
+ * import { HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
  *
+ * const hotMesh = await HotMesh.init({
+ *   appId: 'my-app',
+ *   engine: {
+ *     connection: {
+ *       class: Postgres,
+ *       options: {
+ *         connectionString: 'postgresql://user:pass@localhost:5432/db'
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * ## Advanced Features
+ *
+ * **Pattern Subscriptions**: Listen to multiple workflow topics
+ * ```typescript
+ * await hotMesh.psub('order.*', (topic, message) => {
+ *   console.log(`Received ${topic}:`, message);
+ * });
+ * ```
+ *
+ * **Throttling**: Control processing rates
+ * ```typescript
+ * // Pause all processing for 5 seconds
+ * await hotMesh.throttle({ throttle: 5000 });
+ *
+ * // Emergency stop (pause indefinitely)
+ * await hotMesh.throttle({ throttle: -1 });
+ * ```
+ *
+ * **Workflow Interruption**: Gracefully stop running workflows
+ * ```typescript
+ * await hotMesh.interrupt('order.process', jobId, {
+ *   reason: 'User cancellation'
+ * });
+ * ```
+ *
+ * **State Inspection**: Query workflow state and progress
+ * ```typescript
+ * const state = await hotMesh.getState('order.process', jobId);
+ * const status = await hotMesh.getStatus(jobId);
+ * ```
+ *
+ * ## Distributed Coordination
+ *
+ * HotMesh automatically handles distributed coordination through its quorum system:
+ *
+ * ```typescript
+ * // Check quorum health
+ * const members = await hotMesh.rollCall();
+ *
+ * // Coordinate version activation across all instances
+ * await hotMesh.activate('2', 1000); // 1 second delay for consensus
+ * ```
+ *
+ * ## Integration with Higher-Level Modules
+ *
+ * For most use cases, consider using the higher-level modules:
+ * - **MemFlow**: For Temporal.io-style workflows with TypeScript functions
+ * - **MeshCall**: For durable function calls and RPC patterns
+ *
+ * ## Cleanup
+ *
+ * Always clean up resources when shutting down:
+ * ```typescript
+ * // Stop this instance
+ * hotMesh.stop();
+ *
+ * // Stop all instances (typically in signal handlers)
  * await HotMesh.stop();
  * ```
+ *
+ * @see {@link https://hotmesh.io/docs} - Complete documentation
+ * @see {@link https://github.com/hotmeshio/samples-typescript} - Examples and tutorials
+ * @see {@link https://zenodo.org/records/12168558} - Academic paper on the architecture
  */
 declare class HotMesh {
     namespace: string;

package/build/services/hotmesh/index.js

@@ -11,48 +11,191 @@ const router_1 = require("../router");
 const worker_1 = require("../worker");
 const enums_1 = require("../../modules/enums");
 /**
- * This example shows the full lifecycle of a HotMesh engine instance,
- * including: initialization, deployment, activation and execution.
+ * HotMesh is a distributed, reentrant process orchestration engine that transforms
+ * Redis, Postgres, or NATS into a resilient service mesh capable of running
+ * fault-tolerant workflows across multiple services and systems.
  *
- * Engine routers are self-managing, but subscribe to the 'quorum' channel
- * to establish consensus as necessary for distributed processing.
- * Completed workflows are always soft-deleted with a configurable
- * retention period.
+ * ## Core Concepts
+ *
+ * **Distributed Quorum Architecture**: HotMesh operates as a distributed quorum
+ * where multiple engine and worker instances coordinate using CQRS principles.
+ * Each member reads from assigned topic queues and writes results to other queues,
+ * creating emergent workflow orchestration without a central controller.
+ *
+ * **Reentrant Process Engine**: Unlike traditional workflow engines, HotMesh
+ * provides built-in retry logic, idempotency, and failure recovery. Your business
+ * logic doesn't need to handle timeouts or retries - the engine manages all of that.
+ *
+ * **Multi-Provider Support**: Supports Redis/ValKey, Postgres, and NATS as backend
+ * providers, allowing you to leverage existing infrastructure investments.
+ *
+ * ## Key Features
+ *
+ * - **Fault Tolerance**: Automatic retry, timeout, and failure recovery
+ * - **Distributed Execution**: No single point of failure
+ * - **Multi-Provider**: Redis, Postgres, NATS backend support
+ * - **YAML-Driven**: Model-driven development with declarative workflow definitions
+ * - **OpenTelemetry**: Built-in observability and tracing
+ * - **Durable State**: Workflow state persists across system restarts
+ * - **Pattern Matching**: Pub/sub with wildcard pattern support
+ * - **Throttling**: Dynamic flow control and backpressure management
+ *
+ * ## Architecture
+ *
+ * HotMesh consists of several specialized modules:
+ * - **HotMesh**: Core orchestration engine (this class)
+ * - **MemFlow**: Temporal.io-compatible workflow framework
+ * - **MeshCall**: Durable function execution (Temporal-like clone)
+ *
+ * ## Lifecycle Overview
+ *
+ * 1. **Initialize**: Create HotMesh instance with provider configuration
+ * 2. **Deploy**: Upload YAML workflow definitions to the backend
+ * 3. **Activate**: Coordinate quorum to enable the workflow version
+ * 4. **Execute**: Publish events to trigger workflow execution
+ * 5. **Monitor**: Track progress via OpenTelemetry and built-in observability
+ *
+ * ## Basic Usage
  *
  * @example
  * ```typescript
- * import { Client as Postgres } from 'pg';
  * import { HotMesh } from '@hotmeshio/hotmesh';
+ * import Redis from 'ioredis';
  *
+ * // Initialize with Redis backend
  * const hotMesh = await HotMesh.init({
- *   appId: 'abc',
+ *   appId: 'my-app',
  *   engine: {
  *     connection: {
- *       class: Postgres,
- *       options: {
- *         connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *       }
+ *       class: Redis,
+ *       options: { host: 'localhost', port: 6379 }
  *     }
  *   }
  * });
  *
+ * // Deploy workflow definition
  * await hotMesh.deploy(`
  * app:
- *   id: abc
+ *   id: my-app
  *   version: '1'
  *   graphs:
- *     - subscribes: abc.test
+ *     - subscribes: order.process
  *       activities:
- *         t1:
- *           type: trigger
+ *         validate:
+ *           type: worker
+ *           topic: order.validate
+ *         approve:
+ *           type: hook
+ *           topic: order.approve
+ *         fulfill:
+ *           type: worker
+ *           topic: order.fulfill
+ *       transitions:
+ *         validate:
+ *           - to: approve
+ *         approve:
+ *           - to: fulfill
  * `);
  *
+ * // Activate the workflow version
  * await hotMesh.activate('1');
  *
- * await hotMesh.pubsub('abc.test');
+ * // Execute workflow (fire-and-forget)
+ * const jobId = await hotMesh.pub('order.process', {
+ *   orderId: '12345',
+ *   amount: 99.99
+ * });
+ *
+ * // Execute workflow and wait for result
+ * const result = await hotMesh.pubsub('order.process', {
+ *   orderId: '12345',
+ *   amount: 99.99
+ * });
+ * ```
+ *
+ * ## Postgres Backend Example
+ *
+ * @example
+ * ```typescript
+ * import { HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
  *
+ * const hotMesh = await HotMesh.init({
+ *   appId: 'my-app',
+ *   engine: {
+ *     connection: {
+ *       class: Postgres,
+ *       options: {
+ *         connectionString: 'postgresql://user:pass@localhost:5432/db'
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * ## Advanced Features
+ *
+ * **Pattern Subscriptions**: Listen to multiple workflow topics
+ * ```typescript
+ * await hotMesh.psub('order.*', (topic, message) => {
+ *   console.log(`Received ${topic}:`, message);
+ * });
+ * ```
+ *
+ * **Throttling**: Control processing rates
+ * ```typescript
+ * // Pause all processing for 5 seconds
+ * await hotMesh.throttle({ throttle: 5000 });
+ *
+ * // Emergency stop (pause indefinitely)
+ * await hotMesh.throttle({ throttle: -1 });
+ * ```
+ *
+ * **Workflow Interruption**: Gracefully stop running workflows
+ * ```typescript
+ * await hotMesh.interrupt('order.process', jobId, {
+ *   reason: 'User cancellation'
+ * });
+ * ```
+ *
+ * **State Inspection**: Query workflow state and progress
+ * ```typescript
+ * const state = await hotMesh.getState('order.process', jobId);
+ * const status = await hotMesh.getStatus(jobId);
+ * ```
+ *
+ * ## Distributed Coordination
+ *
+ * HotMesh automatically handles distributed coordination through its quorum system:
+ *
+ * ```typescript
+ * // Check quorum health
+ * const members = await hotMesh.rollCall();
+ *
+ * // Coordinate version activation across all instances
+ * await hotMesh.activate('2', 1000); // 1 second delay for consensus
+ * ```
+ *
+ * ## Integration with Higher-Level Modules
+ *
+ * For most use cases, consider using the higher-level modules:
+ * - **MemFlow**: For Temporal.io-style workflows with TypeScript functions
+ * - **MeshCall**: For durable function calls and RPC patterns
+ *
+ * ## Cleanup
+ *
+ * Always clean up resources when shutting down:
+ * ```typescript
+ * // Stop this instance
+ * hotMesh.stop();
+ *
+ * // Stop all instances (typically in signal handlers)
  * await HotMesh.stop();
  * ```
+ *
+ * @see {@link https://hotmesh.io/docs} - Complete documentation
+ * @see {@link https://github.com/hotmeshio/samples-typescript} - Examples and tutorials
+ * @see {@link https://zenodo.org/records/12168558} - Academic paper on the architecture
  */
 class HotMesh {
     /**

package/build/services/mapper/index.js

@@ -1 +1,81 @@
-'use strict';const n=b;function b(c,d){const e=a();return b=function(f,g){f=f-0x13b;let h=e[f];return h;},b(c,d);}(function(c,d){const m=b,e=c();while(!![]){try{const f=parseInt(m(0x13f))/0x1+-parseInt(m(0x158))/0x2+-parseInt(m(0x154))/0x3+-parseInt(m(0x157))/0x4+-parseInt(m(0x142))/0x5+-parseInt(m(0x146))/0x6+-parseInt(m(0x156))/0x7*(-parseInt(m(0x153))/0x8);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x89daa));Object[n(0x155)](exports,n(0x14a),{'value':!0x0}),exports[n(0x159)]=void 0x0;function a(){const v=['object','mapRules','code','5033430AzNdxc','evaluate','call','match','__esModule','../pipe','data','rules','boolean','gate','Pipe','includes','traverseRules','3810848nMFZtM','2569122ELrJiH','defineProperty','49lscjxt','3056932jFzfum','354956OvZpIy','MapperService','toString','prototype','@pipe','forEach','resolve','44684KWVcmv','process','pipe','887680gGDIfL'];a=function(){return v;};return a();}const pipe_1=require(n(0x14b));class MapperService{constructor(c,d){const o=n;this[o(0x14d)]=c,this['data']=d;}[n(0x144)](){const p=n;return this[p(0x152)](this['rules']);}['traverseRules'](c){const q=n;if(q(0x143)==typeof c&&q(0x13c)in c)return this[q(0x141)](c['@pipe']);if(q(0x143)==typeof c&&null!==c){const d={};for(const f in c)Object[q(0x13b)]['hasOwnProperty'][q(0x148)](c,f)&&(d[f]=this[q(0x152)](c[f]));return d;}return this[q(0x13e)](c);}['pipe'](c){const r=n;return new pipe_1[(r(0x150))](c,this[r(0x14c)])[r(0x140)]();}[n(0x13e)](c){const s=n;return new pipe_1['Pipe']([[c]],this[s(0x14c)])[s(0x140)]();}static[n(0x147)](c,d,f){const t=n;if(t(0x14e)==typeof c)return c;if(Array['isArray'](c['code'])&&c[t(0x145)][t(0x151)](f||0xc8)||f[t(0x15a)]()===(c['code']||0xc8)[t(0x15a)]()){if(!c[t(0x149)])return!0x0;const g='or'===c[t(0x14f)];let h=!0x0,i=!0x1;return c[t(0x149)][t(0x13d)](({expected:j,actual:k})=>{const u=t;if(g&&!i||!g&&h){const l=pipe_1[u(0x150)]['resolve'](k,d)===j;g&&l?i=!0x0:g||l||(h=!0x1);}}),g?i:h;}return!0x1;}}exports[n(0x159)]=MapperService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperService = void 0;
+const pipe_1 = require("../pipe");
+class MapperService {
+    constructor(rules, data) {
+        this.rules = rules;
+        this.data = data;
+    }
+    mapRules() {
+        return this.traverseRules(this.rules);
+    }
+    traverseRules(rules) {
+        if (typeof rules === 'object' && '@pipe' in rules) {
+            return this.pipe(rules['@pipe']);
+        }
+        if (typeof rules === 'object' && rules !== null) {
+            const mappedRules = {};
+            for (const key in rules) {
+                if (Object.prototype.hasOwnProperty.call(rules, key)) {
+                    mappedRules[key] = this.traverseRules(rules[key]);
+                }
+            }
+            return mappedRules;
+        }
+        else {
+            return this.resolve(rules);
+        }
+    }
+    /**
+     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * @param value
+     * @returns
+     */
+    pipe(value) {
+        const pipe = new pipe_1.Pipe(value, this.data);
+        return pipe.process();
+    }
+    /**
+     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * @param value
+     * @returns
+     */
+    resolve(value) {
+        const pipe = new pipe_1.Pipe([[value]], this.data);
+        return pipe.process();
+    }
+    /**
+     * Evaluates a transition rule against the current job state and incoming Stream message
+     * to determine which (if any) transition should be taken.
+     */
+    static evaluate(transitionRule, context, code) {
+        if (typeof transitionRule === 'boolean') {
+            return transitionRule;
+        }
+        if ((Array.isArray(transitionRule.code) &&
+            transitionRule.code.includes(code || 200)) ||
+            code.toString() === (transitionRule.code || 200).toString()) {
+            if (!transitionRule.match) {
+                return true;
+            }
+            const orGate = transitionRule.gate === 'or';
+            let allAreTrue = true;
+            let someAreTrue = false;
+            transitionRule.match.forEach(({ expected, actual }) => {
+                if ((orGate && !someAreTrue) || (!orGate && allAreTrue)) {
+                    const result = pipe_1.Pipe.resolve(actual, context) === expected;
+                    if (orGate && result) {
+                        someAreTrue = true;
+                    }
+                    else if (!orGate && !result) {
+                        allAreTrue = false;
+                    }
+                }
+            });
+            return orGate ? someAreTrue : allAreTrue;
+        }
+        return false;
+    }
+}
+exports.MapperService = MapperService;

package/build/services/{meshflow → memflow}/client.d.ts

@@ -1,7 +1,7 @@
 import { HotMesh } from '../hotmesh';
-import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/meshflow';
+import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/memflow';
 /**
- * The MeshFlow `Client` service is functionally
+ * The MemFlow `Client` service is functionally
  * equivalent to the Temporal `Client` service.
  * Start a new workflow execution by calling
  * `workflow.start`. Note the direct connection to
@@ -81,7 +81,7 @@ export declare class ClientService {
      */
     search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
     /**
-     * The MeshFlow `Client` service is functionally
+     * The MemFlow `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().