@hotmeshio/hotmesh 0.25.1 → 0.25.2

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.25.1",
+    "version": "0.25.2",
     "description": "Durable Workflow",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",

package/build/services/activities/hook.js

@@ -496,7 +496,16 @@ class Hook extends activity_1.Activity {
     }
     async getHookRule(topic) {
         const rules = await this.store.getHookRules();
-        return rules?.[topic]?.[0];
+        const forTopic = rules?.[topic];
+        if (!forTopic?.length)
+            return undefined;
+        // A topic may carry one rule per waiter activity — the durable factory
+        // registers `waiter` and `signaler_waiter` on the same wait topic. Select
+        // the rule that targets THIS activity: the positional first rule addresses
+        // a sibling branch for every activity but its own, so its expected-pipe
+        // resolves against output that does not exist in this flow (which is how
+        // execHook-context waits were writing signal_key-less escalation rows).
+        return (forTopic.find((rule) => rule.to === this.metadata.aid) ?? forTopic[0]);
     }
     /**
      * Register the time hook (sleep) inside the Leg1 transaction.
@@ -654,10 +663,20 @@ class Hook extends activity_1.Activity {
         const store = this.store;
         if (typeof store.expireEscalationBySignalKey !== 'function')
             return;
+        // Hydration here is THROWAWAY. getState() REPLACES this.context with
+        // restored job state, which does not carry the per-message dimensional
+        // address (dad) — the stream message is its only carrier for this leg.
+        // processEvent must receive the pristine dispatch state (verifyReentry
+        // hydrates for itself, reading dad from context.metadata), so snapshot
+        // everything getState mutates — the context reference, metadata.dad,
+        // and leg — and restore them on every exit path. Without this, a wait
+        // executing below the root (any dimension) crashes Leg2 notarization.
+        const dispatchContext = this.context;
+        const dispatchDad = this.metadata.dad;
+        const dispatchLeg = this.leg;
         try {
-            // The TIMEHOOK dispatch context carries metadata only — hydrate job
-            // state so the signal-key pipe expression resolves to the same value
-            // Leg1 stored on the row.
+            // Hydrate job state so the signal-key pipe expression resolves to the
+            // same value Leg1 stored on the row.
             this.setLeg(2);
             await this.getState();
             const appId = this.engine.appId;
@@ -689,6 +708,11 @@ class Hook extends activity_1.Activity {
                 error: e.message,
             });
         }
+        finally {
+            this.context = dispatchContext;
+            this.metadata.dad = dispatchDad;
+            this.setLeg(dispatchLeg);
+        }
     }
 }
 exports.Hook = Hook;

package/build/services/durable/workflow/condition.d.ts

@@ -72,6 +72,15 @@ import { ConditionQueueConfig } from '../../../types/hmsh_escalations';
  * await client.escalations.resolve({ id: item.id, resolverPayload: { approved: true } });
  * ```
  *
+ * ## Placement: call escalation-bearing waits from main workflow code
+ *
+ * The resolve/signal delivery pipeline routes to the main flow's waiter.
+ * Inside a hook function (`execHook`), an escalation-bearing wait writes its
+ * row and honors `timeout` (the row expires and the hook resumes with
+ * `false`), while resolution delivery targets the main flow — so structure
+ * SLA-gated human waits in the workflow body and let hook functions report
+ * back via `signal()`.
+ *
  * ## Fan-in: wait for multiple signals in parallel
  *
  * ```typescript

package/build/services/durable/workflow/condition.js

@@ -77,6 +77,15 @@ const didRun_1 = require("./didRun");
  * await client.escalations.resolve({ id: item.id, resolverPayload: { approved: true } });
  * ```
  *
+ * ## Placement: call escalation-bearing waits from main workflow code
+ *
+ * The resolve/signal delivery pipeline routes to the main flow's waiter.
+ * Inside a hook function (`execHook`), an escalation-bearing wait writes its
+ * row and honors `timeout` (the row expires and the hook resumes with
+ * `false`), while resolution delivery targets the main flow — so structure
+ * SLA-gated human waits in the workflow body and let hook functions report
+ * back via `signal()`.
+ *
  * ## Fan-in: wait for multiple signals in parallel
  *
  * ```typescript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",