@hotmeshio/hotmesh 0.14.7 → 0.14.8

package/build/package.json

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

package/build/services/activities/worker.js

@@ -181,6 +181,20 @@ class Worker extends activity_1.Activity {
                 retry: this.config.retry,
             };
         }
+        // Propagate per-activity retry config as _streamRetryConfig so
+        // the engine-level retry mechanism uses it for exponential backoff.
+        // The durable module's maximumAttempts means max retries
+        // (total executions = 1 + maximumAttempts), while the engine's
+        // max_retry_attempts means total attempts. Add 1 to align.
+        if (jobData?.maximumAttempts || jobData?.backoffCoefficient || jobData?.maximumInterval || jobData?.initialInterval) {
+            const durableMaxAttempts = jobData.maximumAttempts ?? 50;
+            streamData._streamRetryConfig = {
+                max_retry_attempts: durableMaxAttempts + 1,
+                backoff_coefficient: jobData.backoffCoefficient ?? 10,
+                maximum_interval_seconds: jobData.maximumInterval ?? 120,
+                initialInterval: jobData.initialInterval ?? 1,
+            };
+        }
         return (await this.engine.router?.publishMessage(topic, streamData, transaction));
     }
 }

package/build/services/durable/exporter.js

@@ -474,10 +474,10 @@ class ExporterService {
         const activityArgsField = this.resolveSymbolField(symbolSets, 'activity_trigger', 'activity_trigger/output/data/arguments');
         const workflowArgsField = this.resolveSymbolField(symbolSets, 'trigger', 'trigger/output/data/arguments');
         // ── 1. Enrich activity inputs ──
-        if (activityArgsField) {
+        {
             const activityEvents = execution.events.filter((e) => e.event_type === 'activity_task_scheduled' || e.event_type === 'activity_task_completed' || e.event_type === 'activity_task_failed');
             if (activityEvents.length > 0) {
-                const { byJobId, byNameIndex } = await this.store.getActivityInputs(workflowId, activityArgsField);
+                const { byJobId, byNameIndex } = await this.store.getActivityInputs(workflowId, activityArgsField || '');
                 for (const evt of activityEvents) {
                     const attrs = evt.attributes;
                     let input = attrs.timeline_key ? byJobId.get(attrs.timeline_key) : undefined;

package/build/services/durable/schemas/factory.d.ts

@@ -1,22 +1,4 @@
-/**
- *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model a durable workflow engine using a pluggable backend.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
-declare const APP_VERSION = "11";
+declare const APP_VERSION = "12";
 declare const APP_ID = "durable";
 /**
  * returns a new durable workflow schema

package/build/services/durable/schemas/factory.js

@@ -1,25 +1,7 @@
 "use strict";
-/**
- *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model a durable workflow engine using a pluggable backend.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
-const APP_VERSION = '11';
+const APP_VERSION = '12';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
@@ -153,12 +135,10 @@ const getWorkflowYAML = (app, version) => {
                   type: number
             maps:
               retryCount: 0
-              throttleSeconds: 0
 
         throttler:
-          title: Pauses for an exponentially-throttled amount of time after a retryable error or passes through immediately
+          title: Pass-through hook between cycle_hook and worker
           type: hook
-          sleep: '{cycle_hook.output.data.throttleSeconds}'
 
         worker:
           title: Main Worker - Calls linked Workflow functions
@@ -202,6 +182,22 @@ const getWorkflowYAML = (app, version) => {
                     - ['{trigger.output.data.maximumAttempts}', 5]
                     - ['{@conditional.nullish}']
                   - ['{@conditional.less_than}']
+              maximumAttempts:
+                '@pipe':
+                  - ['{trigger.output.data.maximumAttempts}', 5]
+                  - ['{@conditional.nullish}']
+              backoffCoefficient:
+                '@pipe':
+                  - ['{trigger.output.data.backoffCoefficient}', 10]
+                  - ['{@conditional.nullish}']
+              maximumInterval:
+                '@pipe':
+                  - ['{trigger.output.data.maximumInterval}', 120]
+                  - ['{@conditional.nullish}']
+              initialInterval:
+                '@pipe':
+                  - ['{trigger.output.data.initialInterval}', 1]
+                  - ['{@conditional.nullish}']
           output:
             schema:
               type: object
@@ -364,7 +360,6 @@ const getWorkflowYAML = (app, version) => {
           input:
             maps:
               retryCount: 0
-              throttleSeconds: 0
               continueGeneration: '{cycle_hook.output.data.continueGeneration}'
               continueArgs: '{cycle_hook.output.data.continueArgs}'
 
@@ -540,38 +535,13 @@ const getWorkflowYAML = (app, version) => {
                   - '@pipe':
                     - [0]
                   - ['{@conditional.ternary}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - ['{childer.output.metadata.err}']
-                  - '@pipe':
-                    - '@pipe':
-                      - '@pipe':
-                        - '@pipe':
-                          - ['{trigger.output.data.backoffCoefficient}', 10]
-                          - ['{@conditional.nullish}']
-                        - '@pipe':
-                          - ['{cycle_hook.output.data.retryCount}', 0]
-                          - ['{@conditional.nullish}']
-                        - ['{@math.pow}']
-                      - '@pipe':
-                        - ['{trigger.output.data.initialInterval}', 1]
-                        - ['{@conditional.nullish}']
-                      - ['{@math.multiply}']
-                    - '@pipe':
-                      - ['{trigger.output.data.maximumInterval}', 120]
-                      - ['{@logical.or}']
-                    - ['{@math.min}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
               continueGeneration: '{cycle_hook.output.data.continueGeneration}'
               continueArgs: '{cycle_hook.output.data.continueArgs}'
 
         proxyer:
-          title: Invokes the activity flow and awaits the response
-          type: await
-          topic: ${app}.activity.execute
+          title: Calls the activity function directly via worker topic
+          type: worker
+          topic: '{worker.output.data.workflowTopic}'
           input:
             schema:
               type: object
@@ -637,6 +607,12 @@ const getWorkflowYAML = (app, version) => {
                   - ['{worker.output.data.maximumInterval}','{trigger.output.data.maximumInterval}']
                   - ['{@conditional.nullish}', 120]
                   - ['{@conditional.nullish}']
+          output:
+            schema:
+              type: object
+              properties:
+                response:
+                  type: any
           job:
             maps:
               idempotentcy-marker[-]:
@@ -646,24 +622,26 @@ const getWorkflowYAML = (app, version) => {
                     - ['{@string.concat}']
                   - '@pipe':
                     - '@pipe':
-                      - ['{$self.output.data.$error}']
+                      - ['{$self.output.data.$error}', '{$self.output.metadata.err}']
+                      - ['{@logical.or}']
                     - '@pipe':
                       - '@pipe':
                         - [$error]
                       - '@pipe':
-                        - ['{$self.output.data.$error}']
+                        - ['{$self.output.data.$error}', '{$self.output.metadata.$error}']
+                        - ['{@conditional.nullish}']
                       - '@pipe':
                         - [ac]
                       - '@pipe':
-                        - ['{$self.output.data.jc}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
                         - [au]
                       - '@pipe':
-                        - ['{$self.output.data.ju}']
+                        - ['{$self.output.metadata.au}']
                       - '@pipe':
                         - ['job_id']
                       - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{worker.output.data.workflowId}']
                       - ['{@object.create}']
                     - '@pipe':
                       - '@pipe':
@@ -673,15 +651,15 @@ const getWorkflowYAML = (app, version) => {
                       - '@pipe':
                         - [ac]
                       - '@pipe':
-                        - ['{$self.output.data.jc}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
                         - [au]
                       - '@pipe':
-                        - ['{$self.output.data.ju}']
+                        - ['{$self.output.metadata.au}']
                       - '@pipe':
                         - ['job_id']
                       - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{worker.output.data.workflowId}']
                       - ['{@object.create}']
                     - ['{@conditional.ternary}']
                   - ['{@object.create}']
@@ -692,42 +670,7 @@ const getWorkflowYAML = (app, version) => {
           ancestor: cycle_hook
           input:
             maps:
-              retryCount:
-                '@pipe':
-                  - '@pipe':
-                    - ['{proxyer.output.metadata.err}']
-                  - '@pipe':
-                    - ['{cycle_hook.output.data.retryCount}', 0]
-                    - ['{@logical.or}', 1]
-                    - ['{@math.add}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - ['{proxyer.output.metadata.err}']
-                  - '@pipe':
-                    - '@pipe':
-                      - '@pipe':
-                        - '@pipe':
-                          - ['{trigger.output.data.backoffCoefficient}', 10]
-                          - ['{@conditional.nullish}']
-                        - '@pipe':
-                          - ['{cycle_hook.output.data.retryCount}', 0]
-                          - ['{@conditional.nullish}']
-                        - ['{@math.pow}']
-                      - '@pipe':
-                        - ['{trigger.output.data.initialInterval}', 1]
-                        - ['{@conditional.nullish}']
-                      - ['{@math.multiply}']
-                    - '@pipe':
-                      - ['{trigger.output.data.maximumInterval}', 120]
-                      - ['{@logical.or}']
-                    - ['{@math.min}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
+              retryCount: 0
               continueGeneration: '{cycle_hook.output.data.continueGeneration}'
               continueArgs: '{cycle_hook.output.data.continueArgs}'
 
@@ -832,35 +775,6 @@ const getWorkflowYAML = (app, version) => {
           input:
             maps:
               retryCount: 0
-              throttleSeconds: 0
-              continueGeneration: '{cycle_hook.output.data.continueGeneration}'
-              continueArgs: '{cycle_hook.output.data.continueArgs}'
-
-        retryer:
-          title: Cycles back to the cycle_hook pivot, increasing the retryCount (the exponential)
-          type: cycle
-          ancestor: cycle_hook
-          input:
-            maps:
-              retryCount:
-                '@pipe':
-                  - ['{cycle_hook.output.data.retryCount}', 0]
-                  - ['{@logical.or}', 1]
-                  - ['{@math.add}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - '@pipe':
-                      - ['{trigger.output.data.backoffCoefficient}', 10]
-                      - ['{@conditional.nullish}']
-                    - '@pipe':
-                      - ['{cycle_hook.output.data.retryCount}', 0]
-                      - ['{@conditional.nullish}']
-                    - ['{@math.pow}']
-                  - '@pipe':
-                    - ['{trigger.output.data.maximumInterval}', 120]
-                    - ['{@logical.or}']
-                  - ['{@math.min}']
               continueGeneration: '{cycle_hook.output.data.continueGeneration}'
               continueArgs: '{cycle_hook.output.data.continueArgs}'
 
@@ -871,7 +785,6 @@ const getWorkflowYAML = (app, version) => {
           input:
             maps:
               retryCount: 0
-              throttleSeconds: 0
               continueArgs: '{worker.output.data.arguments}'
               continueGeneration:
                 '@pipe':
@@ -886,18 +799,20 @@ const getWorkflowYAML = (app, version) => {
           job:
             maps:
               done: true
-              $error: '{worker.output.data.$error}'
+              $error:
+                '@pipe':
+                  - ['{worker.output.data.$error}', '{worker.output.metadata.$error}']
+                  - ['{@conditional.nullish}']
               jc: '{$job.metadata.jc}'
               ju:
                 '@pipe':
                   - ['{@date.toISOXString}']
 
-        closer:
-          title: Closes the \`Signal In\` Hook Channel, so the workflow can exit
+        stopper:
+          title: Stops 'Signal In' when retryCount is exceeded (and as a result ends the job)
           type: signal
           subtype: one
           topic: ${app}.flow.signal
-          statusThreshold: 1
           signal:
             schema:
               type: object
@@ -909,17 +824,26 @@ const getWorkflowYAML = (app, version) => {
           job:
             maps:
               done: true
-              $error: '{worker.output.data.$error}'
+              $error:
+                '@pipe':
+                  - '@pipe':
+                    - ['{worker.output.data.$error}', '{worker.output.metadata.$error}']
+                    - ['{@conditional.nullish}']
+                  - '@pipe':
+                    - [message, 'maximum retry attempts exceeded', code, 597]
+                    - ['{@object.create}']
+                  - ['{@conditional.nullish}']
               jc: '{$job.metadata.jc}'
               ju:
                 '@pipe':
                   - ['{@date.toISOXString}']
 
-        stopper:
-          title: Stops 'Signal In' when retryCount is exceeded (and as a result ends the job)
+        closer:
+          title: Closes the \`Signal In\` Hook Channel, so the workflow can exit
           type: signal
           subtype: one
           topic: ${app}.flow.signal
+          statusThreshold: 1
           signal:
             schema:
               type: object
@@ -933,8 +857,8 @@ const getWorkflowYAML = (app, version) => {
               done: true
               $error:
                 '@pipe':
-                  - ['{worker.output.data.$error}', 'code', 597]
-                  - ['{@object.set}']
+                  - ['{worker.output.data.$error}', '{worker.output.metadata.$error}']
+                  - ['{@conditional.nullish}']
               jc: '{$job.metadata.jc}'
               ju:
                 '@pipe':
@@ -970,13 +894,11 @@ const getWorkflowYAML = (app, version) => {
                   type: number
             maps:
               retryCount: 0
-              throttleSeconds: 0
 
         signaler_throttler:
-          title: Pauses between failed hook executions for an exponentially-throttled amount of time after a retryable error
+          title: Pass-through hook between signaler_cycle_hook and signaler_worker
           type: hook
-          sleep: '{signaler_cycle_hook.output.data.throttleSeconds}'
-    
+
         signaler_worker:
           title: Signal In - Worker
           type: worker
@@ -1014,6 +936,22 @@ const getWorkflowYAML = (app, version) => {
                     - ['{trigger.output.data.maximumAttempts}', 5]
                     - ['{@conditional.nullish}']
                   - ['{@conditional.less_than}']
+              maximumAttempts:
+                '@pipe':
+                  - ['{trigger.output.data.maximumAttempts}', 5]
+                  - ['{@conditional.nullish}']
+              backoffCoefficient:
+                '@pipe':
+                  - ['{trigger.output.data.backoffCoefficient}', 10]
+                  - ['{@conditional.nullish}']
+              maximumInterval:
+                '@pipe':
+                  - ['{trigger.output.data.maximumInterval}', 120]
+                  - ['{@conditional.nullish}']
+              initialInterval:
+                '@pipe':
+                  - ['{trigger.output.data.initialInterval}', 1]
+                  - ['{@conditional.nullish}']
 
           output:
             schema:
@@ -1174,7 +1112,6 @@ const getWorkflowYAML = (app, version) => {
           input:
             maps:
               retryCount: 0
-              throttleSeconds: 0
 
         signaler_childer:
           title: Awaits a child flow to be executed/started
@@ -1344,36 +1281,11 @@ const getWorkflowYAML = (app, version) => {
                   - '@pipe':
                     - [0]
                   - ['{@conditional.ternary}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - ['{signaler_childer.output.metadata.err}']
-                  - '@pipe':
-                    - '@pipe':
-                      - '@pipe':
-                        - '@pipe':
-                          - ['{trigger.output.data.backoffCoefficient}', 10]
-                          - ['{@conditional.nullish}']
-                        - '@pipe':
-                          - ['{signaler_cycle_hook.output.data.retryCount}', 0]
-                          - ['{@conditional.nullish}']
-                        - ['{@math.pow}']
-                      - '@pipe':
-                        - ['{trigger.output.data.initialInterval}', 1]
-                        - ['{@conditional.nullish}']
-                      - ['{@math.multiply}']
-                    - '@pipe':
-                      - ['{trigger.output.data.maximumInterval}', 120]
-                      - ['{@logical.or}']
-                    - ['{@math.min}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
-  
+
         signaler_proxyer:
-          title: Invokes the activity flow and awaits the response
-          type: await
-          topic: ${app}.activity.execute
+          title: Calls the activity function directly via worker topic
+          type: worker
+          topic: '{signaler_worker.output.data.workflowTopic}'
           input:
             schema:
               type: object
@@ -1439,6 +1351,12 @@ const getWorkflowYAML = (app, version) => {
                   - ['{signaler_worker.output.data.maximumInterval}','{trigger.output.data.maximumInterval}']
                   - ['{@conditional.nullish}', 120]
                   - ['{@conditional.nullish}']
+          output:
+            schema:
+              type: object
+              properties:
+                response:
+                  type: any
           job:
             maps:
               idempotentcy-marker[-]:
@@ -1448,24 +1366,26 @@ const getWorkflowYAML = (app, version) => {
                     - ['{@string.concat}']
                   - '@pipe':
                     - '@pipe':
-                      - ['{$self.output.data.$error}']
+                      - ['{$self.output.data.$error}', '{$self.output.metadata.err}']
+                      - ['{@logical.or}']
                     - '@pipe':
                       - '@pipe':
                         - [$error]
                       - '@pipe':
-                        - ['{$self.output.data.$error}']
+                        - ['{$self.output.data.$error}', '{$self.output.metadata.$error}']
+                        - ['{@conditional.nullish}']
                       - '@pipe':
                         - [ac]
                       - '@pipe':
-                        - ['{$self.output.data.jc}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
                         - [au]
                       - '@pipe':
-                        - ['{$self.output.data.ju}']
+                        - ['{$self.output.metadata.au}']
                       - '@pipe':
                         - ['job_id']
                       - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{signaler_worker.output.data.workflowId}']
                       - ['{@object.create}']
                     - '@pipe':
                       - '@pipe':
@@ -1475,15 +1395,15 @@ const getWorkflowYAML = (app, version) => {
                       - '@pipe':
                         - [ac]
                       - '@pipe':
-                        - ['{$self.output.data.jc}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
                         - [au]
                       - '@pipe':
-                        - ['{$self.output.data.ju}']
+                        - ['{$self.output.metadata.au}']
                       - '@pipe':
                         - ['job_id']
                       - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{signaler_worker.output.data.workflowId}']
                       - ['{@object.create}']
                     - ['{@conditional.ternary}']
                   - ['{@object.create}']
@@ -1494,42 +1414,7 @@ const getWorkflowYAML = (app, version) => {
           ancestor: signaler_cycle_hook
           input:
             maps:
-              retryCount:
-                '@pipe':
-                  - '@pipe':
-                    - ['{signaler_proxyer.output.metadata.err}']
-                  - '@pipe':
-                    - ['{signaler_cycle_hook.output.data.retryCount}', 0]
-                    - ['{@logical.or}', 1]
-                    - ['{@math.add}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - ['{signaler_proxyer.output.metadata.err}']
-                  - '@pipe':
-                    - '@pipe':
-                      - '@pipe':
-                        - '@pipe':
-                          - ['{trigger.output.data.backoffCoefficient}', 10]
-                          - ['{@conditional.nullish}']
-                        - '@pipe':
-                          - ['{signaler_cycle_hook.output.data.retryCount}', 0]
-                          - ['{@conditional.nullish}']
-                        - ['{@math.pow}']
-                      - '@pipe':
-                        - ['{trigger.output.data.initialInterval}', 1]
-                        - ['{@conditional.nullish}']
-                      - ['{@math.multiply}']
-                    - '@pipe':
-                      - ['{trigger.output.data.maximumInterval}', 120]
-                      - ['{@logical.or}']
-                    - ['{@math.min}']
-                  - '@pipe':
-                    - [0]
-                  - ['{@conditional.ternary}']
+              retryCount: 0
 
         signaler_collator:
           title: Awaits the collator to resolve the idempotent items as a sequential set
@@ -1632,34 +1517,7 @@ const getWorkflowYAML = (app, version) => {
           input:
             maps:
               retryCount: 0
-              throttleSeconds: 0
 
-        signaler_retryer:
-          title: Cycles back to the signaler_cycle_hook pivot, increasing the retryCount (the exponential)
-          type: cycle
-          ancestor: signaler_cycle_hook
-          input:
-            maps:
-              retryCount:
-                '@pipe':
-                  - ['{signaler_cycle_hook.output.data.retryCount}', 0]
-                  - ['{@logical.or}', 1]
-                  - ['{@math.add}']
-              throttleSeconds:
-                '@pipe':
-                  - '@pipe':
-                    - '@pipe':
-                      - ['{trigger.output.data.backoffCoefficient}', 10]
-                      - ['{@conditional.nullish}']
-                    - '@pipe':
-                      - ['{signaler_cycle_hook.output.data.retryCount}', 0]
-                      - ['{@conditional.nullish}']
-                    - ['{@math.pow}']
-                  - '@pipe':
-                    - ['{trigger.output.data.maximumInterval}', 120]
-                    - ['{@logical.or}']
-                  - ['{@math.min}']
-  
       transitions:
         trigger:
           - to: cycle_hook
@@ -1720,22 +1578,9 @@ const getWorkflowYAML = (app, version) => {
           - to: continuer
             conditions:
               code: 592
-          - to: retryer
-            conditions:
-              code: 599
-              match:
-                - expected: true
-                  actual: 
-                    '@pipe':
-                      - '@pipe':
-                        - ['{cycle_hook.output.data.retryCount}']
-                      - '@pipe':
-                        - ['{trigger.output.data.maximumAttempts}', 5]
-                        - ['{@conditional.nullish}']
-                      - ['{@conditional.less_than}']
           - to: stopper
             conditions:
-              code: [590, 591, 596, 597, 598, 599]
+              code: [590, 591, 596, 597, 598]
               match:
                 - expected: true
                   actual:
@@ -1786,19 +1631,6 @@ const getWorkflowYAML = (app, version) => {
           - to: signaler_proxyer
             conditions:
               code: 591
-          - to: signaler_retryer
-            conditions:
-              code: 599
-              match:
-                - expected: true
-                  actual: 
-                    '@pipe':
-                      - '@pipe':
-                        - ['{signaler_cycle_hook.output.data.retryCount}']
-                      - '@pipe':
-                        - ['{trigger.output.data.maximumAttempts}', 5]
-                        - ['{@conditional.nullish}']
-                      - ['{@conditional.less_than}']
         signaler_collator:
           - to: signaler_collate_cycler
         signaler_childer:
@@ -2215,9 +2047,13 @@ const getWorkflowYAML = (app, version) => {
                   - ['{@object.create}']
 
         collator_proxyer:
-          title: Invokes the activity flow and awaits the response
-          type: await
-          topic: ${app}.activity.execute
+          title: Calls the activity function directly via worker topic
+          type: worker
+          topic:
+            '@pipe':
+              - ['{collator_trigger.output.data.items}', '{collator_cycle_hook.output.data.cur_index}']
+              - ['{@array.get}', workflowTopic]
+              - ['{@object.get}']
           input:
             schema:
               type: object
@@ -2327,23 +2163,6 @@ const getWorkflowYAML = (app, version) => {
               properties:
                 response:
                   type: any
-                $error:
-                  type: object
-                  properties:
-                    code:
-                      type: number
-                    message:
-                      type: string
-                    stack:
-                      type: string
-                done:
-                  type: boolean
-                workflowId:
-                  type: string
-                jc:
-                  type: string
-                ju:
-                  type: string
           job:
             maps:
               response[25]:
@@ -2352,46 +2171,44 @@ const getWorkflowYAML = (app, version) => {
                     - ['{collator_cycle_hook.output.data.cur_index}']
                   - '@pipe':
                     - '@pipe':
-                      - ['{$self.output.data.response}']
+                      - ['{$self.output.data.$error}', '{$self.output.metadata.err}']
+                      - ['{@logical.or}']
                     - '@pipe':
                       - '@pipe':
                         - [type]
                       - '@pipe':
                         - ['proxy']
                       - '@pipe':
-                        - [data]
+                        - [$error]
                       - '@pipe':
-                        - ['{$self.output.data.response}']
+                        - ['{$self.output.data.$error}', '{$self.output.metadata.$error}']
+                        - ['{@conditional.nullish}']
                       - '@pipe':
                         - [ac]
                       - '@pipe':
-                        - ['{$job.metadata.jc}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
                         - [au]
                       - '@pipe':
-                        - ['{@date.toISOXString}']
-                      - '@pipe':
-                        - [job_id]
-                      - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{$self.output.metadata.au}']
                       - ['{@object.create}']
                     - '@pipe':
                       - '@pipe':
-                        - [$error]
+                        - [type]
                       - '@pipe':
-                        - ['{$self.output.data}']
+                        - ['proxy']
                       - '@pipe':
-                        - [ac]
+                        - [data]
                       - '@pipe':
-                        - ['{$job.metadata.jc}']
+                        - ['{$self.output.data.response}']
                       - '@pipe':
-                        - [au]
+                        - [ac]
                       - '@pipe':
-                        - ['{@date.toISOXString}']
+                        - ['{$self.output.metadata.ac}']
                       - '@pipe':
-                        - [job_id]
+                        - [au]
                       - '@pipe':
-                        - ['{$self.output.data.workflowId}']
+                        - ['{$self.output.metadata.au}']
                       - ['{@object.create}']
                     - ['{@conditional.ternary}']
                   - ['{@object.create}']
@@ -2453,6 +2270,8 @@ const getWorkflowYAML = (app, version) => {
                       - ['{collator_trigger.output.data.items}', '{collator_cycle_hook.output.data.cur_index}']
                       - ['{@array.get}', code]
                       - ['{@object.get}']
+        collator_proxyer:
+          - to: collator_cycler
 
       hooks:
         ${app}.wfs.signal:
@@ -2465,227 +2284,6 @@ const getWorkflowYAML = (app, version) => {
                       - ['{@array.get}', signalId]
                       - ['{@object.get}']
                   actual: '{$self.hook.data.id}'
-
-
-
-    ###################################################
-    #          THE REENTRANT ACTIVITY FLOW            #
-    #                                                 #
-    - subscribes: ${app}.activity.execute
-      publishes: ${app}.activity.executed
-
-      expire:
-        '@pipe':
-          - '@pipe':
-            - ['{activity_trigger.output.data.startToCloseTimeout}']
-          - '@pipe':
-            - ['{activity_trigger.output.data.expire}', 1]
-            - ['{@conditional.nullish}']
-          - ['{@conditional.nullish}']
-
-      input:
-        schema:
-          type: object
-          properties:
-            parentWorkflowId:
-              type: string
-            originJobId:
-              type: string
-            workflowId:
-              type: string
-            workflowTopic:
-              type: string
-            activityName:
-              type: string
-            arguments:
-              type: array
-            headers:
-              type: object
-            backoffCoefficient:
-              type: number
-            initialInterval:
-              type: number
-            maximumAttempts:
-              type: number
-            maximumInterval:
-              type: number
-            startToCloseTimeout:
-              type: number
-            expire:
-              type: number
-      output:
-        schema:
-          type: object
-          properties:
-            response:
-              type: any
-            done:
-              type: boolean
-            workflowId:
-              type: string
-            jc:
-              type: string
-            ju:
-              type: string
-
-      activities:
-        activity_trigger:
-          title: Activity Flow Trigger
-          type: trigger
-          stats:
-            id: '{$self.input.data.workflowId}'
-            key: '{$self.input.data.parentWorkflowId}'
-            parent: '{$self.input.data.originJobId}'
-            adjacent: '{$self.input.data.parentWorkflowId}'
-          job:
-            maps:
-              workflowId: '{$self.input.data.workflowId}'
-
-        activity_cycle_hook:
-          title: Activity Flow Pivot - Cycling Descendants Point Here
-          type: hook
-          cycle: true
-          output:
-            schema:
-              type: object
-              properties:
-                retryCount:
-                  type: number
-            maps:
-              retryCount: 0
-
-        activity_worker:
-          title: Activity Worker - Calls Activity Functions
-          type: worker
-          topic: '{activity_trigger.output.data.workflowTopic}'
-          input:
-            schema:
-              type: object
-              properties:
-                parentWorkflowId:
-                  type: string
-                workflowId:
-                  type: string
-                workflowTopic:
-                  type: string
-                activityName:
-                  type: string
-                arguments:
-                  type: array
-                headers:
-                  type: object
-                startToCloseTimeout:
-                  type: number
-            maps:
-              parentWorkflowId: '{activity_trigger.output.data.parentWorkflowId}'
-              workflowId: '{activity_trigger.output.data.workflowId}'
-              workflowTopic: '{activity_trigger.output.data.workflowTopic}'
-              activityName: '{activity_trigger.output.data.activityName}'
-              arguments: '{activity_trigger.output.data.arguments}'
-              headers: '{activity_trigger.output.data.headers}'
-              startToCloseTimeout: '{activity_trigger.output.data.startToCloseTimeout}'
-          output:
-            schema:
-              type: object
-              properties:
-                response:
-                  type: any
-          job:
-            maps:
-              response: '{$self.output.data.response}'
-
-        activity_retryer:
-          title: Pauses for an exponentially-throttled amount of time after a 599 (retryable) error
-          type: hook
-          sleep:
-            '@pipe':
-              - '@pipe':
-                - '@pipe':
-                  - ['{activity_trigger.output.data.backoffCoefficient}', 10]
-                  - ['{@logical.or}', '{activity_cycle_hook.output.data.retryCount}']
-                  - ['{@math.pow}']
-                - '@pipe':
-                  - ['{activity_trigger.output.data.initialInterval}', 1]
-                  - ['{@conditional.nullish}']
-                - ['{@math.multiply}']
-              - '@pipe':
-                - ['{activity_trigger.output.data.maximumInterval}', 120]
-                - ['{@math.min}']
-              - ['{@math.min}']
-
-        activity_retry_cycler:
-          title: Cycles back to the activity_cycle_hook pivot, incrementing the \`retryCount\` (the exponential)
-          type: cycle
-          ancestor: activity_cycle_hook
-          input:
-            maps:
-              retryCount:
-                '@pipe':
-                  - ['{activity_cycle_hook.output.data.retryCount}', 1]
-                  - ['{@math.add}']
-
-        activity_closer:
-          title: Marks the activity workflow as done
-          type: hook
-          job:
-            maps:
-              done: true
-              $error: '{activity_worker.output.data.$error}'
-              jc: '{$job.metadata.jc}'
-              ju:
-                '@pipe':
-                  - ['{@date.toISOXString}']
-
-        activity_stopper:
-          title: Stops the activity after retry count has been maxed
-          type: hook
-          job:
-            maps:
-              done: true
-              $error: '{activity_worker.output.data.$error}'
-              jc: '{$job.metadata.jc}'
-              ju:
-                '@pipe':
-                  - ['{@date.toISOXString}']
-
-      transitions:
-        activity_trigger:
-          - to: activity_cycle_hook
-        activity_cycle_hook:
-          - to: activity_worker
-        activity_worker:
-          - to: activity_closer
-            conditions:
-              code: [200, 598, 597, 596]
-          - to: activity_stopper
-            conditions:
-              code: 599
-              match:
-                - expected: true
-                  actual:
-                    '@pipe':
-                      - '@pipe':
-                        - ['{activity_cycle_hook.output.data.retryCount}']
-                      - '@pipe':
-                        - ['{activity_trigger.output.data.maximumAttempts}', 50]
-                        - ['{@conditional.nullish}']
-                      - ['{@conditional.greater_than_or_equal}']
-
-          - to: activity_retryer
-            conditions:
-              code: 599
-              match:
-                - expected: true
-                  actual: 
-                    '@pipe':
-                      - '@pipe':
-                        - ['{activity_cycle_hook.output.data.retryCount}']
-                      - '@pipe':
-                        - ['{activity_trigger.output.data.maximumAttempts}', 50]
-                        - ['{@conditional.nullish}']
-                      - ['{@conditional.less_than}']
-        activity_retryer:
-          - to: activity_retry_cycler
 `;
 };
 exports.getWorkflowYAML = getWorkflowYAML;

package/build/services/durable/worker.js

@@ -377,15 +377,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: 599,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -607,15 +605,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                timestamp: (0, utils_1.formatISODate)(new Date()),
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -963,9 +959,24 @@ class WorkerService {
                     }, telemetry_3.SpanStatusCode.ERROR, err.message);
                 }
                 isProcessing = true;
+                const errorCode = err.code || new errors_1.DurableRetryError(err.message).code;
+                if (errorCode === enums_1.HMSH_CODE_DURABLE_RETRYABLE) {
+                    // Retryable errors use status: ERROR so the engine-level
+                    // retry mechanism (handleRetry + _streamRetryConfig) kicks in
+                    return withPatchMarkers({
+                        status: stream_1.StreamStatus.ERROR,
+                        code: errorCode,
+                        metadata: { ...data.metadata },
+                        data: {
+                            message: err.message,
+                            stack: err.stack,
+                            code: errorCode,
+                        },
+                    });
+                }
                 return withPatchMarkers({
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.DurableRetryError(err.message).code,
+                    code: errorCode,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -973,7 +984,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.DurableRetryError(err.message).code,
+                            code: errorCode,
                         },
                     },
                 });

package/build/services/router/consumption/index.js

@@ -585,14 +585,23 @@ class ConsumptionManager {
                 // Extract retry policy with priority:
                 // 1. Use message-level _streamRetryConfig (from database columns or previous retry)
                 // 2. Fall back to router-level retry (from worker config)
-                const retry = input._streamRetryConfig
+                const streamRetryConfig = input._streamRetryConfig;
+                const retry = streamRetryConfig
                     ? {
-                        maximumAttempts: input._streamRetryConfig.max_retry_attempts,
-                        backoffCoefficient: input._streamRetryConfig.backoff_coefficient,
-                        maximumInterval: input._streamRetryConfig.maximum_interval_seconds,
+                        maximumAttempts: streamRetryConfig.max_retry_attempts,
+                        backoffCoefficient: streamRetryConfig.backoff_coefficient,
+                        maximumInterval: streamRetryConfig.maximum_interval_seconds,
+                        initialInterval: streamRetryConfig.initialInterval ?? input.data?.initialInterval ?? 1,
                     }
                     : this.retry;
-                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry);
+                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry, (topic, delayMs) => {
+                    // Schedule a targeted NOTIFY so the consumer wakes up
+                    // when the visibility-delayed retry message becomes visible
+                    if (typeof this.stream.scheduleStreamNotify === 'function') {
+                        const streamKey = this.stream.mintKey(key_1.KeyType.STREAMS, { topic });
+                        this.stream.scheduleStreamNotify(streamKey, delayMs);
+                    }
+                });
             }
             else if (typeof output.metadata !== 'object') {
                 output.metadata = { ...input.metadata, guid: (0, utils_1.guid)() };

package/build/services/router/error-handling/index.d.ts

@@ -4,5 +4,5 @@ export declare class ErrorHandler {
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
     structureUnacknowledgedError(input: StreamData): StreamDataResponse;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
-    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy): Promise<string>;
+    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy, onRetryScheduled?: (topic: string, delayMs: number) => void): Promise<string>;
 }

package/build/services/router/error-handling/index.js

@@ -14,16 +14,11 @@ class ErrorHandler {
             const maxInterval = typeof retry.maximumInterval === 'string'
                 ? parseInt(retry.maximumInterval)
                 : (retry.maximumInterval || 120);
-            // Check if we can retry (next attempt would be attempt #tryCount+2, must be <= maxAttempts)
-            // tryCount=0 is 1st attempt, tryCount=1 is 2nd attempt, etc.
-            // So after tryCount, we've made (tryCount + 1) attempts
-            // We can retry if (tryCount + 1) < maxAttempts
+            const initialIntervalS = retry.initialInterval || 1;
             if ((tryCount + 1) < maxAttempts) {
-                // Exponential backoff: min(coefficient^(try+1), maxInterval)
-                // First retry (after try=0): coefficient^1
-                // Second retry (after try=1): coefficient^2, etc.
-                const backoffSeconds = Math.min(Math.pow(backoffCoeff, tryCount + 1), maxInterval);
-                return [true, backoffSeconds * 1000]; // Convert to milliseconds
+                // Exponential backoff: min(initialInterval * coefficient^(try+1), maxInterval)
+                const backoffSeconds = Math.min(initialIntervalS * Math.pow(backoffCoeff, tryCount + 1), maxInterval);
+                return [true, backoffSeconds * 1000];
             }
             return [false, 0];
         }
@@ -101,7 +96,7 @@ class ErrorHandler {
             data,
         };
     }
-    async handleRetry(input, output, publishMessage, retry) {
+    async handleRetry(input, output, publishMessage, retry, onRetryScheduled) {
         const [shouldRetry, timeout] = this.shouldRetry(input, output, retry);
         if (shouldRetry) {
             // Only sleep if no retry (legacy behavior for backward compatibility)
@@ -126,7 +121,13 @@ class ErrorHandler {
             // Track retry attempt count in database
             const currentAttempt = input._retryAttempt || 0;
             newMessage._retryAttempt = currentAttempt + 1;
-            return (await publishMessage(input.metadata.topic, newMessage));
+            const messageId = (await publishMessage(input.metadata.topic, newMessage));
+            // Schedule a targeted NOTIFY so the consumer wakes up when
+            // the visibility-delayed message becomes visible
+            if (retry && timeout > 0 && onRetryScheduled) {
+                onRetryScheduled(input.metadata.topic, timeout);
+            }
+            return messageId;
         }
         else {
             const structuredError = this.structureError(input, output);

package/build/services/store/providers/postgres/exporter-sql.d.ts

@@ -15,6 +15,10 @@ export declare const GET_JOB_ATTRIBUTES = "\n  SELECT symbol || dimension AS fie
  * Matches all activity jobs for the given workflow and extracts their input arguments.
  */
 export declare const GET_ACTIVITY_INPUTS = "\n  SELECT j.key, ja.value\n  FROM {schema}.jobs j\n  JOIN {schema}.jobs_attributes ja ON ja.job_id = j.id\n  WHERE j.key LIKE $1\n    AND ja.symbol = $2 AND ja.dimension = $3\n";
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+export declare const GET_PROXYER_STREAM_INPUTS = "\n  SELECT message\n  FROM {schema}.worker_streams\n  WHERE jid = $1\n    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')\n  ORDER BY created_at, id\n";
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

package/build/services/store/providers/postgres/exporter-sql.js

@@ -4,7 +4,7 @@
  * These queries support the exporter's input enrichment and direct query features.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
+exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_PROXYER_STREAM_INPUTS = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
 /**
  * Fetch job record by key.
  */
@@ -34,6 +34,16 @@ exports.GET_ACTIVITY_INPUTS = `
   WHERE j.key LIKE $1
     AND ja.symbol = $2 AND ja.dimension = $3
 `;
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+exports.GET_PROXYER_STREAM_INPUTS = `
+  SELECT message
+  FROM {schema}.worker_streams
+  WHERE jid = $1
+    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')
+  ORDER BY created_at, id
+`;
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

package/build/services/store/providers/postgres/postgres.js

@@ -1442,6 +1442,30 @@ class PostgresStoreService extends __1.StoreService {
                 // Skip unparseable values
             }
         }
+        // If no results from legacy approach, try direct worker approach:
+        // extract arguments from proxyer messages in worker_streams
+        if (byNameIndex.size === 0) {
+            const { GET_PROXYER_STREAM_INPUTS } = await Promise.resolve().then(() => __importStar(require('./exporter-sql')));
+            const streamSql = GET_PROXYER_STREAM_INPUTS.replace(/{schema}/g, schemaName);
+            const streamResult = await this.pgClient.query(streamSql, [workflowId]);
+            for (const row of streamResult.rows) {
+                try {
+                    const msg = typeof row.message === 'string' ? JSON.parse(row.message) : row.message;
+                    const data = msg?.data;
+                    if (data?.activityName && data?.arguments) {
+                        const activityName = data.activityName;
+                        const wfId = data.workflowId || '';
+                        const idxMatch = wfId.match(/-(\d+)$/);
+                        const execIndex = idxMatch ? idxMatch[1] : '0';
+                        byNameIndex.set(`${activityName}:${execIndex}`, data.arguments);
+                        byJobId.set(wfId, data.arguments);
+                    }
+                }
+                catch {
+                    // Skip unparseable messages
+                }
+            }
+        }
         return { byJobId, byNameIndex };
     }
     /**

package/build/services/stream/providers/postgres/postgres.d.ts

@@ -58,6 +58,12 @@ declare class PostgresStreamService extends StreamService<PostgresClientType & P
      * added to the transaction for atomic execution.
      */
     publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): Promise<string[] | ProviderTransaction>;
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName: string, delayMs: number): void;
     _publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): {
         sql: string;
         params: any[];

package/build/services/stream/providers/postgres/postgres.js

@@ -174,6 +174,31 @@ class PostgresStreamService extends index_1.StreamService {
         const target = this.resolveStreamTarget(streamName);
         return Messages.publishMessages(this.streamClient, target.tableName, target.streamName, target.isEngine, messages, options, this.logger);
     }
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName, delayMs) {
+        const target = this.resolveStreamTarget(streamName);
+        const prefix = target.isEngine ? 'eng_' : 'wrk_';
+        let channelName = `${prefix}${target.streamName}`;
+        if (channelName.length > 63) {
+            channelName = channelName.substring(0, 63);
+        }
+        const payload = JSON.stringify({
+            stream_name: target.streamName,
+            table_type: target.isEngine ? 'engine' : 'worker',
+        });
+        setTimeout(async () => {
+            try {
+                await this.streamClient.query(`SELECT pg_notify($1, $2)`, [channelName, payload]);
+            }
+            catch {
+                // Best-effort; the scout fallback will pick it up
+            }
+        }, delayMs);
+    }
     _publishMessages(streamName, messages, options) {
         const target = this.resolveStreamTarget(streamName);
         return Messages.buildPublishSQL(target.tableName, target.streamName, target.isEngine, messages, options);

package/package.json

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