@hotmeshio/hotmesh 0.0.36 → 0.0.37

package/build/services/task/index.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskService = void 0;
 const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
+const pipe_1 = require("../pipe");
 class TaskService {
     constructor(store, logger) {
         this.cleanupTimeout = null;
+        this.isScout = false;
         this.logger = logger;
         this.store = store;
     }
@@ -36,29 +38,61 @@ class TaskService {
             await this.store.registerExpireJob(jobId, expireTimeSlot, options);
         }
     }
-    async registerTimeHook(jobId, activityId, type, inSeconds = enums_1.FIDELITY_SECONDS, multi) {
+    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.FIDELITY_SECONDS, multi) {
         const awakenTimeSlot = Math.floor((Date.now() + (inSeconds * 1000)) / (enums_1.FIDELITY_SECONDS * 1000)) * (enums_1.FIDELITY_SECONDS * 1000); //n second awaken groups
-        await this.store.registerTimeHook(jobId, activityId, type, awakenTimeSlot, multi);
+        await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, multi);
+    }
+    /**
+     * Should this engine instance play the role of 'scout' for the quorum.
+     */
+    async shouldScout() {
+        const wasScout = this.isScout;
+        const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
+        if (isScout) {
+            if (!wasScout) {
+                setTimeout(() => {
+                    this.isScout = false;
+                }, enums_1.SCOUT_INTERVAL_SECONDS * 1000);
+            }
+            return true;
+        }
+        return false;
     }
     async processTimeHooks(timeEventCallback, listKey) {
-        try {
-            const timeJob = await this.store.getNextTimeJob(listKey);
-            if (timeJob) {
-                const [listKey, jobId, activityId, type] = timeJob;
-                await timeEventCallback(jobId, activityId, type);
-                await (0, utils_1.sleepFor)(0);
-                this.processTimeHooks(timeEventCallback, listKey);
+        if (await this.shouldScout()) {
+            try {
+                const timeJob = await this.store.getNextTimeJob(listKey);
+                if (Array.isArray(timeJob)) {
+                    //a queue had a job; try again immediately
+                    const [listKey, jobId, gId, activityId, type] = timeJob;
+                    await timeEventCallback(jobId, gId, activityId, type);
+                    await (0, utils_1.sleepFor)(0);
+                    this.processTimeHooks(timeEventCallback, listKey);
+                }
+                else if (timeJob) {
+                    //a queue was just emptied; try again immediately
+                    await (0, utils_1.sleepFor)(0);
+                    this.processTimeHooks(timeEventCallback);
+                }
+                else {
+                    //all queues are empty; sleep before checking
+                    let sleep = (0, utils_1.XSleepFor)(enums_1.FIDELITY_SECONDS * 1000);
+                    this.cleanupTimeout = sleep.timerId;
+                    await sleep.promise;
+                    this.processTimeHooks(timeEventCallback);
+                }
             }
-            else {
-                let sleep = (0, utils_1.XSleepFor)(enums_1.FIDELITY_SECONDS * 1000);
-                this.cleanupTimeout = sleep.timerId;
-                await sleep.promise;
-                this.processTimeHooks(timeEventCallback);
+            catch (err) {
+                //todo: retry connect to redis
+                this.logger.error('task-process-timehooks-error', err);
             }
         }
-        catch (err) {
-            //todo: retry connect to redis
-            this.logger.error('task-process-timehooks-error', err);
+        else {
+            //didn't get the scout role; try again in 'one-ish' minutes
+            let sleep = (0, utils_1.XSleepFor)(enums_1.SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
+            this.cleanupTimeout = sleep.timerId;
+            await sleep.promise;
+            this.processTimeHooks(timeEventCallback);
         }
     }
     cancelCleanup() {
@@ -67,5 +101,69 @@ class TaskService {
             this.cleanupTimeout = undefined;
         }
     }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerWebHook(topic, context, dad, multi) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            const mapExpression = hookRule.conditions.match[0].expected;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const jobId = context.metadata.jid;
+            const gId = context.metadata.gid;
+            const activityId = hookRule.to;
+            const hook = {
+                topic,
+                resolved,
+                jobId: `${activityId}::${dad}::${gId}::${jobId}`,
+            };
+            await this.store.setHookSignal(hook, multi);
+            return jobId;
+        }
+        else {
+            throw new Error('signaler.registerWebHook:error: hook rule not found');
+        }
+    }
+    async processWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return undefined
+                //users can also provide a bogus topic; not an issue; return undefined
+                return undefined;
+            }
+            //`aid` is part of composit key, but the hook `topic` is its public interface;
+            // this means that a new version of the graph can be deployed and the
+            // topic can be re-mapped to a different activity id. Outside callers
+            // can adhere to the unchanged contract (calling the same topic),
+            // while the internal system can be updated in real time as necessary.
+            const [_aid, dad, gid, ...jid] = hookSignalId.split('::');
+            return [jid.join('::'), hookRule.to, dad, gid];
+        }
+        else {
+            throw new Error('signal-not-found');
+        }
+    }
+    async deleteWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            return await this.store.deleteHookSignal(topic, resolved);
+        }
+        else {
+            throw new Error('signaler.process:error: hook rule not found');
+        }
+    }
 }
 exports.TaskService = TaskService;

package/build/services/telemetry/index.js

@@ -93,17 +93,17 @@ class TelemetryService {
                     return result;
                 }, {})
             };
-            this.span.setAttributes(namespacedAtts);
+            this.span?.setAttributes(namespacedAtts);
         }
     }
     setActivityAttributes(attributes) {
-        this.span.setAttributes(attributes);
+        this.span?.setAttributes(attributes);
     }
     setStreamAttributes(attributes) {
-        this.span.setAttributes(attributes);
+        this.span?.setAttributes(attributes);
     }
     setJobAttributes(attributes) {
-        this.jobSpan.setAttributes(attributes);
+        this.jobSpan?.setAttributes(attributes);
     }
     endJobSpan() {
         this.endSpan(this.jobSpan);
@@ -174,10 +174,10 @@ class TelemetryService {
         }
     }
     setActivityError(message) {
-        this.span.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
     }
     setStreamError(message) {
-        this.span.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
     }
     /**
      * Adds the paths (HGET) necessary to restore telemetry state for an activity

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

@@ -1,5 +1,5 @@
 import { ILogger } from "../logger";
-import { StreamSignaler } from "../signaler/stream";
+import { Router } from "../router";
 import { StoreService } from '../store';
 import { StreamService } from '../stream';
 import { SubService } from '../sub';
@@ -15,7 +15,7 @@ declare class WorkerService {
     store: StoreService<RedisClient, RedisMulti> | null;
     stream: StreamService<RedisClient, RedisMulti> | null;
     subscribe: SubService<RedisClient, RedisMulti> | null;
-    streamSignaler: StreamSignaler | null;
+    router: Router | null;
     logger: ILogger;
     reporting: boolean;
     static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<WorkerService[]>;
@@ -23,7 +23,7 @@ declare class WorkerService {
     initStoreChannel(service: WorkerService, store: RedisClient): Promise<void>;
     initSubChannel(service: WorkerService, sub: RedisClient): Promise<void>;
     initStreamChannel(service: WorkerService, stream: RedisClient): Promise<void>;
-    initStreamSignaler(worker: HotMeshWorker, logger: ILogger): StreamSignaler;
+    initRouter(worker: HotMeshWorker, logger: ILogger): Router;
     subscriptionHandler(): SubscriptionCallback;
     throttle(delayInMillis: number): Promise<void>;
 }

package/build/services/worker/index.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const key_1 = require("../../modules/key");
-const stream_1 = require("../signaler/stream");
+const router_1 = require("../router");
 const redis_1 = require("../store/clients/redis");
 const ioredis_1 = require("../store/clients/ioredis");
 const redis_2 = require("../stream/clients/redis");
 const ioredis_2 = require("../stream/clients/ioredis");
 const ioredis_3 = require("../sub/clients/ioredis");
 const redis_3 = require("../sub/clients/redis");
-const stream_2 = require("../../types/stream");
+const stream_1 = require("../../types/stream");
 const utils_1 = require("../../modules/utils");
 const connector_1 = require("../connector");
 class WorkerService {
@@ -35,9 +35,9 @@ class WorkerService {
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.topic);
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.guid);
                 await service.initStreamChannel(service, worker.stream);
-                service.streamSignaler = service.initStreamSignaler(worker, logger);
+                service.router = service.initRouter(worker, logger);
                 const key = service.stream.mintKey(key_1.KeyType.STREAMS, { appId: service.appId, topic: worker.topic });
-                await service.streamSignaler.consumeMessages(key, 'WORKER', service.guid, worker.callback);
+                await service.router.consumeMessages(key, 'WORKER', service.guid, worker.callback);
                 services.push(service);
             }
         }
@@ -78,12 +78,12 @@ class WorkerService {
         }
         await service.stream.init(service.namespace, service.appId, service.logger);
     }
-    initStreamSignaler(worker, logger) {
-        return new stream_1.StreamSignaler({
+    initRouter(worker, logger) {
+        return new router_1.Router({
             namespace: this.namespace,
             appId: this.appId,
             guid: this.guid,
-            role: stream_2.StreamRole.WORKER,
+            role: stream_1.StreamRole.WORKER,
             topic: worker.topic,
             reclaimDelay: worker.reclaimDelay,
             reclaimCount: worker.reclaimCount,
@@ -99,7 +99,7 @@ class WorkerService {
         };
     }
     async throttle(delayInMillis) {
-        this.streamSignaler.setThrottle(delayInMillis);
+        this.router.setThrottle(delayInMillis);
     }
 }
 exports.WorkerService = WorkerService;

package/build/types/job.d.ts

@@ -6,10 +6,12 @@ type ActivityData = {
 };
 type JobMetadata = {
     key?: string;
+    gid: string;
     jid: string;
     dad: string;
     aid: string;
     pj?: string;
+    pg?: string;
     pd?: string;
     pa?: string;
     ngn?: string;

package/build/types/stream.d.ts

@@ -31,6 +31,7 @@ export interface StreamData {
         guid: string;
         topic?: string;
         jid?: string;
+        gid?: string;
         dad?: string;
         aid: string;
         trc?: string;

package/modules/enums.ts

@@ -30,3 +30,6 @@ export const FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? TEST_FIDELITY_
 
 // DURABLE CONSTANTS
 export const DURABLE_EXPIRE_SECONDS = 1;
+
+// TASK CONSTANTS
+export const SCOUT_INTERVAL_SECONDS = 60;

package/modules/errors.ts

@@ -122,6 +122,23 @@ class InactiveJobError extends Error {
     this.status = status;
   }
 }
+class GenerationalError extends Error {
+  expected: string;
+  actual: string;
+  jobId: string;
+  activityId: string;
+  dimensionalAddress: string;
+
+  constructor(expected: string, actual: string, jobId: string, activityId: string, dimensionalAddress: string) {
+    super("Generational Error");
+    this.expected = expected;
+    this.actual = actual;
+    this.jobId = jobId;
+    this.activityId = activityId;
+    this.dimensionalAddress = dimensionalAddress;
+  }
+}
+
 class ExecActivityError extends Error {
   constructor() {
     super("Error occurred while executing activity");
@@ -155,6 +172,7 @@ export {
   DurableWaitForSignalError,
   DuplicateJobError,
   ExecActivityError,
+  GenerationalError,
   GetStateError,
   InactiveJobError,
   MapDataError,

package/modules/key.ts

@@ -31,25 +31,25 @@ const HMNS = "hmsh";
 
 //these are the entity types that are stored in the key/value store
 enum KeyType {
-  APP,
-  ENGINE_ID,
-  HOOKS,
-  JOB_DEPENDENTS,
-  JOB_STATE,
-  JOB_STATS_GENERAL,
-  JOB_STATS_MEDIAN,
-  JOB_STATS_INDEX,
-  HOTMESH,
-  QUORUM,
-  SCHEMAS,
-  SIGNALS,
-  STREAMS,
-  SUBSCRIPTIONS,
-  SUBSCRIPTION_PATTERNS,
-  SYMKEYS,
-  SYMVALS,
-  TIME_RANGE,
-  WORK_ITEMS,
+  APP = 'APP',
+  ENGINE_ID = 'ENGINE',
+  HOOKS = 'HOOKS',
+  JOB_DEPENDENTS = 'JOB_DEPENDENTS',
+  JOB_STATE = 'JOB_STATE',
+  JOB_STATS_GENERAL = 'JOB_STATS_GENERAL',
+  JOB_STATS_MEDIAN = 'JOB_STATS_MEDIAN',
+  JOB_STATS_INDEX = 'JOB_STATS_INDEX',
+  HOTMESH = 'HOTMESH',
+  QUORUM = 'QUORUM',
+  SCHEMAS = 'SCHEMAS',
+  SIGNALS = 'SIGNALS',
+  STREAMS = 'STREAMS',
+  SUBSCRIPTIONS = 'SUBSCRIPTIONS',
+  SUBSCRIPTION_PATTERNS = 'SUBSCRIPTION_PATTERNS',
+  SYMKEYS = 'SYMKEYS',
+  SYMVALS = 'SYMVALS',
+  TIME_RANGE = 'TIME_RANGE',
+  WORK_ITEMS = 'WORK_ITEMS',
 }
 
 //when minting a key, the following parameters are used to create a unique key per entity
@@ -64,6 +64,7 @@ type KeyStoreParams = {
   facet?: string;       //data path starting at root with values separated by colons (e.g. "object/type:bar")
   topic?: string;       //topic name (e.g., "foo" or "" for top-level)
   timeValue?: number;   //time value (rounded to minute) (for delete range)
+  scoutType?: 'signal' | 'time'; //a single member of the quorum serves as the 'scout' for the group, triaging tasks for the collective
 };
 
 class KeyService {
@@ -86,7 +87,7 @@ class KeyService {
       case KeyType.ENGINE_ID:
         return `${namespace}:${params.appId}:e:${params.engineId}`;
       case KeyType.WORK_ITEMS:
-        return `${namespace}:${params.appId}:w:`;
+        return `${namespace}:${params.appId}:w:${params.scoutType || ''}`;
       case KeyType.TIME_RANGE:
         return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
       case KeyType.APP:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/services/activities/activity.ts

@@ -1,4 +1,9 @@
-import { CollationError, GetStateError, InactiveJobError } from '../../modules/errors';
+import { EXPIRE_DURATION } from '../../modules/enums';
+import {
+  CollationError,
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import {
   formatISODate,
   getValueByPath,
@@ -30,7 +35,6 @@ import {
   StreamDataType,
   StreamStatus } from '../../types/stream';
 import { TransitionRule } from '../../types/transition';
-import { EXPIRE_DURATION } from '../../modules/enums';
 
 /**
  * The base class for all activities
@@ -71,6 +75,21 @@ class Activity {
     this.leg = leg;
   }
 
+  /**
+   * Upon entering leg 1 of a duplexed activty, verify
+   * all aspects of the entry including job and activty state
+   */
+  async verifyEntry() {
+    this.setLeg(1);
+    await this.getState();
+    CollatorService.assertJobActive(
+      this.context.metadata.js,
+      this.context.metadata.jid,
+      this.metadata.aid
+    );
+    await CollatorService.notarizeEntry(this);
+  }
+
   //********  DUPLEX RE-ENTRY POINT  ********//
   async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200, type: 'hook' | 'output' = 'output'): Promise<void> {
     this.setLeg(2);
@@ -116,6 +135,9 @@ class Activity {
       } else if (error instanceof InactiveJobError) {
         this.logger.info('process-event-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.info('process-event-get-job-error', { error });
         return;
@@ -337,7 +359,7 @@ class Activity {
   }
 
   async getState() {
-    //assemble list of paths necessary to create 'job state' from the 'symbol hash'
+    const gid = this.context.metadata.gid;
     const jobSymbolHashName = `$${this.config.subscribes}`;
     const consumes: Consumes = {
       [jobSymbolHashName]: MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`)
@@ -365,11 +387,28 @@ class Activity {
     //`state` is a flat hash; context is a tree
     const [state, status] = await this.store.getState(jid, consumes, dIds);
     this.context = restoreHierarchy(state) as JobState;
+    this.assertGenerationalId(this.context.metadata.gid, gid);
     this.initDimensionalAddress(dad);
     this.initSelf(this.context);
     this.initPolicies(this.context);
   }
 
+  /**
+   * if the job is created/deleted/created with the same key,
+   * the 'gid' ensures no stale messages enter the stream
+   */
+  assertGenerationalId(jobGID: string, msgGID?: string) {
+    if (msgGID !== jobGID) {
+      throw new GenerationalError(
+        jobGID,
+        msgGID,
+        this.context.metadata.jid,
+        this.context.metadata.aid,
+        this.context.metadata.dad
+      );
+    }
+  }
+
   initDimensionalAddress(dad: string): void {
     this.metadata.dad = dad;
   }
@@ -434,6 +473,7 @@ class Activity {
             metadata: {
               guid: guid(),
               jid: this.context.metadata.jid,
+              gid: this.context.metadata.gid,
               dad: adjacentDad,
               aid: toActivityId,
               spn: this.context['$self'].output.metadata?.l2s,
@@ -466,7 +506,7 @@ class Activity {
     if (adjacencyList.length && jobStatus > 0) {
       const multi = this.store.getMulti();
       for (const execSignal of adjacencyList) {
-        await this.engine.streamSignaler?.publishMessage(null, execSignal, multi);
+        await this.engine.router?.publishMessage(null, execSignal, multi);
       }
       mIds = (await multi.exec()) as string[];
     }

package/services/activities/await.ts

@@ -1,7 +1,11 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
+import { TelemetryService } from '../telemetry';
 import {
   ActivityData,
   ActivityMetadata,
@@ -10,7 +14,6 @@ import {
 import { JobState } from '../../types/job';
 import { MultiResponseFlags, RedisMulti } from '../../types/redis';
 import { StreamData, StreamDataType } from '../../types/stream';
-import { TelemetryService } from '../telemetry';
 import { Pipe } from '../pipe';
 import { guid } from '../../modules/utils';
 
@@ -29,14 +32,11 @@ class Await extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('await-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('await-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //confirm entry is allowed and restore state
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
       this.mapInputData();
@@ -62,6 +62,9 @@ class Await extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('await-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('await-get-state-error', { error });
         return;
@@ -72,7 +75,7 @@ class Await extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('await-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('await-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -82,6 +85,7 @@ class Await extends Activity {
       metadata: {
         guid: guid(),
         jid: this.context.metadata.jid,
+        gid: this.context.metadata.gid,
         dad: this.metadata.dad,
         aid: this.metadata.aid,
         topic,
@@ -96,7 +100,7 @@ class Await extends Activity {
         retry: this.config.retry
       };
     }
-    return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(null, streamData, multi)) as string;
   }
 }
 

package/services/activities/cycle.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { Activity, ActivityType } from './activity';
@@ -28,14 +31,11 @@ class Cycle extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('cycle-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //verify entry is allowed
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
       this.mapInputData();
@@ -65,6 +65,9 @@ class Cycle extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('cycle-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('cycle-get-state-error', { error });
         return;
@@ -75,7 +78,7 @@ class Cycle extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -95,15 +98,16 @@ class Cycle extends Activity {
     const streamData: StreamData = {
       metadata: {
         guid: guid(),
-        dad: CollatorService.resolveReentryDimension(this),
         jid: this.context.metadata.jid,
+        gid: this.context.metadata.gid,
+        dad: CollatorService.resolveReentryDimension(this),
         aid: this.config.ancestor,
         spn: this.context['$self'].output.metadata?.l1s,
         trc: this.context.metadata.trc,
       },
       data: this.context.data
     };
-    return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(null, streamData, multi)) as string;
   }
 }