@hotmeshio/hotmesh 0.12.1 → 0.14.0

package/build/services/activities/activity/protocol.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLeg1StepProtocol = exports.executeStepProtocol = void 0;
+const collator_1 = require("../../collator");
+/**
+ * 3-step Leg2 protocol using GUID ledger for crash-safe resume.
+ * Each step bundles durable writes with its concluding digit
+ * update in a single transaction.
+ */
+async function executeStepProtocol(instance, delta, shouldFinalize) {
+    const msgGuid = instance.context.metadata.guid;
+    const threshold = instance.mapStatusThreshold();
+    const { id: appId } = await instance.engine.getVID();
+    //Step 1: Save work (skip if GUID 10B already set)
+    if (!collator_1.CollatorService.isGuidStep1Done(instance.guidLedger)) {
+        const txn1 = instance.store.transact();
+        await instance.setState(txn1);
+        await collator_1.CollatorService.notarizeStep1(instance, msgGuid, txn1);
+        await txn1.exec();
+    }
+    //Step 2: Spawn children + semaphore + edge capture
+    let thresholdHit = false;
+    if (!collator_1.CollatorService.isGuidStep2Done(instance.guidLedger)) {
+        const txn2 = instance.store.transact();
+        await collator_1.CollatorService.notarizeStep2(instance, msgGuid, txn2);
+        for (const child of instance.adjacencyList) {
+            await instance.engine.router?.publishMessage(null, child, txn2);
+        }
+        await instance.store.setStatusAndCollateGuid(delta, threshold, instance.context.metadata.jid, appId, msgGuid, collator_1.CollatorService.WEIGHTS.GUID_SNAPSHOT, txn2);
+        const results = (await txn2.exec());
+        thresholdHit = instance.resolveThresholdHit(results);
+        instance.logger.debug('step-protocol-step2-complete', {
+            jid: instance.context.metadata.jid,
+            aid: instance.metadata.aid,
+            delta,
+            threshold,
+            thresholdHit,
+            lastResult: results[results.length - 1],
+            resultCount: results.length,
+        });
+    }
+    else {
+        thresholdHit = collator_1.CollatorService.isGuidJobClosed(instance.guidLedger);
+    }
+    //Step 3: Job completion tasks
+    const isErrorTerminal = !thresholdHit &&
+        instance.context.data?.done === true &&
+        !!instance.context.data?.$error;
+    const needsCompletion = thresholdHit ||
+        instance.shouldEmit() ||
+        instance.shouldPersistJob() ||
+        isErrorTerminal;
+    if (needsCompletion &&
+        !collator_1.CollatorService.isGuidStep3Done(instance.guidLedger)) {
+        const txn3 = instance.store.transact();
+        const options = thresholdHit || isErrorTerminal
+            ? {}
+            : { emit: !instance.shouldPersistJob() };
+        await instance.engine.runJobCompletionTasks(instance.context, options, txn3);
+        await collator_1.CollatorService.notarizeStep3(instance, msgGuid, txn3);
+        const shouldFinalizeNow = thresholdHit || isErrorTerminal
+            ? shouldFinalize
+            : instance.shouldPersistJob();
+        if (shouldFinalizeNow) {
+            await collator_1.CollatorService.notarizeFinalize(instance, txn3);
+        }
+        await txn3.exec();
+    }
+    else if (needsCompletion) {
+        instance.logger.debug('step-protocol-step3-skipped-already-done', {
+            jid: instance.context.metadata.jid,
+            aid: instance.metadata.aid,
+        });
+    }
+    else {
+        instance.logger.debug('step-protocol-no-threshold', {
+            jid: instance.context.metadata.jid,
+            aid: instance.metadata.aid,
+            thresholdHit,
+        });
+    }
+    return thresholdHit;
+}
+exports.executeStepProtocol = executeStepProtocol;
+/**
+ * 3-step Leg1 protocol for Category B activities
+ * (Leg1-only with children: Hook passthrough, Signal, Interrupt-another).
+ *
+ * Step A: setState + Leg1 completion + step1 marker
+ * Step B: publish children + semaphore + edge capture
+ * Step C: if edge → completion tasks + finalize
+ */
+async function executeLeg1StepProtocol(instance, delta) {
+    const msgGuid = instance.context.metadata.guid;
+    const threshold = instance.mapStatusThreshold();
+    const { id: appId } = await instance.engine.getVID();
+    //Step A: Save work + Leg1 completion marker
+    if (!collator_1.CollatorService.isGuidStep1Done(instance.guidLedger)) {
+        const txn1 = instance.store.transact();
+        await instance.setState(txn1);
+        if (instance.adjacentIndex === 0) {
+            await collator_1.CollatorService.notarizeLeg1Completion(instance, txn1);
+        }
+        await collator_1.CollatorService.notarizeStep1(instance, msgGuid, txn1);
+        await txn1.exec();
+    }
+    //Step B: Spawn children + semaphore + edge capture
+    let thresholdHit = false;
+    if (!collator_1.CollatorService.isGuidStep2Done(instance.guidLedger)) {
+        const txn2 = instance.store.transact();
+        await collator_1.CollatorService.notarizeStep2(instance, msgGuid, txn2);
+        for (const child of instance.adjacencyList) {
+            await instance.engine.router?.publishMessage(null, child, txn2);
+        }
+        await instance.store.setStatusAndCollateGuid(delta, threshold, instance.context.metadata.jid, appId, msgGuid, collator_1.CollatorService.WEIGHTS.GUID_SNAPSHOT, txn2);
+        const results = (await txn2.exec());
+        thresholdHit = instance.resolveThresholdHit(results);
+        instance.logger.debug('leg1-step-protocol-stepB-complete', {
+            jid: instance.context.metadata.jid,
+            aid: instance.metadata.aid,
+            delta,
+            threshold,
+            thresholdHit,
+            lastResult: results[results.length - 1],
+        });
+    }
+    else {
+        thresholdHit = collator_1.CollatorService.isGuidJobClosed(instance.guidLedger);
+    }
+    //Step C: Job completion tasks
+    const isErrorTerminal = !thresholdHit &&
+        instance.context.data?.done === true &&
+        !!instance.context.data?.$error;
+    const needsCompletion = thresholdHit ||
+        instance.shouldEmit() ||
+        instance.shouldPersistJob() ||
+        isErrorTerminal;
+    if (needsCompletion &&
+        !collator_1.CollatorService.isGuidStep3Done(instance.guidLedger)) {
+        const txn3 = instance.store.transact();
+        const options = thresholdHit || isErrorTerminal
+            ? {}
+            : { emit: !instance.shouldPersistJob() };
+        await instance.engine.runJobCompletionTasks(instance.context, options, txn3);
+        await collator_1.CollatorService.notarizeStep3(instance, msgGuid, txn3);
+        await collator_1.CollatorService.notarizeFinalize(instance, txn3);
+        await txn3.exec();
+    }
+    return thresholdHit;
+}
+exports.executeLeg1StepProtocol = executeLeg1StepProtocol;

package/build/services/activities/activity/state.d.ts

@@ -0,0 +1,40 @@
+import { EngineService } from '../../engine';
+import { ILogger } from '../../logger';
+import { StoreService } from '../../store';
+import { ActivityData, ActivityLeg, ActivityMetadata, ActivityType } from '../../../types/activity';
+import { JobState } from '../../../types/job';
+import { ProviderClient, ProviderTransaction } from '../../../types/provider';
+import { StringAnyType } from '../../../types/serializer';
+import { StreamStatus } from '../../../types/stream';
+interface StateContext {
+    config: ActivityType;
+    context: JobState;
+    metadata: ActivityMetadata;
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    engine: EngineService;
+    logger: ILogger;
+    status: StreamStatus;
+    data: ActivityData;
+    leg: ActivityLeg;
+    getJobStatus(): number | null;
+    authorizeEntry(state: StringAnyType): string[];
+    resolveDad(): string;
+    getTriggerConfig(): Promise<ActivityType>;
+    bindJobMetadataPaths(): string[];
+    bindActivityMetadataPaths(): string[];
+    assertGenerationalId(jobGID: string, msgGID: string): void;
+    initDimensionalAddress(dad: string): void;
+    initSelf(context: StringAnyType): JobState;
+    initPolicies(context: JobState): void;
+}
+export declare function setState(instance: StateContext, transaction?: ProviderTransaction): Promise<string>;
+export declare function getState(instance: StateContext): Promise<void>;
+export declare function setStatus(instance: StateContext, amount: number, transaction?: ProviderTransaction): Promise<void | any>;
+export declare function bindJobMetadata(instance: StateContext): void;
+export declare function bindActivityMetadata(instance: StateContext): void;
+export declare function bindJobState(instance: StateContext, state: StringAnyType): Promise<void>;
+export declare function bindActivityState(instance: StateContext, state: StringAnyType): void;
+export declare function bindDimensionalAddress(instance: StateContext, state: StringAnyType): void;
+export declare function bindJobMetadataPaths(): string[];
+export declare function bindActivityMetadataPaths(leg: ActivityLeg): string[];
+export {};

package/build/services/activities/activity/state.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindActivityMetadataPaths = exports.bindJobMetadataPaths = exports.bindDimensionalAddress = exports.bindActivityState = exports.bindJobState = exports.bindActivityMetadata = exports.bindJobMetadata = exports.setStatus = exports.getState = exports.setState = void 0;
+const utils_1 = require("../../../modules/utils");
+const collator_1 = require("../../collator");
+const serializer_1 = require("../../serializer");
+const telemetry_1 = require("../../telemetry");
+const stream_1 = require("../../../types/stream");
+//─── persist full activity + job state ───────────────────────────────
+async function setState(instance, transaction) {
+    const jobId = instance.context.metadata.jid;
+    bindJobMetadata(instance);
+    bindActivityMetadata(instance);
+    const state = {};
+    await bindJobState(instance, state);
+    const presets = instance.authorizeEntry(state);
+    bindDimensionalAddress(instance, state);
+    bindActivityState(instance, state);
+    const symbolNames = [
+        `$${instance.config.subscribes}`,
+        instance.metadata.aid,
+        ...presets,
+    ];
+    const dIds = collator_1.CollatorService.getDimensionsById([...instance.config.ancestors, instance.metadata.aid], instance.resolveDad());
+    return await instance.store.setState(state, instance.getJobStatus(), jobId, symbolNames, dIds, transaction);
+}
+exports.setState = setState;
+//─── load state from store into context ──────────────────────────────
+async function getState(instance) {
+    const gid = instance.context.metadata.gid;
+    const jobSymbolHashName = `$${instance.config.subscribes}`;
+    const consumes = {
+        [jobSymbolHashName]: serializer_1.MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`),
+    };
+    for (let [activityId, paths] of Object.entries(instance.config.consumes)) {
+        if (activityId === '$job') {
+            for (const path of paths) {
+                consumes[jobSymbolHashName].push(path);
+            }
+        }
+        else {
+            if (activityId === '$self') {
+                activityId = instance.metadata.aid;
+            }
+            if (!consumes[activityId]) {
+                consumes[activityId] = [];
+            }
+            for (const path of paths) {
+                consumes[activityId].push(`${activityId}/${path}`);
+            }
+        }
+    }
+    telemetry_1.TelemetryService.addTargetTelemetryPaths(consumes, instance.config, instance.metadata, instance.leg);
+    const { dad, jid } = instance.context.metadata;
+    const dIds = collator_1.CollatorService.getDimensionsById([...instance.config.ancestors, instance.metadata.aid], dad || '');
+    const [state, _status] = await instance.store.getState(jid, consumes, dIds);
+    instance.context = (0, utils_1.restoreHierarchy)(state);
+    instance.assertGenerationalId(instance.context?.metadata?.gid, gid);
+    instance.initDimensionalAddress(dad);
+    instance.initSelf(instance.context);
+    instance.initPolicies(instance.context);
+}
+exports.getState = getState;
+//─── semaphore status update ─────────────────────────────────────────
+async function setStatus(instance, amount, transaction) {
+    const { id: appId } = await instance.engine.getVID();
+    return await instance.store.setStatus(amount, instance.context.metadata.jid, appId, transaction);
+}
+exports.setStatus = setStatus;
+//─── metadata binding ────────────────────────────────────────────────
+function bindJobMetadata(instance) {
+    instance.context.metadata.ju = (0, utils_1.formatISODate)(new Date());
+}
+exports.bindJobMetadata = bindJobMetadata;
+function bindActivityMetadata(instance) {
+    const self = instance.context['$self'];
+    if (!self.output.metadata) {
+        self.output.metadata = {};
+    }
+    if (instance.status === stream_1.StreamStatus.ERROR) {
+        self.output.metadata.err = JSON.stringify(instance.data);
+    }
+    const ts = (0, utils_1.formatISODate)(new Date());
+    self.output.metadata.ac = ts;
+    self.output.metadata.au = ts;
+    self.output.metadata.atp = instance.config.type;
+    if (instance.config.subtype) {
+        self.output.metadata.stp = instance.config.subtype;
+    }
+    self.output.metadata.aid = instance.metadata.aid;
+}
+exports.bindActivityMetadata = bindActivityMetadata;
+//─── state path resolution ───────────────────────────────────────────
+async function bindJobState(instance, state) {
+    const triggerConfig = await instance.getTriggerConfig();
+    const PRODUCES = [
+        ...(triggerConfig.PRODUCES || []),
+        ...instance.bindJobMetadataPaths(),
+    ];
+    for (const path of PRODUCES) {
+        const value = (0, utils_1.getValueByPath)(instance.context, path);
+        if (value !== undefined) {
+            state[path] = value;
+        }
+    }
+    for (const key in instance.context?.data ?? {}) {
+        if (key.startsWith('-') || key.startsWith('_')) {
+            state[key] = instance.context.data[key];
+        }
+    }
+    telemetry_1.TelemetryService.bindJobTelemetryToState(state, instance.config, instance.context);
+}
+exports.bindJobState = bindJobState;
+function bindActivityState(instance, state) {
+    const produces = [
+        ...instance.config.produces,
+        ...instance.bindActivityMetadataPaths(),
+    ];
+    for (const path of produces) {
+        const prefixedPath = `${instance.metadata.aid}/${path}`;
+        const value = (0, utils_1.getValueByPath)(instance.context, prefixedPath);
+        if (value !== undefined) {
+            state[prefixedPath] = value;
+        }
+    }
+    telemetry_1.TelemetryService.bindActivityTelemetryToState(state, instance.config, instance.metadata, instance.context, instance.leg);
+}
+exports.bindActivityState = bindActivityState;
+function bindDimensionalAddress(instance, state) {
+    const dad = instance.resolveDad();
+    state[`${instance.metadata.aid}/output/metadata/dad`] = dad;
+}
+exports.bindDimensionalAddress = bindDimensionalAddress;
+//─── default metadata path resolvers (overridden by Trigger) ─────────
+function bindJobMetadataPaths() {
+    return serializer_1.MDATA_SYMBOLS.JOB_UPDATE.KEYS.map((key) => `metadata/${key}`);
+}
+exports.bindJobMetadataPaths = bindJobMetadataPaths;
+function bindActivityMetadataPaths(leg) {
+    const keys_to_save = leg === 1 ? 'ACTIVITY' : 'ACTIVITY_UPDATE';
+    return serializer_1.MDATA_SYMBOLS[keys_to_save].KEYS.map((key) => `output/metadata/${key}`);
+}
+exports.bindActivityMetadataPaths = bindActivityMetadataPaths;

package/build/services/activities/activity/transition.d.ts

@@ -0,0 +1,23 @@
+import { EngineService } from '../../engine';
+import { StoreService } from '../../store';
+import { ActivityMetadata, ActivityType } from '../../../types/activity';
+import { JobState, JobStatus } from '../../../types/job';
+import { ProviderClient, ProviderTransaction, TransactionResultList } from '../../../types/provider';
+import { StreamCode, StreamData } from '../../../types/stream';
+interface TransitionContext {
+    config: ActivityType;
+    context: JobState;
+    metadata: ActivityMetadata;
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    engine: EngineService;
+    code: StreamCode;
+    resolveAdjacentDad(): string;
+}
+export declare function filterAdjacent(instance: TransitionContext): Promise<StreamData[]>;
+export declare function resolveThresholdHit(results: TransactionResultList): boolean;
+export declare function resolveStatus(multiResponse: TransactionResultList): number;
+export declare function shouldEmit(instance: TransitionContext): boolean;
+export declare function shouldPersistJob(instance: TransitionContext): boolean;
+export declare function isJobComplete(jobStatus: JobStatus): boolean;
+export declare function jobWasInterrupted(jobStatus: JobStatus): boolean;
+export {};

package/build/services/activities/activity/transition.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobWasInterrupted = exports.isJobComplete = exports.shouldPersistJob = exports.shouldEmit = exports.resolveStatus = exports.resolveThresholdHit = exports.filterAdjacent = void 0;
+const utils_1 = require("../../../modules/utils");
+const mapper_1 = require("../../mapper");
+const pipe_1 = require("../../pipe");
+const stream_1 = require("../../../types/stream");
+async function filterAdjacent(instance) {
+    const adjacencyList = [];
+    const transitions = await instance.store.getTransitions(await instance.engine.getVID());
+    const transition = transitions[`.${instance.metadata.aid}`];
+    const adjacentDad = instance.resolveAdjacentDad();
+    if (transition) {
+        for (const toActivityId in transition) {
+            const transitionRule = transition[toActivityId];
+            if (mapper_1.MapperService.evaluate(transitionRule, instance.context, instance.code)) {
+                adjacencyList.push({
+                    metadata: {
+                        guid: (0, utils_1.guid)(),
+                        jid: instance.context.metadata.jid,
+                        gid: instance.context.metadata.gid,
+                        dad: adjacentDad,
+                        aid: toActivityId,
+                        spn: instance.context['$self'].output.metadata?.l2s,
+                        trc: instance.context.metadata.trc,
+                    },
+                    type: stream_1.StreamDataType.TRANSITION,
+                    data: {},
+                });
+            }
+        }
+    }
+    return adjacencyList;
+}
+exports.filterAdjacent = filterAdjacent;
+function resolveThresholdHit(results) {
+    const last = results[results.length - 1];
+    const value = Array.isArray(last) ? last[1] : last;
+    return Number(value) === 1;
+}
+exports.resolveThresholdHit = resolveThresholdHit;
+function resolveStatus(multiResponse) {
+    const activityStatus = multiResponse[multiResponse.length - 1];
+    if (Array.isArray(activityStatus)) {
+        return Number(activityStatus[1]);
+    }
+    return Number(activityStatus);
+}
+exports.resolveStatus = resolveStatus;
+function shouldEmit(instance) {
+    if (instance.config.emit) {
+        return pipe_1.Pipe.resolve(instance.config.emit, instance.context) === true;
+    }
+    return false;
+}
+exports.shouldEmit = shouldEmit;
+function shouldPersistJob(instance) {
+    if (instance.config.persist !== undefined) {
+        return pipe_1.Pipe.resolve(instance.config.persist, instance.context) === true;
+    }
+    return false;
+}
+exports.shouldPersistJob = shouldPersistJob;
+function isJobComplete(jobStatus) {
+    return jobStatus <= 0;
+}
+exports.isJobComplete = isJobComplete;
+function jobWasInterrupted(jobStatus) {
+    return jobStatus < -100000000;
+}
+exports.jobWasInterrupted = jobWasInterrupted;

package/build/services/activities/activity/verify.d.ts

@@ -0,0 +1,22 @@
+import { EngineService } from '../../engine';
+import { StoreService } from '../../store';
+import { ActivityLeg, ActivityMetadata, ActivityType } from '../../../types/activity';
+import { ProviderClient, ProviderTransaction } from '../../../types/provider';
+import { JobState } from '../../../types/job';
+interface VerifyContext {
+    config: ActivityType;
+    context: JobState;
+    metadata: ActivityMetadata;
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    engine: EngineService;
+    adjacentIndex: number;
+    guidLedger: number;
+    setLeg(leg: ActivityLeg): void;
+    getState(): Promise<void>;
+    setStatus(amount: number, txn?: ProviderTransaction): Promise<void | any>;
+    mapStatusThreshold(): number;
+}
+export declare function verifyEntry(instance: VerifyContext): Promise<void>;
+export declare function verifyReentry(instance: VerifyContext): Promise<number>;
+export declare function verifyLeg1Entry(instance: VerifyContext): Promise<boolean>;
+export {};

package/build/services/activities/activity/verify.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyLeg1Entry = exports.verifyReentry = exports.verifyEntry = void 0;
+const errors_1 = require("../../../modules/errors");
+const collator_1 = require("../../collator");
+async function verifyEntry(instance) {
+    instance.setLeg(1);
+    await instance.getState();
+    const threshold = instance.mapStatusThreshold();
+    try {
+        collator_1.CollatorService.assertJobActive(instance.context.metadata.js, instance.context.metadata.jid, instance.metadata.aid, threshold);
+    }
+    catch (error) {
+        await collator_1.CollatorService.notarizeEntry(instance);
+        if (threshold > 0) {
+            if (instance.context.metadata.js <= threshold) {
+                const status = await instance.setStatus(-threshold);
+                if (Number(status) === 0) {
+                    const txn = instance.store.transact();
+                    await instance.engine.runJobCompletionTasks(instance.context, {}, txn);
+                    await txn.exec();
+                }
+            }
+        }
+        else {
+            throw error;
+        }
+        return;
+    }
+    await collator_1.CollatorService.notarizeEntry(instance);
+}
+exports.verifyEntry = verifyEntry;
+async function verifyReentry(instance) {
+    const msgGuid = instance.context.metadata.guid;
+    instance.setLeg(2);
+    await instance.getState();
+    instance.context.metadata.guid = msgGuid;
+    collator_1.CollatorService.assertJobActive(instance.context.metadata.js, instance.context.metadata.jid, instance.metadata.aid);
+    const [activityLedger, guidLedger] = await collator_1.CollatorService.notarizeLeg2Entry(instance, msgGuid);
+    instance.guidLedger = guidLedger;
+    return activityLedger;
+}
+exports.verifyReentry = verifyReentry;
+async function verifyLeg1Entry(instance) {
+    const msgGuid = instance.context.metadata.guid;
+    instance.setLeg(1);
+    await instance.getState();
+    instance.context.metadata.guid = msgGuid;
+    const threshold = instance.mapStatusThreshold();
+    try {
+        collator_1.CollatorService.assertJobActive(instance.context.metadata.js, instance.context.metadata.jid, instance.metadata.aid, threshold);
+    }
+    catch (error) {
+        if (error instanceof errors_1.InactiveJobError && threshold > 0) {
+            await collator_1.CollatorService.notarizeEntry(instance);
+            if (instance.context.metadata.js === threshold) {
+                const status = await instance.setStatus(-threshold);
+                if (Number(status) === 0) {
+                    await instance.engine.runJobCompletionTasks(instance.context);
+                }
+            }
+        }
+        throw error;
+    }
+    try {
+        await collator_1.CollatorService.notarizeEntry(instance);
+        return false;
+    }
+    catch (error) {
+        if (error instanceof errors_1.CollationError && error.fault === 'duplicate') {
+            if (instance.config.cycle) {
+                const [activityLedger, guidLedger] = await collator_1.CollatorService.notarizeLeg2Entry(instance, msgGuid);
+                instance.adjacentIndex =
+                    collator_1.CollatorService.getDimensionalIndex(activityLedger);
+                instance.guidLedger = guidLedger;
+                return false;
+            }
+            const guidValue = await instance.store.collateSynthetic(instance.context.metadata.jid, msgGuid, 0);
+            instance.guidLedger = guidValue;
+            return true;
+        }
+        throw error;
+    }
+}
+exports.verifyLeg1Entry = verifyLeg1Entry;

package/build/services/activities/await.d.ts

@@ -1,7 +1,5 @@
-import { EngineService } from '../engine';
-import { ActivityData, ActivityMetadata, AwaitActivity, ActivityType } from '../../types/activity';
+import { AwaitActivity } from '../../types/activity';
 import { ProviderTransaction } from '../../types/provider';
-import { JobState } from '../../types/job';
 import { Activity } from './activity';
 /**
  * Invokes another graph (sub-flow) and optionally waits for its completion.
@@ -106,7 +104,6 @@ import { Activity } from './activity';
  */
 declare class Await extends Activity {
     config: AwaitActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
     execActivity(transaction: ProviderTransaction): Promise<string>;
 }

package/build/services/activities/await.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Await = void 0;
-const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const collator_1 = require("../collator");
 const pipe_1 = require("../pipe");
@@ -110,10 +109,6 @@ const activity_1 = require("./activity");
  * @see {@link AwaitActivity} for the TypeScript interface
  */
 class Await extends activity_1.Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        super(config, data, metadata, hook, engine, context);
-    }
-    //********  INITIAL ENTRY POINT (A)  ********//
     async process() {
         this.logger.debug('await-process', {
             jid: this.context.metadata.jid,
@@ -126,15 +121,12 @@ class Await extends activity_1.Activity {
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
-            //save state and mark Leg1 complete
             const transaction = this.store.transact();
-            //todo: await this.registerTimeout();
             const messageId = await this.execActivity(transaction);
             await collator_1.CollatorService.notarizeLeg1Completion(this, transaction);
             await this.setState(transaction);
             await this.setStatus(0, transaction);
             const multiResponse = (await transaction.exec());
-            //telemetry
             telemetry.mapActivityAttributes();
             const jobStatus = this.resolveStatus(multiResponse);
             telemetry.setActivityAttributes({
@@ -144,34 +136,8 @@ class Await extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            if (error instanceof errors_1.InactiveJobError) {
-                this.logger.error('await-inactive-job-error', { error });
-                return;
-            }
-            else if (error instanceof errors_1.GenerationalError) {
-                this.logger.info('process-event-generational-job-error', { error });
-                return;
-            }
-            else if (error instanceof errors_1.GetStateError) {
-                this.logger.error('await-get-state-error', { error });
-                return;
-            }
-            else if (error instanceof errors_1.CollationError) {
-                if (error.fault === 'duplicate') {
-                    this.logger.info('await-collation-overage', {
-                        job_id: this.context.metadata.jid,
-                        guid: this.context.metadata.guid,
-                    });
-                    return;
-                }
-                //unknown collation error
-                this.logger.error('await-collation-error', { error });
-            }
-            else {
-                this.logger.error('await-process-error', { error });
-            }
-            telemetry?.setActivityError(error.message);
-            throw error;
+            this.handleProcessError(error, telemetry, 'await');
+            return;
         }
         finally {
             telemetry?.endActivitySpan();

package/build/services/activities/cycle.d.ts

@@ -1,7 +1,5 @@
-import { EngineService } from '../engine';
-import { ActivityData, ActivityMetadata, ActivityType, CycleActivity } from '../../types/activity';
+import { CycleActivity } from '../../types/activity';
 import { ProviderTransaction } from '../../types/provider';
-import { JobState } from '../../types/job';
 import { Activity } from './activity';
 /**
  * Re-executes an ancestor activity in a new dimensional thread, enabling
@@ -87,15 +85,7 @@ import { Activity } from './activity';
  */
 declare class Cycle extends Activity {
     config: CycleActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
-    /**
-     * Trigger the target ancestor to execute in a cycle,
-     * without violating the constraints of the DAG. Immutable
-     * `individual activity state` will execute in a new dimensional
-     * thread while `shared job state` can change. This
-     * pattern allows for retries without violating the DAG.
-     */
     cycleAncestorActivity(transaction: ProviderTransaction): Promise<string>;
 }
 export { Cycle };