@hotmeshio/hotmesh 0.7.0 → 0.9.0

package/build/services/collator/index.js

@@ -42,85 +42,158 @@ class CollatorService {
         dimensions.push('0');
         return dimensions.join(',');
     }
+    // ──────────────────────────────────────────────────
+    //  Leg1 notarization
+    // ──────────────────────────────────────────────────
+    /**
+     * Leg1 entry: increment attempt counter (+1T).
+     * NOT bundled with Leg1 work — exists only to mark entry.
+     */
     static async notarizeEntry(activity, transaction) {
-        //decrement by -100_000_000_000_000
-        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100000000000000, this.getDimensionalAddress(activity), transaction);
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, this.WEIGHTS.LEG1_ENTRY, this.getDimensionalAddress(activity), transaction);
         this.verifyInteger(amount, 1, 'enter');
         return amount;
     }
-    static async authorizeReentry(activity, transaction) {
-        //set second digit to 8, allowing for re-entry
-        //decrement by -10_000_000_000_000
-        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10000000000000, this.getDimensionalAddress(activity), transaction);
-        return amount;
+    /**
+     * Leg1 completion: increment +100B to mark Leg1 complete.
+     * For cycle=true activities, also pre-seeds the Leg2 entry counter (+1)
+     * so the first real Leg2 gets adjacentIndex=1 (new dimension).
+     * MUST be bundled in the same transaction as Leg1 durable work.
+     */
+    static async notarizeLeg1Completion(activity, transaction) {
+        const amount = activity.config.cycle
+            ? this.WEIGHTS.LEG1_COMPLETE + this.WEIGHTS.LEG2_ENTRY
+            : this.WEIGHTS.LEG1_COMPLETE;
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, amount, this.getDimensionalAddress(activity), transaction);
     }
+    /**
+     * Leg1 early exit: marks Leg1 complete for activities that
+     * only run Leg1 and fully close (e.g., Cycle).
+     * Increment +100B (Leg1 completion marker).
+     */
     static async notarizeEarlyExit(activity, transaction) {
-        //decrement the 2nd and 3rd digits to fully deactivate (`cycle` activities use this command to fully exit after leg 1) (should result in `888000000000000`)
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -11000000000000, this.getDimensionalAddress(activity), transaction);
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, this.WEIGHTS.LEG1_COMPLETE, this.getDimensionalAddress(activity), transaction);
     }
+    /**
+     * Leg1 early completion: marks Leg1 complete for Leg1-only
+     * activities that spawn children (e.g., Signal, Hook passthrough,
+     * Interrupt-another). Increment +100B.
+     */
     static async notarizeEarlyCompletion(activity, transaction) {
-        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd
-        //3rd digit is optionally kept open if the activity might be used in a cycle
-        const decrement = activity.config.cycle
-            ? 10000000000000
-            : 11000000000000;
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - decrement, this.getDimensionalAddress(activity), transaction);
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, this.WEIGHTS.LEG1_COMPLETE, this.getDimensionalAddress(activity), transaction);
     }
+    // ──────────────────────────────────────────────────
+    //  Leg2 notarization (entry + 3-step protocol)
+    // ──────────────────────────────────────────────────
     /**
-     * sets the synthetic inception key (in case of an overage occurs).
+     * Leg2 entry: atomically increments the activity ledger (+1) and
+     * seeds the GUID ledger with the ordinal IF NOT EXISTS.
+     * Returns [activityLedger, guidLedger] after the compound operation.
      */
-    static async notarizeInception(activity, guid, transaction) {
-        if (guid) {
-            await activity.store.collateSynthetic(activity.context.metadata.jid, guid, 1000000, transaction);
-        }
+    static async notarizeLeg2Entry(activity, guid, transaction) {
+        const jid = activity.context.metadata.jid;
+        const localMulti = transaction || activity.store.transact();
+        //compound: increment activity Leg2 counter and seed GUID ledger
+        await activity.store.collateLeg2Entry(jid, activity.metadata.aid, guid, this.getDimensionalAddress(activity, true), localMulti);
+        const results = await localMulti.exec();
+        const result = results[0];
+        const [amountConcrete, amountSynthetic] = Array.isArray(result)
+            ? result
+            : [result, result];
+        this.verifyInteger(amountConcrete, 2, 'enter');
+        this.verifySyntheticInteger(amountSynthetic);
+        return [amountConcrete, amountSynthetic];
     }
     /**
-     * ignore those ID collisions that are due to re-entry overages
+     * Step 1: Mark Leg2 work done (+10B on GUID ledger only).
+     * MUST be bundled with Leg2 durable work writes.
      */
-    static async isInceptionOverage(activity, guid) {
-        if (guid) {
-            const amount = await activity.store.collateSynthetic(activity.context.metadata.jid, guid, 1000000);
-            return amount > 1000000;
-        }
-        return false;
+    static async notarizeStep1(activity, guid, transaction) {
+        const jid = activity.context.metadata.jid;
+        await activity.store.collateSynthetic(jid, guid, this.WEIGHTS.STEP1_WORK, transaction);
     }
     /**
-     * verifies both the concrete and synthetic keys for the activity; concrete keys
-     * exist in the original model and are effectively the 'real' keys. In reality,
-     * hook activities are atomized during compilation to create a synthetic DAG that
-     * is used to track the status of the graph in a distributed environment. The
-     * synthetic key represents different dimensional realities and is used to
-     * track re-entry overages (it distinguishes between the original and re-entry).
-     * The essential challenge is: is this a re-entry that is purposeful in
-     * order to induce cycles, or is the re-entry due to a failure in the system?
+     * Step 2: Mark children spawned (+1B on GUID ledger only).
+     * The job semaphore update and GUID job-closed snapshot are handled
+     * by the compound `setStatusAndCollateGuid` primitive, which MUST
+     * be called in the same transaction.
      */
-    static async notarizeReentry(activity, guid, transaction) {
+    static async notarizeStep2(activity, guid, transaction) {
         const jid = activity.context.metadata.jid;
-        const localMulti = transaction || activity.store.transact();
-        //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
-        await activity.store.collate(jid, activity.metadata.aid, 1000000, this.getDimensionalAddress(activity, true), localMulti);
-        await activity.store.collateSynthetic(jid, guid, 1000000, localMulti);
-        const [_amountConcrete, _amountSynthetic] = await localMulti.exec();
-        const amountConcrete = Array.isArray(_amountConcrete)
-            ? _amountConcrete[1]
-            : _amountConcrete;
-        const amountSynthetic = Array.isArray(_amountSynthetic)
-            ? _amountSynthetic[1]
-            : _amountSynthetic;
-        this.verifyInteger(amountConcrete, 2, 'enter');
-        this.verifySyntheticInteger(amountSynthetic);
-        return amountConcrete;
+        await activity.store.collateSynthetic(jid, guid, this.WEIGHTS.STEP2_SPAWN, transaction);
     }
-    static async notarizeContinuation(activity, transaction) {
-        //keep open; actualize the leg2 dimension (+1)
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1, this.getDimensionalAddress(activity), transaction);
+    /**
+     * Step 3: Mark job completion tasks done (+100M on GUID ledger only).
+     * MUST be bundled with job completion durable writes.
+     */
+    static async notarizeStep3(activity, guid, transaction) {
+        const jid = activity.context.metadata.jid;
+        await activity.store.collateSynthetic(jid, guid, this.WEIGHTS.STEP3_CLEANUP, transaction);
     }
-    static async notarizeCompletion(activity, transaction) {
-        //1) ALWAYS actualize leg2 dimension (+1)
-        //2) IF the activity is used in a cycle, don't close leg 2!
-        const decrement = activity.config.cycle ? 0 : 1000000000000;
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), transaction);
+    /**
+     * Finalize: close the activity to new Leg2 GUIDs (+200T).
+     * Sets pos 1 to 2 (finalized).
+     * Only for non-cycle activities after final SUCCESS/ERROR.
+     */
+    static async notarizeFinalize(activity, transaction) {
+        if (!activity.config.cycle) {
+            await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, this.WEIGHTS.FINALIZE, this.getDimensionalAddress(activity), transaction);
+        }
     }
+    // ──────────────────────────────────────────────────
+    //  GUID ledger extraction (step-level resume)
+    // ──────────────────────────────────────────────────
+    /**
+     * Check if Step 1 (work done) is complete on the GUID ledger.
+     * Position 5 (10B digit) > 0.
+     */
+    static isGuidStep1Done(guidLedger) {
+        return this.getDigitAtPosition(guidLedger, 5) > 0;
+    }
+    /**
+     * Check if Step 2 (children spawned) is complete on the GUID ledger.
+     * Position 6 (1B digit) > 0.
+     */
+    static isGuidStep2Done(guidLedger) {
+        return this.getDigitAtPosition(guidLedger, 6) > 0;
+    }
+    /**
+     * Check if Step 3 (job completion tasks) is complete on the GUID ledger.
+     * Position 7 (100M digit) > 0.
+     */
+    static isGuidStep3Done(guidLedger) {
+        return this.getDigitAtPosition(guidLedger, 7) > 0;
+    }
+    /**
+     * Check if this GUID was responsible for closing the job.
+     * Position 4 (100B digit) > 0 (job closed snapshot).
+     */
+    static isGuidJobClosed(guidLedger) {
+        return this.getDigitAtPosition(guidLedger, 4) > 0;
+    }
+    /**
+     * Get the attempt count from the GUID ledger (last 8 digits).
+     */
+    static getGuidAttemptCount(guidLedger) {
+        return guidLedger % 100000000;
+    }
+    // ──────────────────────────────────────────────────
+    //  Digit extraction
+    // ──────────────────────────────────────────────────
+    /**
+     * Gets the digit at a 1-indexed position from a 15-digit ledger value.
+     * The value is left-padded to 15 digits before extraction.
+     */
+    static getDigitAtPosition(num, position) {
+        const numStr = num.toString().padStart(this.targetLength, '0');
+        if (position < 1 || position > this.targetLength) {
+            return 0;
+        }
+        return parseInt(numStr[position - 1], 10);
+    }
+    /**
+     * @deprecated Use getDigitAtPosition (1-indexed) instead
+     */
     static getDigitAtIndex(num, targetDigitIndex) {
         const numStr = num.toString();
         if (targetDigitIndex < 0 || targetDigitIndex >= numStr.length) {
@@ -129,77 +202,79 @@ class CollatorService {
         const digit = parseInt(numStr[targetDigitIndex], 10);
         return digit;
     }
+    /**
+     * Extracts the dimensional index from the Leg2 entry counter.
+     * Non-cycle activities: first Leg2 → leg2Count=1 → 1-1=0 (same dimension as Leg1).
+     * Cycle activities: first Leg2 → leg2Count=2 (pre-seeded +1) → 2-1=1 (new dimension).
+     */
     static getDimensionalIndex(num) {
-        const numStr = num.toString();
-        if (numStr.length < 9) {
+        const leg2EntryCount = num % 100000000;
+        if (leg2EntryCount <= 0) {
             return null;
         }
-        const extractedStr = numStr.substring(3, 9);
-        const extractedInt = parseInt(extractedStr, 10);
-        return extractedInt - 1;
-    }
-    static isDuplicate(num, targetDigitIndex) {
-        return this.getDigitAtIndex(num, targetDigitIndex) < 8;
-    }
-    static isInactive(num) {
-        return this.getDigitAtIndex(num, 2) < 9;
-    }
-    static isPrimed(amount, leg) {
-        //activity entry is not allowed if paths not properly pre-set
-        if (leg == 1) {
-            return amount != -100000000000000;
-        }
-        else {
-            return (this.getDigitAtIndex(amount, 0) < 9 &&
-                this.getDigitAtIndex(amount, 1) < 9);
-        }
+        return leg2EntryCount - 1;
     }
+    // ──────────────────────────────────────────────────
+    //  Verification
+    // ──────────────────────────────────────────────────
     /**
-     * During compilation, the graphs are compiled into structures necessary
-     * for distributed processing; these are referred to as 'synthetic DAGs',
-     * because they are not part of the original graph, but are used to track
-     * the status of the graph in a distributed environment. This check ensures
-     * that the 'synthetic key' is not a duplicate. (which is different than
-     * saying the 'key' is not a duplicate)
+     * Verifies the GUID ledger value for step-level resume decisions.
+     * The GUID ledger is seeded with an ordinal position (last 8 digits)
+     * on first entry; step markers drive all resume/reject logic.
+     *
+     * Fully processed: Step 3 done, or Steps 1+2 done without job closure.
+     * Crash recovery: Any incomplete step combination is allowed for resume.
      */
     static verifySyntheticInteger(amount) {
-        const samount = amount.toString();
-        const isCompletedValue = parseInt(samount[samount.length - 1], 10);
-        if (isCompletedValue > 0) {
-            //already done error (ack/delete clearly failed; this is a duplicate)
+        const step2Done = this.isGuidStep2Done(amount);
+        const step3Done = this.isGuidStep3Done(amount);
+        const jobClosed = this.isGuidJobClosed(amount);
+        if (step3Done) {
+            //all steps complete; nothing more to do
             throw new errors_1.CollationError(amount, 2, 'enter', collator_1.CollationFaultType.INACTIVE);
         }
-        else if (amount >= 2000000) {
-            //duplicate synthetic key (this is a duplicate job ID)
-            throw new errors_1.CollationError(amount, 2, 'enter', collator_1.CollationFaultType.DUPLICATE);
+        if (step2Done && !jobClosed) {
+            //steps 1+2 done but this GUID didn't close the job; no Step 3 needed
+            throw new errors_1.CollationError(amount, 2, 'enter', collator_1.CollationFaultType.INACTIVE);
         }
+        //all other cases: allow entry
+        // - no steps done (fresh entry or pre-step-1 crash recovery)
+        // - step 1 done, step 2 not (crash after step 1)
+        // - steps 1+2 done, job closed, step 3 not (crash recovery for step 3)
     }
+    /**
+     * Verifies the activity ledger value at entry boundaries.
+     *
+     * Leg1 enter: pos 3 (1T digit) must be > 0 after +1T (proves seed exists).
+     *             pos 4 (100B) must be 0 (Leg1 not yet complete).
+     *             If pos 3 > 1 and pos 4 == 1, it's a stale/replayed message.
+     *
+     * Leg2 enter: pos 4 (100B) must be > 0 (Leg1 complete, reentry authorized).
+     *             pos 1 (100T) must be < 2 (not finalized) — cycle activities exempt.
+     */
     static verifyInteger(amount, leg, stage) {
         let faultType;
         if (leg === 1 && stage === 'enter') {
-            if (!this.isPrimed(amount, 1)) {
+            const leg1Attempts = this.getDigitAtPosition(amount, 3);
+            const leg1Complete = this.getDigitAtPosition(amount, 4);
+            if (leg1Attempts === 0) {
+                //seed was not set (no authorization)
                 faultType = collator_1.CollationFaultType.MISSING;
             }
-            else if (this.isDuplicate(amount, 0)) {
-                faultType = collator_1.CollationFaultType.DUPLICATE;
-            }
-            else if (amount != 899000000000000) {
-                faultType = collator_1.CollationFaultType.INVALID;
-            }
-        }
-        else if (leg === 1 && stage === 'exit') {
-            if (amount === -10000000000000) {
-                faultType = collator_1.CollationFaultType.MISSING;
-            }
-            else if (this.isDuplicate(amount, 1)) {
+            else if (leg1Complete > 0) {
+                //Leg1 already completed — stale/replayed message
                 faultType = collator_1.CollationFaultType.DUPLICATE;
             }
         }
         else if (leg === 2 && stage === 'enter') {
-            if (!this.isPrimed(amount, 2)) {
+            const leg1Complete = this.getDigitAtPosition(amount, 4);
+            const finalized = this.getDigitAtPosition(amount, 1);
+            if (leg1Complete === 0) {
+                //Leg1 not complete — reentry not authorized
                 faultType = collator_1.CollationFaultType.FORBIDDEN;
             }
-            else if (this.isInactive(amount)) {
+            else if (finalized >= 2) {
+                //activity finalized (pos 1 = 2) — no new Leg2 GUIDs accepted
                 faultType = collator_1.CollationFaultType.INACTIVE;
             }
         }
@@ -207,6 +282,9 @@ class CollatorService {
             throw new errors_1.CollationError(amount, leg, stage, faultType);
         }
     }
+    // ──────────────────────────────────────────────────
+    //  Dimensional address resolution
+    // ──────────────────────────────────────────────────
     static getDimensionsById(ancestors, dad) {
         //ancestors is an ordered list of all ancestors, starting with the trigger (['t1', 'a1', 'a2'])
         //dad is the dimensional address of the ancestors list (',0,5,3')
@@ -221,18 +299,19 @@ class CollatorService {
         });
         return map;
     }
+    // ──────────────────────────────────────────────────
+    //  Seeds
+    // ──────────────────────────────────────────────────
     /**
-     * All non-trigger activities are assigned a status seed by their parent
-     */
-    static getSeed() {
-        return '999000000000000';
-    }
-    /**
-     * All trigger activities are assigned a status seed in a completed state
+     * All trigger activities are assigned a status seed in a completed state.
+     * Seed: 101100000000001 (authorized, 1 Leg1 entry, Leg1 complete, 1 Leg2 entry)
      */
     static getTriggerSeed() {
-        return '888000001000001';
+        return '101100000000001';
     }
+    // ──────────────────────────────────────────────────
+    //  Compiler
+    // ──────────────────────────────────────────────────
     /**
      * entry point for compiler-type activities. This is called by the compiler
      * to bind the sorted activity IDs to the trigger activity. These are then used
@@ -291,3 +370,20 @@ class CollatorService {
 exports.CollatorService = CollatorService;
 //max int digit count that supports `hincrby`
 CollatorService.targetLength = 15;
+/**
+ * Positional weights for the 15-digit activity/GUID ledger.
+ *
+ * Position:  1     2     3    4      5     6    7      8-15
+ * Weight:   100T  10T   1T   100B   10B   1B   100M   10M..1
+ */
+CollatorService.WEIGHTS = {
+    AUTH: 100000000000000,
+    FINALIZE: 200000000000000,
+    LEG1_ENTRY: 1000000000000,
+    LEG1_COMPLETE: 100000000000,
+    STEP1_WORK: 10000000000,
+    STEP2_SPAWN: 1000000000,
+    STEP3_CLEANUP: 100000000,
+    LEG2_ENTRY: 1,
+    GUID_SNAPSHOT: 100000000000, // 100B on GUID ledger (job closed snapshot)
+};

package/build/services/connector/factory.d.ts

@@ -3,7 +3,7 @@ import { ProviderConfig, ProviderNativeClient } from '../../types/provider';
 export declare class ConnectorService {
     static disconnectAll(): Promise<void>;
     /**
-     * Connect to a provider (redis, nats, postgres) and return the native
+     * Connect to a provider (nats, postgres) and return the native
      * client. Connections are handled by the engine and worker routers at
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.

package/build/services/connector/factory.js

@@ -2,19 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorService = void 0;
 const utils_1 = require("../../modules/utils");
-const ioredis_1 = require("./providers/ioredis");
 const nats_1 = require("./providers/nats");
 const postgres_1 = require("./providers/postgres");
-const redis_1 = require("./providers/redis");
 class ConnectorService {
     static async disconnectAll() {
-        await redis_1.RedisConnection.disconnectAll();
-        await ioredis_1.RedisConnection.disconnectAll();
         await postgres_1.PostgresConnection.disconnectAll();
         await nats_1.NatsConnection.disconnectAll();
     }
     /**
-     * Connect to a provider (redis, nats, postgres) and return the native
+     * Connect to a provider (nats, postgres) and return the native
      * client. Connections are handled by the engine and worker routers at
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.
@@ -81,12 +77,6 @@ class ConnectorService {
         let clientInstance;
         const id = (0, utils_1.guid)();
         switch (providerType) {
-            case 'redis':
-                clientInstance = await redis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
-                break;
-            case 'ioredis':
-                clientInstance = await ioredis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
-                break;
             case 'nats':
                 clientInstance = await nats_1.NatsConnection.connect(id, providerClass, options, { provider: providerName });
                 break;

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

@@ -31,11 +31,17 @@ declare class EngineService {
     appId: string;
     guid: string;
     exporter: ExporterService | null;
+    /** @hidden */
     search: SearchService<ProviderClient> | null;
+    /** @hidden */
     store: StoreService<ProviderClient, ProviderTransaction> | null;
+    /** @hidden */
     stream: StreamService<ProviderClient, ProviderTransaction> | null;
+    /** @hidden */
     subscribe: SubService<ProviderClient> | null;
+    /** @hidden */
     router: Router<typeof this.stream> | null;
+    /** @hidden */
     taskService: TaskService | null;
     logger: ILogger;
     cacheMode: CacheMode;
@@ -143,7 +149,7 @@ declare class EngineService {
     /**
      * @private
      */
-    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<string>;
+    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<string>;
     /**
      * @private
      */
@@ -161,17 +167,27 @@ declare class EngineService {
      */
     scrub(jobId: string): Promise<void>;
     /**
+     * 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
      */
-    hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
+    signal(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode, transaction?: ProviderTransaction): Promise<string>;
     /**
      * @private
      */
     hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
     /**
+     * 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.
+     *
      * @private
      */
-    hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
+    signalAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     /**
      * @private
      */
@@ -199,7 +215,7 @@ declare class EngineService {
     /**
      * @private
      */
-    pubOneTimeSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    pubOneTimeSubs(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<void>;
     /**
      * @private
      */
@@ -207,7 +223,7 @@ declare class EngineService {
     /**
      * @private
      */
-    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<void>;
     /**
      * @private
      */
@@ -227,7 +243,7 @@ declare class EngineService {
     /**
      * @private
      */
-    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions): Promise<string | void>;
+    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions, transaction?: ProviderTransaction): Promise<string | void>;
     /**
      * Job hash expiration is typically reliant on the metadata field
      * if the activity concludes normally. However, if the job is `interrupted`,