@hotmeshio/hotmesh 0.12.1 → 0.14.0

package/build/services/engine/index.js

@@ -1,35 +1,78 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+/**
+ * EngineService — the workflow execution engine.
+ *
+ * Consumes stream messages from the router and dispatches them
+ * to the appropriate activity handler (Trigger, Worker, Hook, …).
+ *
+ * Each section delegates to a purpose-specific module inside `engine/`.
+ * Open the module when you need implementation detail; read this file
+ * when you need the big picture.
+ *
+ * Lifecycle (maps to modules):
+ *   1. INIT       → init.ts       (channel setup, router, config)
+ *   2. VERSION    → version.ts    (app version resolution, caching)
+ *   3. SCHEMA     → schema.ts     (activity lookup, handler factory)
+ *   4. COMPILE    → compiler.ts   (YAML plan & deploy)
+ *   5. REPORT     → reporting.ts  (stats, IDs, query resolution)
+ *   6. DISPATCH   → dispatch.ts   (stream message → activity handler)
+ *   7. COMPLETION → completion.ts (parent notify, cleanup, expiry)
+ *   8. SIGNAL     → signal.ts     (webhook/timehook delivery, fan-out)
+ *   9. PUB/SUB    → pubsub.ts     (topic messaging, subscriptions)
+ *  10. STATE      → state.ts      (job state retrieval, export)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EngineService = void 0;
 const key_1 = require("../../modules/key");
-const registry_1 = require("../stream/registry");
 const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
-const activities_1 = __importDefault(require("../activities"));
-const compiler_1 = require("../compiler");
-const exporter_1 = require("../exporter");
-const reporter_1 = require("../reporter");
-const router_1 = require("../router");
-const serializer_1 = require("../serializer");
-const factory_1 = require("../search/factory");
-const factory_2 = require("../store/factory");
-const factory_3 = require("../stream/factory");
-const factory_4 = require("../sub/factory");
-const task_1 = require("../task");
 const stream_1 = require("../../types/stream");
+const Init = __importStar(require("./init"));
+const Version = __importStar(require("./version"));
+const Schema = __importStar(require("./schema"));
+const Compiler = __importStar(require("./compiler"));
+const Reporting = __importStar(require("./reporting"));
+const Dispatch = __importStar(require("./dispatch"));
+const Completion = __importStar(require("./completion"));
+const Signal = __importStar(require("./signal"));
+const PubSub = __importStar(require("./pubsub"));
+const State = __importStar(require("./state"));
 class EngineService {
+    // ═════════════════════════════════════════════════════════════════
+    //  1. INIT — bootstrap channels, router, and services
+    //     → see init.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
     constructor() {
+        // ── execution state ───────────────────────────────────────────────
         this.cacheMode = 'cache';
         this.untilVersion = null;
         this.jobCallbacks = {};
-        this.reporting = false;
-        this.jobId = 1;
     }
     /**
      * @private
@@ -37,608 +80,238 @@ class EngineService {
     static async init(namespace, appId, guid, config, logger) {
         if (config.engine) {
             const instance = new EngineService();
-            instance.verifyEngineFields(config);
+            Init.verifyEngineFields(config);
             instance.namespace = namespace;
             instance.appId = appId;
             instance.guid = guid;
             instance.logger = logger;
-            await instance.initSearchChannel(config.engine.store);
-            await instance.initStoreChannel(config.engine.store);
-            //NOTE: if `pub` is present, use it; otherwise, use `store`
-            await instance.initSubChannel(config.engine.sub, config.engine.pub ?? config.engine.store);
-            await instance.initStreamChannel(config.engine.stream, config.engine.store);
-            instance.router = await instance.initRouter(config);
-            // Use singleton consumer via registry for engine stream
-            await registry_1.StreamConsumerRegistry.registerEngine(namespace, appId, guid, instance.processStreamMessage.bind(instance), instance.stream, instance.store, logger, {
-                reclaimDelay: config.engine.reclaimDelay,
-                reclaimCount: config.engine.reclaimCount,
-            });
-            instance.taskService = new task_1.TaskService(instance.store, logger);
-            instance.exporter = new exporter_1.ExporterService(instance.appId, instance.store, logger);
-            instance.inited = (0, utils_1.formatISODate)(new Date());
+            await Init.initSearchChannel(instance, config.engine.store);
+            await Init.initStoreChannel(instance, config.engine.store);
+            await Init.initSubChannel(instance, config.engine.sub, config.engine.pub ?? config.engine.store);
+            await Init.initStreamChannel(instance, config.engine.stream, config.engine.store);
+            instance.router = await Init.initRouter(instance, config);
+            await Init.registerStreamConsumer(instance, config);
+            Init.initServices(instance);
             return instance;
         }
     }
     /**
      * @private
      */
-    verifyEngineFields(config) {
-        if (!(0, utils_1.identifyProvider)(config.engine.store) ||
-            !(0, utils_1.identifyProvider)(config.engine.stream) ||
-            !(0, utils_1.identifyProvider)(config.engine.sub)) {
-            throw new Error('engine must include `store`, `stream`, and `sub` fields.');
-        }
-    }
-    /**
-     * @private
-     */
-    async initSearchChannel(search, store) {
-        this.search = await factory_1.SearchServiceFactory.init(search, store, this.namespace, this.appId, this.logger);
-    }
-    /**
-     * @private
-     */
-    async initStoreChannel(store) {
-        this.store = await factory_2.StoreServiceFactory.init(store, this.namespace, this.appId, this.logger);
-    }
-    /**
-     * @private
-     */
-    async initSubChannel(sub, store) {
-        this.subscribe = await factory_4.SubServiceFactory.init(sub, store, this.namespace, this.appId, this.guid, this.logger);
-    }
-    /**
-     * @private
-     */
-    async initStreamChannel(stream, store) {
-        this.stream = await factory_3.StreamServiceFactory.init(stream, store, this.namespace, this.appId, this.logger);
-    }
-    /**
-     * @private
-     */
-    async initRouter(config) {
-        const throttle = await this.store.getThrottleRate(':');
-        return new router_1.Router({
-            namespace: this.namespace,
-            appId: this.appId,
-            guid: this.guid,
-            role: stream_1.StreamRole.ENGINE,
-            reclaimDelay: config.engine.reclaimDelay,
-            reclaimCount: config.engine.reclaimCount,
-            throttle,
-            readonly: config.engine.readonly,
-        }, this.stream, this.logger);
+    async getSettings() {
+        return Init.getSettings(this);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  2. VERSION — app version resolution and cache management
+    //     → see version.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
-     * resolves the distributed executable version using a delay
-     * to allow deployment race conditions to resolve
      * @private
      */
-    async fetchAndVerifyVID(vid, count = 0) {
-        if (isNaN(Number(vid.version))) {
-            const app = await this.store.getApp(vid.id, true);
-            if (!isNaN(Number(app.version))) {
-                if (!this.apps)
-                    this.apps = {};
-                this.apps[vid.id] = app;
-                return { id: vid.id, version: app.version };
-            }
-            else if (count < 10) {
-                await (0, utils_1.sleepFor)(enums_1.HMSH_QUORUM_DELAY_MS * 2);
-                return await this.fetchAndVerifyVID(vid, count + 1);
-            }
-            else {
-                this.logger.error('engine-vid-resolution-error', {
-                    id: vid.id,
-                    guid: this.guid,
-                });
-            }
-        }
-        return vid;
-    }
     async getVID(vid) {
-        if (this.cacheMode === 'nocache') {
-            const app = await this.store.getApp(this.appId, true);
-            if (app.version.toString() === this.untilVersion.toString()) {
-                //new version is deployed; OK to cache again
-                if (!this.apps)
-                    this.apps = {};
-                this.apps[this.appId] = app;
-                this.setCacheMode('cache', app.version.toString());
-            }
-            return { id: this.appId, version: app.version };
-        }
-        else if (!this.apps && vid) {
-            this.apps = {};
-            this.apps[this.appId] = vid;
-            return vid;
-        }
-        else {
-            return await this.fetchAndVerifyVID({
-                id: this.appId,
-                version: this.apps?.[this.appId].version,
-            });
-        }
+        return Version.getVID(this, vid);
     }
     /**
      * @private
      */
     setCacheMode(cacheMode, untilVersion) {
-        this.logger.info(`engine-executable-cache`, {
-            mode: cacheMode,
-            [cacheMode === 'cache' ? 'target' : 'until']: untilVersion,
-        });
-        this.cacheMode = cacheMode;
-        this.untilVersion = untilVersion;
+        Version.setCacheMode(this, cacheMode, untilVersion);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  3. SCHEMA — activity schema lookup and handler instantiation
+    //     → see schema.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    async routeToSubscribers(topic, message) {
-        const jobCallback = this.jobCallbacks[message.metadata.jid];
-        if (jobCallback) {
-            this.delistJobCallback(message.metadata.jid);
-            jobCallback(topic, message);
-        }
+    async initActivity(topic, data = {}, context) {
+        return Schema.initActivity(this, topic, data, context);
     }
     /**
      * @private
      */
-    async processWebHooks() {
-        this.taskService.processWebHooks(this.signal.bind(this));
+    async getSchema(topic) {
+        return Schema.getSchema(this, topic);
     }
     /**
      * @private
      */
-    async processTimeHooks() {
-        this.taskService.processTimeHooks(this.hookTime.bind(this));
+    isPrivate(topic) {
+        return Schema.isPrivate(topic);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  4. COMPILE — YAML app plan & deploy
+    //     → see compiler.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    async throttle(delayInMillis) {
-        try {
-            this.router?.setThrottle(delayInMillis);
-        }
-        catch (e) {
-            this.logger.error('engine-throttle-error', { error: e });
-        }
+    async plan(pathOrYAML) {
+        return Compiler.plan(this, pathOrYAML);
     }
-    // ************* METADATA/MODEL METHODS *************
     /**
      * @private
      */
-    async initActivity(topic, data = {}, context) {
-        const [activityId, schema] = await this.getSchema(topic);
-        if (!schema) {
-            throw new Error(`Activity schema not found for "${activityId}" (topic: ${topic}) in app ${this.appId}`);
-        }
-        const ActivityHandler = activities_1.default[schema.type];
-        if (ActivityHandler) {
-            const utc = (0, utils_1.formatISODate)(new Date());
-            const metadata = {
-                aid: activityId,
-                atp: schema.type,
-                stp: schema.subtype,
-                ac: utc,
-                au: utc,
-            };
-            const hook = null;
-            return new ActivityHandler(schema, data, metadata, hook, this, context);
-        }
-        else {
-            throw new Error(`activity type ${schema.type} not found`);
-        }
-    }
-    async getSchema(topic) {
-        const app = (await this.store.getApp(this.appId));
-        if (!app) {
-            throw new Error(`no app found for id ${this.appId}`);
-        }
-        if (this.isPrivate(topic)) {
-            //private subscriptions use the schema id (.activityId)
-            const activityId = topic.substring(1);
-            const schema = await this.store.getSchema(activityId, await this.getVID(app));
-            return [activityId, schema];
-        }
-        else {
-            //public subscriptions use a topic (a.b.c) that is associated with a schema id
-            const activityId = await this.store.getSubscription(topic, await this.getVID(app));
-            if (activityId) {
-                const schema = await this.store.getSchema(activityId, await this.getVID(app));
-                return [activityId, schema];
-            }
-        }
-        throw new Error(`no subscription found for topic ${topic} in app ${this.appId} for app version ${app.version}`);
+    async deploy(pathOrYAML) {
+        return Compiler.deploy(this, pathOrYAML);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  5. REPORT — stats queries and job-ID lookups
+    //     → see reporting.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    async getSettings() {
-        return await this.store.getSettings();
+    async getStats(topic, query) {
+        return Reporting.getStats(this, topic, query);
     }
     /**
      * @private
      */
-    isPrivate(topic) {
-        return topic.startsWith('.');
+    async getIds(topic, query, queryFacets = []) {
+        return Reporting.getIds(this, topic, query, queryFacets);
     }
-    // ************* COMPILER METHODS *************
     /**
      * @private
      */
-    async plan(pathOrYAML) {
-        const compiler = new compiler_1.CompilerService(this.store, this.stream, this.logger);
-        return await compiler.plan(pathOrYAML);
+    async resolveQuery(topic, query) {
+        return Reporting.resolveQuery(this, topic, query);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  6. DISPATCH — stream message routing to activity handlers
+    //     → see dispatch.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    async deploy(pathOrYAML) {
-        const compiler = new compiler_1.CompilerService(this.store, this.stream, this.logger);
-        return await compiler.deploy(pathOrYAML);
+    async processStreamMessage(streamData) {
+        return Dispatch.processStreamMessage(this, streamData);
     }
-    // ************* REPORTER METHODS *************
+    // ═════════════════════════════════════════════════════════════════
+    //  7. COMPLETION — parent notification, cleanup, and expiry
+    //     → see completion.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    async getStats(topic, query) {
-        const { id, version } = await this.getVID();
-        const reporter = new reporter_1.ReporterService({ id, version }, this.store, this.logger);
-        const resolvedQuery = await this.resolveQuery(topic, query);
-        return await reporter.getStats(resolvedQuery);
+    async execAdjacentParent(context, jobOutput, emit = false, transaction) {
+        return Completion.execAdjacentParent(this, context, jobOutput, emit, transaction);
     }
     /**
      * @private
      */
-    async getIds(topic, query, queryFacets = []) {
-        const { id, version } = await this.getVID();
-        const reporter = new reporter_1.ReporterService({ id, version }, this.store, this.logger);
-        const resolvedQuery = await this.resolveQuery(topic, query);
-        return await reporter.getIds(resolvedQuery, queryFacets);
+    hasParentJob(context, checkSevered = false) {
+        return Completion.hasParentJob(context, checkSevered);
     }
     /**
      * @private
      */
-    async resolveQuery(topic, query) {
-        const trigger = (await this.initActivity(topic, query.data));
-        await trigger.getState();
-        return {
-            end: query.end,
-            start: query.start,
-            range: query.range,
-            granularity: trigger.resolveGranularity(),
-            key: trigger.resolveJobKey(trigger.createInputContext()),
-            sparse: query.sparse,
-        };
+    async interrupt(topic, jobId, options = {}) {
+        return Completion.interrupt(this, topic, jobId, options);
     }
-    // ****************** STREAM RE-ENTRY POINT *****************
     /**
      * @private
      */
-    async processStreamMessage(streamData) {
-        this.logger.debug('engine-process', {
-            jid: streamData.metadata.jid,
-            gid: streamData.metadata.gid,
-            dad: streamData.metadata.dad,
-            aid: streamData.metadata.aid,
-            status: streamData.status || stream_1.StreamStatus.SUCCESS,
-            code: streamData.code || 200,
-            type: streamData.type,
-        });
-        const context = {
-            metadata: {
-                guid: streamData.metadata.guid,
-                jid: streamData.metadata.jid,
-                gid: streamData.metadata.gid,
-                dad: streamData.metadata.dad,
-                aid: streamData.metadata.aid,
-            },
-            data: streamData.data,
-        };
-        if (streamData.type === stream_1.StreamDataType.TIMEHOOK) {
-            //TIMEHOOK AWAKEN
-            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context));
-            await activityHandler.processTimeHookEvent(streamData.metadata.jid);
-        }
-        else if (streamData.type === stream_1.StreamDataType.WEBHOOK) {
-            //WEBHOOK AWAKEN (SIGNAL IN)
-            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context));
-            await activityHandler.processWebHookEvent(streamData.status, streamData.code);
-        }
-        else if (streamData.type === stream_1.StreamDataType.TRANSITION) {
-            //TRANSITION (ADJACENT ACTIVITY)
-            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context)); //todo: `as Activity` (type is more generic)
-            await activityHandler.process();
-        }
-        else if (streamData.type === stream_1.StreamDataType.AWAIT) {
-            //TRIGGER JOB
-            context.metadata = {
-                ...context.metadata,
-                pj: streamData.metadata.jid,
-                pg: streamData.metadata.gid,
-                pd: streamData.metadata.dad,
-                pa: streamData.metadata.aid,
-                px: streamData.metadata.await === false,
-                trc: streamData.metadata.trc,
-                spn: streamData.metadata.spn,
-            };
-            const activityHandler = (await this.initActivity(streamData.metadata.topic, streamData.data, context));
-            await activityHandler.process();
-        }
-        else if (streamData.type === stream_1.StreamDataType.RESULT) {
-            //AWAIT RESULT
-            const activityHandler = (await this.initActivity(`.${context.metadata.aid}`, streamData.data, context));
-            await activityHandler.processEvent(streamData.status, streamData.code);
-        }
-        else {
-            //WORKER RESULT
-            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context));
-            await activityHandler.processEvent(streamData.status, streamData.code, 'output');
-        }
-        this.logger.debug('engine-process-end', {
-            jid: streamData.metadata.jid,
-            gid: streamData.metadata.gid,
-            aid: streamData.metadata.aid,
-        });
+    async scrub(jobId) {
+        return Completion.scrub(this, jobId);
     }
-    // ***************** `AWAIT` ACTIVITY RETURN RESPONSE ****************
     /**
      * @private
      */
-    async execAdjacentParent(context, jobOutput, emit = false, transaction) {
-        if (this.hasParentJob(context)) {
-            //errors are stringified `StreamError` objects
-            const error = this.resolveError(jobOutput.metadata);
-            const spn = context['$self']?.output?.metadata?.l2s ||
-                context['$self']?.output?.metadata?.l1s;
-            const streamData = {
-                metadata: {
-                    guid: (0, utils_1.guid)(),
-                    jid: context.metadata.pj,
-                    gid: context.metadata.pg,
-                    dad: context.metadata.pd,
-                    aid: context.metadata.pa,
-                    trc: context.metadata.trc,
-                    spn,
-                },
-                type: stream_1.StreamDataType.RESULT,
-                data: jobOutput.data,
-            };
-            if (error && error.code) {
-                streamData.status = stream_1.StreamStatus.ERROR;
-                streamData.data = error;
-                streamData.code = error.code;
-                streamData.stack = error.stack;
-            }
-            else if (emit) {
-                streamData.status = stream_1.StreamStatus.PENDING;
-                streamData.code = enums_1.HMSH_CODE_PENDING;
-            }
-            else {
-                streamData.status = stream_1.StreamStatus.SUCCESS;
-                streamData.code = enums_1.HMSH_CODE_SUCCESS;
-            }
-            return (await this.router?.publishMessage(null, streamData, transaction));
-        }
+    async runJobCompletionTasks(context, options = {}, transaction) {
+        return Completion.runJobCompletionTasks(this, context, options, transaction);
     }
+    // ═════════════════════════════════════════════════════════════════
+    //  8. SIGNAL — webhook/timehook delivery and fan-out
+    //     → see signal.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
-    hasParentJob(context, checkSevered = false) {
-        if (checkSevered) {
-            return Boolean(context.metadata.pj && context.metadata.pa && !context.metadata.px);
-        }
-        return Boolean(context.metadata.pj && context.metadata.pa);
+    async signal(topic, data, status = stream_1.StreamStatus.SUCCESS, code = 200, transaction) {
+        return Signal.signal(this, topic, data, status, code, transaction);
     }
     /**
      * @private
      */
-    resolveError(metadata) {
-        if (metadata && metadata.err) {
-            return JSON.parse(metadata.err);
-        }
+    async hookTime(jobId, gId, topicOrActivity, type) {
+        return Signal.hookTime(this, jobId, gId, topicOrActivity, type);
     }
-    // ****************** `INTERRUPT` ACTIVE JOBS *****************
     /**
      * @private
      */
-    async interrupt(topic, jobId, options = {}) {
-        //immediately interrupt the job, going directly to the data source
-        await this.store.interrupt(topic, jobId, options);
-        //now that the job is interrupted, we can clean up
-        const context = (await this.getState(topic, jobId));
-        const completionOpts = {
-            interrupt: options.descend,
-            expire: options.expire,
-        };
-        return (await this.runJobCompletionTasks(context, completionOpts));
+    async signalAll(hookTopic, data, keyResolver, queryFacets = []) {
+        return Signal.signalAll(this, hookTopic, data, keyResolver, queryFacets);
     }
-    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     /**
      * @private
      */
-    async scrub(jobId) {
-        //todo: do not allow scrubbing of non-existent or actively running job
-        await this.store.scrub(jobId);
+    async routeToSubscribers(topic, message) {
+        return Signal.routeToSubscribers(this, topic, message);
     }
-    // ****************** `SIGNAL` ACTIVITY RE-ENTRY POINT ****************
     /**
-     * Delivers a signal (data payload) to a paused hook activity,
-     * resuming its Leg 2 execution. The `topic` must match a hook rule
-     * defined in the YAML graph's `hooks` section. The engine locates
-     * the target activity and dimension for reentry based on the hook
-     * rule's match conditions.
-     *
      * @private
      */
-    async signal(topic, data, status = stream_1.StreamStatus.SUCCESS, code = 200, transaction) {
-        const hookRule = await this.taskService.getHookRule(topic);
-        const [aid] = await this.getSchema(`.${hookRule.to}`);
-        const streamData = {
-            type: stream_1.StreamDataType.WEBHOOK,
-            status,
-            code,
-            metadata: {
-                guid: (0, utils_1.guid)(),
-                aid,
-                topic,
-            },
-            data,
-        };
-        return (await this.router?.publishMessage(null, streamData, transaction));
+    async processWebHooks() {
+        return Signal.processWebHooks(this, this.signal.bind(this));
     }
     /**
      * @private
      */
-    async hookTime(jobId, gId, topicOrActivity, type) {
-        if (type === 'interrupt' || type === 'expire') {
-            return await this.interrupt(topicOrActivity, jobId, {
-                suppress: true,
-                expire: 1,
-            });
-        }
-        const [aid, ...dimensions] = topicOrActivity.split(',');
-        const dad = `,${dimensions.join(',')}`;
-        const streamData = {
-            type: stream_1.StreamDataType.TIMEHOOK,
-            metadata: {
-                guid: (0, utils_1.guid)(),
-                jid: jobId,
-                gid: gId,
-                dad,
-                aid,
-            },
-            data: { timestamp: Date.now() },
-        };
-        await this.router?.publishMessage(null, streamData);
-    }
-    /**
-     * Fan-out variant of `signal()` that delivers data to **all**
-     * paused workflows matching a search query. Useful for resuming
-     * a batch of workflows waiting on the same external event.
-     *
+    async processTimeHooks() {
+        return Signal.processTimeHooks(this, this.hookTime.bind(this));
+    }
+    /**
      * @private
      */
-    async signalAll(hookTopic, data, keyResolver, queryFacets = []) {
-        const config = await this.getVID();
-        const hookRule = await this.taskService.getHookRule(hookTopic);
-        if (hookRule) {
-            const subscriptionTopic = await (0, utils_1.getSubscriptionTopic)(hookRule.to, this.store, config);
-            const resolvedQuery = await this.resolveQuery(subscriptionTopic, keyResolver);
-            const reporter = new reporter_1.ReporterService(config, this.store, this.logger);
-            const workItems = await reporter.getWorkItems(resolvedQuery, queryFacets);
-            if (workItems.length) {
-                const taskService = new task_1.TaskService(this.store, this.logger);
-                await taskService.enqueueWorkItems(workItems.map((workItem) => [
-                    hookTopic,
-                    workItem,
-                    keyResolver.scrub || false,
-                    JSON.stringify(data),
-                ].join(key_1.VALSEP)));
-                this.subscribe.publish(key_1.KeyType.QUORUM, { type: 'work', originator: this.guid }, this.appId);
-            }
-            return workItems;
-        }
-        else {
-            throw new Error(`unable to find hook rule for topic ${hookTopic}`);
-        }
+    async throttle(delayInMillis) {
+        return Signal.throttle(this, delayInMillis);
     }
-    // ********************** PUB/SUB ENTRY POINT **********************
+    // ═════════════════════════════════════════════════════════════════
+    //  9. PUB/SUB — topic messaging, subscriptions, callbacks
+    //     → see pubsub.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
     async pub(topic, data, context, extended) {
-        const activityHandler = await this.initActivity(topic, data, context);
-        if (activityHandler) {
-            return await activityHandler.process(extended);
-        }
-        else {
-            throw new Error(`unable to process activity for topic ${topic}`);
-        }
+        return PubSub.pub(this, topic, data, context, extended);
     }
     /**
      * @private
      */
     async sub(topic, callback) {
-        const subscriptionCallback = async (topic, message) => {
-            let jobOutput = message.job;
-            // If _ref is true, payload was too large - fetch full job data via getState
-            if (message._ref && message.job?.metadata) {
-                jobOutput = await this.getState(message.job.metadata.tpc, message.job.metadata.jid);
-            }
-            callback(message.topic, jobOutput);
-        };
-        return await this.subscribe.subscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, topic);
+        return PubSub.sub(this, topic, callback);
     }
     /**
      * @private
      */
     async unsub(topic) {
-        return await this.subscribe.unsubscribe(key_1.KeyType.QUORUM, this.appId, topic);
+        return PubSub.unsub(this, topic);
     }
     /**
      * @private
      */
     async psub(wild, callback) {
-        const subscriptionCallback = async (topic, message) => {
-            let jobOutput = message.job;
-            // If _ref is true, payload was too large - fetch full job data via getState
-            if (message._ref && message.job?.metadata) {
-                jobOutput = await this.getState(message.job.metadata.tpc, message.job.metadata.jid);
-            }
-            callback(message.topic, jobOutput);
-        };
-        return await this.subscribe.psubscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, wild);
+        return PubSub.psub(this, wild, callback);
     }
     /**
      * @private
      */
     async punsub(wild) {
-        return await this.subscribe.punsubscribe(key_1.KeyType.QUORUM, this.appId, wild);
+        return PubSub.punsub(this, wild);
     }
     /**
      * @private
      */
     async pubsub(topic, data, context, timeout = enums_1.HMSH_OTT_WAIT_TIME) {
-        context = {
-            metadata: {
-                ngn: this.guid,
-                trc: context?.metadata?.trc,
-                spn: context?.metadata?.spn,
-            },
-        };
-        const jobId = await this.pub(topic, data, context);
-        return new Promise((resolve, reject) => {
-            this.registerJobCallback(jobId, (topic, output) => {
-                if (output.metadata.err) {
-                    const error = JSON.parse(output.metadata.err);
-                    reject({
-                        error,
-                        job_id: output.metadata.jid,
-                    });
-                }
-                else {
-                    resolve(output);
-                }
-            });
-            setTimeout(() => {
-                //note: job is still active (the subscriber timed out)
-                this.delistJobCallback(jobId);
-                reject({
-                    code: enums_1.HMSH_CODE_TIMEOUT,
-                    message: 'timeout',
-                    job_id: jobId,
-                });
-            }, timeout);
-        });
+        return PubSub.pubsub(this, topic, data, context, timeout);
     }
     /**
      * @private
      */
     async pubOneTimeSubs(context, jobOutput, emit = false, transaction) {
-        //todo: subscriber should query for the job...only publish minimum context needed
-        if (this.hasOneTimeSubscription(context)) {
+        if (PubSub.hasOneTimeSubscription(context)) {
             const message = {
                 type: 'job',
                 topic: context.metadata.jid,
@@ -647,20 +320,11 @@ class EngineService {
             await this.subscribe.publish(key_1.KeyType.QUORUM, message, this.appId, context.metadata.ngn, transaction);
         }
     }
-    /**
-     * @private
-     */
-    async getPublishesTopic(context) {
-        const config = await this.getVID();
-        const activityId = context.metadata.aid || context['$self']?.output?.metadata?.aid;
-        const schema = await this.store.getSchema(activityId, config);
-        return schema.publishes;
-    }
     /**
      * @private
      */
     async pubPermSubs(context, jobOutput, emit = false, transaction) {
-        const topic = await this.getPublishesTopic(context);
+        const topic = await PubSub.getPublishesTopic(this, context);
         if (topic) {
             const message = {
                 type: 'job',
@@ -673,135 +337,73 @@ class EngineService {
     /**
      * @private
      */
-    async add(streamData) {
-        return (await this.router?.publishMessage(null, streamData));
-    }
-    /**
-     * @private
-     */
-    registerJobCallback(jobId, jobCallback) {
-        this.jobCallbacks[jobId] = jobCallback;
+    async getPublishesTopic(context) {
+        return PubSub.getPublishesTopic(this, context);
     }
     /**
      * @private
      */
-    delistJobCallback(jobId) {
-        delete this.jobCallbacks[jobId];
+    async add(streamData) {
+        return PubSub.add(this, streamData);
     }
     /**
      * @private
      */
-    hasOneTimeSubscription(context) {
-        return Boolean(context.metadata.ngn);
+    registerJobCallback(jobId, jobCallback) {
+        PubSub.registerJobCallback(this, jobId, jobCallback);
     }
-    // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
     /**
      * @private
      */
-    async runJobCompletionTasks(context, options = {}, transaction) {
-        //'emit' indicates the job is still active
-        const isAwait = this.hasParentJob(context, true);
-        const isOneTimeSub = this.hasOneTimeSubscription(context);
-        const topic = await this.getPublishesTopic(context);
-        let msgId;
-        let jobOutput;
-        if (isAwait || isOneTimeSub || topic) {
-            jobOutput = await this.getState(context.metadata.tpc, context.metadata.jid);
-            //only send RESULT to parent for non-severed children (execChild).
-            //startChild (px=true) children already sent RESULT at spawn time
-            //via Trigger.execAdjacentParent; sending again here would cause
-            //a duplicate semaphore decrement in collation workflows.
-            if (isAwait) {
-                msgId = await this.execAdjacentParent(context, jobOutput, options.emit, transaction);
-            }
-            if (transaction) {
-                //transactional: await to queue NOTIFY in the transaction
-                await this.pubOneTimeSubs(context, jobOutput, options.emit, transaction);
-                await this.pubPermSubs(context, jobOutput, options.emit, transaction);
-            }
-            else {
-                //non-transactional: fire-and-forget to avoid race with inline
-                //trigger processing (callback registered after pub() returns)
-                this.pubOneTimeSubs(context, jobOutput, options.emit);
-                this.pubPermSubs(context, jobOutput, options.emit);
-            }
-        }
-        if (!options.emit) {
-            if (transaction) {
-                await this.taskService.registerJobForCleanup(context.metadata.jid, this.resolveExpires(context, options), options, transaction);
-            }
-            else {
-                this.taskService.registerJobForCleanup(context.metadata.jid, this.resolveExpires(context, options), options);
-            }
-        }
-        return msgId;
+    delistJobCallback(jobId) {
+        PubSub.removeJobCallback(this, jobId);
     }
     /**
-     * Job hash expiration is typically reliant on the metadata field
-     * if the activity concludes normally. However, if the job is `interrupted`,
-     * it will be expired immediately.
      * @private
      */
-    resolveExpires(context, options) {
-        return options.expire ?? context.metadata.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS;
+    hasOneTimeSubscription(context) {
+        return PubSub.hasOneTimeSubscription(context);
     }
-    // ****** GET JOB STATE/COLLATION STATUS BY ID *********
+    // ═════════════════════════════════════════════════════════════════
+    //  10. STATE — job state retrieval, export, and compression
+    //      → see state.ts
+    // ═════════════════════════════════════════════════════════════════
     /**
      * @private
      */
     async export(jobId, options = {}) {
-        return await this.exporter.export(jobId, options);
+        return State.exportJob(this, jobId, options);
     }
     /**
      * @private
      */
     async getRaw(jobId) {
-        return await this.store.getRaw(jobId);
+        return State.getRaw(this, jobId);
     }
     /**
      * @private
      */
     async getStatus(jobId) {
-        const { id: appId } = await this.getVID();
-        return await this.store.getStatus(jobId, appId);
+        return State.getStatus(this, jobId);
     }
     /**
      * @private
      */
     async getState(topic, jobId) {
-        const jobSymbols = await this.store.getSymbols(`$${topic}`);
-        const consumes = {
-            [`$${topic}`]: Object.keys(jobSymbols),
-        };
-        //job data exists at the 'zero' dimension; pass an empty object
-        const dIds = {};
-        const output = await this.store.getState(jobId, consumes, dIds);
-        if (!output) {
-            throw new Error(`not found ${jobId}`);
-        }
-        const [state, status] = output;
-        const stateTree = (0, utils_1.restoreHierarchy)(state);
-        if (status != null && stateTree.metadata) {
-            stateTree.metadata.js = status;
-        }
-        return stateTree;
+        return State.getState(this, topic, jobId);
     }
     /**
      * @private
      */
     async getQueryState(jobId, fields) {
-        return await this.store.getQueryState(jobId, fields);
+        return State.getQueryState(this, jobId, fields);
     }
     /**
      * @private
      * @deprecated
      */
     async compress(terms) {
-        const existingSymbols = await this.store.getSymbolValues();
-        const startIndex = Object.keys(existingSymbols).length;
-        const maxIndex = Math.pow(52, 2) - 1;
-        const newSymbols = serializer_1.SerializerService.filterSymVals(startIndex, maxIndex, existingSymbols, new Set(terms));
-        return await this.store.addSymbolValues(newSymbols);
+        return State.compress(this, terms);
     }
 }
 exports.EngineService = EngineService;