nvent 0.5.4 → 0.5.5

package/dist/runtime/events/wiring/flowWiring.js

@@ -1,6 +1,7 @@
 import { getEventBus } from "../eventBus.js";
 import { useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useFunctionRegistry, useStreamTopics, useRuntimeConfig, useScheduler } from "#imports";
 import { createStallDetector } from "../utils/stallDetector.js";
+import { SYSTEM_HANDLERS } from "../../worker/system/index.js";
 export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   if (!step.subscribes || step.subscribes.length === 0) {
     return true;
@@ -70,49 +71,22 @@ export async function checkAndTriggerPendingSteps(flowName, runId, store) {
     for (const [stepName, stepDef] of Object.entries(flowDef.steps)) {
       const step = stepDef;
       if (!step.subscribes || completedSteps.has(stepName)) continue;
-      const awaitState = flowEntry?.metadata?.awaitingSteps?.[stepName];
-      if (awaitState && awaitState.status === "awaiting") {
-        logger.debug("Step is awaiting, skipping trigger", {
-          flowName,
-          runId,
-          stepName,
-          awaitType: awaitState.awaitType,
-          position: awaitState.position,
-          status: awaitState.status
-        });
-        continue;
-      }
-      if (awaitState && awaitState.status === "timeout") {
-        logger.debug("Step await timed out, skipping trigger", {
-          flowName,
-          runId,
-          stepName,
-          awaitType: awaitState.awaitType
-        });
-        continue;
-      }
-      if (awaitState?.status === "resolved") {
-        logger.debug("Step await is resolved, will proceed", {
-          flowName,
-          runId,
-          stepName,
-          awaitType: awaitState.awaitType,
-          position: awaitState.position
-        });
-      }
+      const awaitBeforeKey = `${stepName}:before`;
+      const awaitState = flowEntry?.metadata?.awaitingSteps?.[awaitBeforeKey];
+      if (awaitState && awaitState.status === "awaiting") continue;
+      if (awaitState && awaitState.status === "timeout") continue;
       const isDependencyAwaiting = step.subscribes.some((sub) => {
         const emitEvent = allEvents.find(
           (evt) => evt.type === "emit" && evt.data?.name === sub
         );
-        if (!emitEvent) {
-          return false;
-        }
+        if (!emitEvent) return false;
         const emitStepName = emitEvent.stepName;
         if (!emitStepName) {
           return false;
         }
-        const awaitState2 = awaitingSteps[emitStepName];
-        if (awaitState2?.position === "after" && awaitState2?.status === "awaiting") {
+        const awaitAfterKey = `${emitStepName}:after`;
+        const awaitState2 = awaitingSteps[awaitAfterKey];
+        if (awaitState2?.status === "awaiting") {
           return true;
         }
         if (awaitState2?.status === "resolved") {
@@ -128,20 +102,80 @@ export async function checkAndTriggerPendingSteps(flowName, runId, store) {
           );
           if (stepCompleted) {
             const awaitResolved = allEvents.some(
-              (evt) => evt.type === "await.resolved" && evt.stepName === emitStepName
+              (evt) => evt.type === "await.resolved" && evt.stepName === emitStepName && evt.position === "after"
             );
-            if (!awaitResolved) {
-              return true;
-            }
+            if (!awaitResolved) return true;
           }
         }
         return false;
       });
-      if (isDependencyAwaiting) {
-        continue;
-      }
+      if (isDependencyAwaiting) continue;
       const canTrigger = checkPendingStepTriggers(step, emittedEvents, completedSteps);
-      if (canTrigger) {
+      if (canTrigger && step.awaitBefore) {
+        if (awaitState?.status === "awaiting") continue;
+        if (awaitState?.status !== "resolved") {
+          try {
+            const emitData = {};
+            const subscribes = step.subscribes || [];
+            for (const sub of subscribes) {
+              const emitEvent = allEvents.find(
+                (evt) => evt.type === "emit" && evt.data?.name === sub
+              );
+              if (emitEvent && emitEvent.data?.payload !== void 0) {
+                emitData[sub] = emitEvent.data.payload;
+              }
+            }
+            const payload = {
+              flowId: runId,
+              flowName,
+              stepName,
+              position: "before",
+              awaitConfig: step.awaitBefore,
+              input: emitData
+            };
+            const jobId = `${runId}__${stepName}__await-register-before`;
+            const flowRegistry = (registry?.flows || {})[flowName];
+            const stepMeta = flowRegistry?.steps?.[stepName];
+            let stepQueue = stepMeta?.queue;
+            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
+              stepQueue = flowRegistry.entry.queue;
+            }
+            if (!stepQueue && registry?.workers) {
+              const worker = registry.workers.find((w) => {
+                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
+                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
+                return flowNames.includes(flowName) && stepMatch;
+              });
+              stepQueue = worker?.queue?.name;
+            }
+            if (!stepQueue) {
+              logger.error("Cannot find queue for step", {
+                stepName,
+                flowName,
+                availableSteps: Object.keys(flowRegistry?.steps || {}),
+                entryStep: flowRegistry?.entry?.step
+              });
+              throw new Error(`Cannot register await: queue not found for step ${stepName} in flow ${flowName}`);
+            }
+            const analyzedAwaitStep = (flowDef.analyzed?.steps || {})[stepName];
+            const awaitStepTimeout = analyzedAwaitStep?.stepTimeout;
+            await queue.enqueue(stepQueue, {
+              name: SYSTEM_HANDLERS.AWAIT_REGISTER,
+              data: payload,
+              opts: { jobId, timeout: awaitStepTimeout }
+            });
+          } catch (err) {
+            logger.error("Failed to register awaitBefore pattern", {
+              flowName,
+              stepName,
+              error: err.message
+            });
+          }
+          continue;
+        }
+      }
+      const shouldEnqueueStep = canTrigger && (!step.awaitBefore || awaitState?.status === "resolved");
+      if (shouldEnqueueStep) {
         const flowRegistry = (registry?.flows || {})[flowName];
         const stepMeta = flowRegistry?.steps?.[stepName];
         if (stepMeta?.queue) {
@@ -161,16 +195,20 @@ export async function checkAndTriggerPendingSteps(flowName, runId, store) {
             input: emitData
             // Keyed by event name
           };
-          if (awaitState?.status === "resolved" && awaitState?.position === "before") {
+          const isAwaitResuming = awaitState?.status === "resolved" && awaitState?.position === "before";
+          if (isAwaitResuming) {
             payload.awaitResolved = true;
             payload.awaitData = awaitState.triggerData;
+            payload.awaitPosition = "before";
           }
-          const jobId = `${runId}__${stepName}`;
+          const jobId = isAwaitResuming ? `${runId}__${stepName}__resumed` : `${runId}__${stepName}`;
           const worker = registry?.workers?.find(
             (w) => w?.flow?.step === stepName && w?.queue?.name === stepMeta.queue
           );
           const defaultOpts = worker?.queue?.defaultJobOptions || {};
-          const opts = { ...defaultOpts, jobId };
+          const analyzedStep = (flowDef.analyzed?.steps || {})[stepName];
+          const stepTimeout = analyzedStep?.stepTimeout;
+          const opts = { ...defaultOpts, jobId, timeout: stepTimeout };
           try {
             await queue.enqueue(stepMeta.queue, { name: stepName, data: payload, opts });
           } catch {
@@ -402,6 +440,21 @@ export function createFlowWiring() {
         const persistedEvent = await store.stream.append(streamName, eventData);
         await bus.publish(persistedEvent);
         if (e.type === "flow.completed" || e.type === "flow.failed") {
+          try {
+            const scheduler = useScheduler();
+            const flowJobs = await scheduler.getJobsByPattern(runId);
+            for (const job of flowJobs) {
+              await scheduler.unschedule(job.id);
+              logger.debug(`Unscheduled job for ${e.type} flow: ${job.id}`);
+            }
+            logger.debug(`Unscheduled ${flowJobs.length} scheduled jobs for ${e.type} flow runId '${runId}'`, {
+              jobs: flowJobs.map((j) => j.id)
+            });
+          } catch (error) {
+            logger.debug(`Could not unschedule jobs for runId '${runId}'`, {
+              error: error.message
+            });
+          }
           const publishKey = `${runId}:terminal`;
           setTimeout(() => {
             try {
@@ -528,11 +581,19 @@ export function createFlowWiring() {
           });
         }
       } catch (err) {
-        logger.warn("Failed to update flow stats", {
-          type: e.type,
-          flowName: e.flowName,
-          error: err?.message
-        });
+        const errorMsg = err?.message || "";
+        if (!errorMsg.includes("Entry not found")) {
+          logger.warn("Failed to update flow stats", {
+            type: e.type,
+            flowName: e.flowName,
+            error: errorMsg
+          });
+        } else {
+          logger.debug("Flow entry not found (will be created)", {
+            type: e.type,
+            flowName: e.flowName
+          });
+        }
       }
     };
     const handleOrchestration = async (e) => {
@@ -561,6 +622,35 @@ export function createFlowWiring() {
             emittedEvents: {}
             // Object for atomic updates
           });
+          try {
+            const analyzedFlows = $useAnalyzedFlows();
+            const flowMeta = analyzedFlows.find((f) => f.id === flowName);
+            const stallTimeout = flowMeta?.analyzed?.stallTimeout || 30 * 60 * 1e3;
+            const scheduler = useScheduler();
+            const stallJobId = `stall-timeout:${runId}`;
+            await scheduler.schedule({
+              id: stallJobId,
+              name: `Stall Timeout - ${flowName}`,
+              type: "one-time",
+              executeAt: timestamp + stallTimeout,
+              handler: async () => {
+                if (stallDetector) {
+                  logger.info(`Per-flow stall timeout fired for '${flowName}' runId '${runId}'`);
+                  await stallDetector.markAsStalled(flowName, runId, "Stall timeout reached");
+                }
+              },
+              metadata: {
+                component: "stall-detector",
+                flowName,
+                runId
+              }
+            });
+            logger.debug(`Scheduled stall timeout for flow '${flowName}' runId '${runId}' in ${stallTimeout / 1e3}s`, { jobId: stallJobId });
+          } catch (error) {
+            logger.warn(`Failed to schedule stall timeout for flow '${flowName}' runId '${runId}'`, {
+              error: error.message
+            });
+          }
         }
         if (e.type === "flow.cancel") {
           try {
@@ -571,8 +661,17 @@ export function createFlowWiring() {
               });
               logger.info("Marked flow as canceled", { flowName, runId });
             }
+            const scheduler = useScheduler();
+            const flowJobs = await scheduler.getJobsByPattern(runId);
+            for (const job of flowJobs) {
+              await scheduler.unschedule(job.id);
+              logger.debug(`Unscheduled job for canceled flow: ${job.id}`);
+            }
+            logger.debug(`Unscheduled ${flowJobs.length} scheduled jobs for canceled flow runId '${runId}'`, {
+              jobs: flowJobs.map((j) => j.id)
+            });
           } catch (err) {
-            logger.warn("Failed to update canceled status", {
+            logger.warn("Failed to update canceled status or unschedule flow jobs", {
               flowName,
               runId,
               error: err?.message
@@ -580,8 +679,36 @@ export function createFlowWiring() {
           }
         }
         if (e.type === "step.started" || e.type === "step.completed" || e.type === "step.failed" || e.type === "step.retry") {
-          if (stallDetector) {
-            await stallDetector.updateActivity(flowName, runId);
+          try {
+            const scheduler = useScheduler();
+            const stallJobId = `stall-timeout:${runId}`;
+            const analyzedFlows = $useAnalyzedFlows();
+            const flowMeta = analyzedFlows.find((f) => f.id === flowName);
+            const stallTimeout = flowMeta?.analyzed?.stallTimeout || 30 * 60 * 1e3;
+            await scheduler.unschedule(stallJobId);
+            await scheduler.schedule({
+              id: stallJobId,
+              name: `Stall Timeout - ${flowName}`,
+              type: "one-time",
+              executeAt: Date.now() + stallTimeout,
+              handler: async () => {
+                if (stallDetector) {
+                  logger.info(`Per-flow stall timeout fired for '${flowName}' runId '${runId}'`);
+                  await stallDetector.markAsStalled(flowName, runId, "Stall timeout reached");
+                }
+              },
+              metadata: {
+                component: "stall-detector",
+                flowName,
+                runId,
+                stallTimeout
+              }
+            });
+            logger.debug(`Rescheduled stall timeout for flow '${flowName}' runId '${runId}' (activity: ${e.type})`);
+          } catch (error) {
+            logger.debug(`Could not reschedule stall timeout for flow '${flowName}' runId '${runId}'`, {
+              error: error.message
+            });
           }
         }
         if (e.type === "step.completed") {
@@ -620,10 +747,15 @@ export function createFlowWiring() {
               if (!timeoutAt) {
                 timeoutAt = now + 24 * 60 * 60 * 1e3;
               }
+              const awaitKey = `${stepName}:${position}`;
               const updatePayload = {
+                status: "awaiting",
+                // Set flow status to awaiting
                 awaitingSteps: {
-                  [stepName]: {
+                  [awaitKey]: {
                     status: "awaiting",
+                    stepName,
+                    // Keep stepName for queries
                     awaitType,
                     position,
                     config: config2,
@@ -651,18 +783,80 @@ export function createFlowWiring() {
         }
         if (e.type === "await.resolved") {
           const awaitEvent = e;
-          const { stepName, triggerData } = awaitEvent;
+          const { stepName, triggerData, position } = awaitEvent;
           try {
             if (store.index.updateWithRetry) {
+              const awaitKey = `${stepName}:${position}`;
               await store.index.updateWithRetry(indexKey, runId, {
                 awaitingSteps: {
-                  [stepName]: {
+                  [awaitKey]: {
                     status: "resolved",
-                    triggerData
+                    stepName,
+                    // Keep stepName for queries
+                    triggerData,
+                    position
                   }
                 }
               });
             }
+            const queue = useQueueAdapter();
+            const { StoreSubjects: StoreSubjects2 } = useStreamTopics();
+            const streamName2 = StoreSubjects2.flowRun(runId);
+            const inputData = {};
+            if (store.stream.read) {
+              const events = await store.stream.read(streamName2, { limit: 100 });
+              const registry2 = $useFunctionRegistry();
+              const flowRegistry2 = (registry2?.flows || {})[flowName];
+              const stepMeta2 = flowRegistry2?.steps?.[stepName];
+              const subscribes = stepMeta2?.subscribes || [];
+              for (const sub of subscribes) {
+                const emitEvent = events.find(
+                  (evt) => evt.type === "emit" && evt.data?.name === sub
+                );
+                if (emitEvent && emitEvent.data?.payload !== void 0) {
+                  inputData[sub] = emitEvent.data.payload;
+                }
+              }
+            }
+            const { SYSTEM_HANDLERS: SYSTEM_HANDLERS2 } = await import("../../worker/system/index.js");
+            const payload = {
+              flowId: runId,
+              flowName,
+              stepName,
+              position,
+              triggerData,
+              input: inputData
+            };
+            const jobId = `${runId}__${stepName}__await-resolve`;
+            const registry = $useFunctionRegistry();
+            const flowRegistry = (registry?.flows || {})[flowName];
+            const stepMeta = flowRegistry?.steps?.[stepName];
+            let stepQueue = stepMeta?.queue;
+            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
+              stepQueue = flowRegistry.entry.queue;
+            }
+            if (!stepQueue && registry?.workers) {
+              const worker = registry.workers.find((w) => {
+                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
+                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
+                return flowNames.includes(flowName) && stepMatch;
+              });
+              stepQueue = worker?.queue?.name;
+            }
+            if (!stepQueue) {
+              logger.error("Cannot find queue for step", {
+                stepName,
+                flowName,
+                availableSteps: Object.keys(flowRegistry?.steps || {}),
+                entryStep: flowRegistry?.entry?.step
+              });
+              throw new Error(`Cannot resolve await: queue not found for step ${stepName} in flow ${flowName}`);
+            }
+            await queue.enqueue(stepQueue, {
+              name: SYSTEM_HANDLERS2.AWAIT_RESOLVE,
+              data: payload,
+              opts: { jobId }
+            });
             await checkAndTriggerPendingSteps(flowName, runId, store);
           } catch (err) {
             logger.error("Error handling await resolution", {
@@ -684,6 +878,63 @@ export function createFlowWiring() {
             action
           });
           try {
+            const queue = useQueueAdapter();
+            const { StoreSubjects: StoreSubjects2 } = useStreamTopics();
+            const streamName2 = StoreSubjects2.flowRun(runId);
+            const inputData = {};
+            if (store.stream.read) {
+              const events = await store.stream.read(streamName2, { limit: 100 });
+              const registry2 = $useFunctionRegistry();
+              const flowRegistry2 = (registry2?.flows || {})[flowName];
+              const stepMeta2 = flowRegistry2?.steps?.[stepName];
+              const subscribes = stepMeta2?.subscribes || [];
+              for (const sub of subscribes) {
+                const emitEvent = events.find(
+                  (evt) => evt.type === "emit" && evt.data?.name === sub
+                );
+                if (emitEvent && emitEvent.data?.payload !== void 0) {
+                  inputData[sub] = emitEvent.data.payload;
+                }
+              }
+            }
+            const payload = {
+              flowId: runId,
+              flowName,
+              stepName,
+              position,
+              timeoutAction: action,
+              input: inputData
+            };
+            const jobId = `${runId}__${stepName}__await-timeout`;
+            const registry = $useFunctionRegistry();
+            const flowRegistry = (registry?.flows || {})[flowName];
+            const stepMeta = flowRegistry?.steps?.[stepName];
+            let stepQueue = stepMeta?.queue;
+            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
+              stepQueue = flowRegistry.entry.queue;
+            }
+            if (!stepQueue && registry?.workers) {
+              const worker = registry.workers.find((w) => {
+                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
+                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
+                return flowNames.includes(flowName) && stepMatch;
+              });
+              stepQueue = worker?.queue?.name;
+            }
+            if (!stepQueue) {
+              logger.error("Cannot find queue for step", {
+                stepName,
+                flowName,
+                availableSteps: Object.keys(flowRegistry?.steps || {}),
+                entryStep: flowRegistry?.entry?.step
+              });
+              throw new Error(`Cannot handle await timeout: queue not found for step ${stepName} in flow ${flowName}`);
+            }
+            await queue.enqueue(stepQueue, {
+              name: SYSTEM_HANDLERS.AWAIT_TIMEOUT,
+              data: payload,
+              opts: { jobId }
+            });
             if (action === "fail") {
               if (store.index.updateWithRetry) {
                 await store.index.updateWithRetry(indexKey, runId, {
@@ -938,56 +1189,9 @@ export function createFlowWiring() {
     const config = useRuntimeConfig();
     const flowConfig = config.nvent.flow || {};
     stallDetector = createStallDetector(store, flowConfig.stallDetection);
-    if (flowConfig.stallDetection?.enabled) {
+    if (flowConfig.stallDetection?.enabled !== false) {
       await stallDetector.start();
-      const scheduleConfig = stallDetector.getScheduleConfig();
-      if (scheduleConfig.enabled) {
-        try {
-          const scheduler = useScheduler();
-          logger.info("Scheduling periodic stall detector from flowWiring", {
-            checkInterval: `${scheduleConfig.interval / 1e3}s`
-          });
-          const jobId = await scheduler.schedule({
-            id: "stall-detection",
-            name: "Flow Stall Detection",
-            type: "interval",
-            interval: scheduleConfig.interval,
-            handler: async () => {
-              if (!stallDetector || !wired) {
-                logger.debug("Stall detector handler called but wiring stopped");
-                return;
-              }
-              try {
-                logger.info("Stall detector running periodic check");
-                const analyzedFlows = $useAnalyzedFlows();
-                const flowNames = analyzedFlows.map((f) => f.id).filter(Boolean);
-                if (flowNames.length > 0) {
-                  await stallDetector.checkFlowsForStalls(flowNames);
-                }
-              } catch (error) {
-                logger.error("Stall detector periodic check failed", {
-                  error: error.message,
-                  stack: error.stack
-                });
-              }
-            },
-            metadata: {
-              component: "stall-detector",
-              stallTimeout: scheduleConfig.stallTimeout,
-              checkInterval: scheduleConfig.interval
-            }
-          });
-          stallDetector.setSchedulerJobId(jobId);
-          logger.info("Stall detector started and scheduled", { jobId });
-        } catch (error) {
-          logger.error("Failed to schedule stall detector - periodic checks disabled", {
-            error: error.message,
-            stack: error.stack
-          });
-        }
-      } else {
-        logger.info("Stall detector started (periodic check disabled)");
-      }
+      logger.info("Stall detector initialized - using per-flow scheduler jobs");
     }
   }
   async function stop() {

package/dist/runtime/events/wiring/triggerWiring.js

@@ -380,8 +380,10 @@ export async function startFlowFromTrigger(flowName, triggerName, triggerData) {
     (w) => w?.flow?.step === stepName && w?.queue?.name === queueName
   );
   const defaultOpts = entryWorker?.queue?.defaultJobOptions || {};
+  const analyzedEntry = flowDef.analyzed?.steps?.[stepName];
+  const stepTimeout = analyzedEntry?.stepTimeout;
   const jobId = `${runId}__${stepName}`;
-  const opts = { ...defaultOpts, jobId };
+  const opts = { ...defaultOpts, jobId, timeout: stepTimeout };
   try {
     await queue.enqueue(queueName, {
       name: stepName,

package/dist/runtime/nitro/plugins/02.workers.js

@@ -1,5 +1,6 @@
 import { defineNitroPlugin, $useWorkerHandlers, $useFunctionRegistry, useQueueAdapter, useHookRegistry } from "#imports";
 import { createJobProcessor } from "../../worker/node/runner.js";
+import { registerSystemHandlersOnQueue } from "../../worker/system/index.js";
 export default defineNitroPlugin(async (nitroApp) => {
   nitroApp.hooks.hook("close", async () => {
     const queueAdapter = useQueueAdapter();
@@ -11,6 +12,7 @@ export default defineNitroPlugin(async (nitroApp) => {
       const handlers = $useWorkerHandlers();
       const registry = $useFunctionRegistry() || { workers: [] };
       const registeredQueues = /* @__PURE__ */ new Set();
+      const queuesWithHooks = /* @__PURE__ */ new Set();
       for (const entry of handlers) {
         const { queue, id, handler, module } = entry;
         const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
@@ -20,7 +22,7 @@ export default defineNitroPlugin(async (nitroApp) => {
         } else {
           jobName = id.includes("/") ? id.split("/").pop() : id;
         }
-        if (module && w?.flow) {
+        if (module) {
           const hooks = {};
           if (typeof module.onAwaitRegister === "function") {
             hooks.onAwaitRegister = module.onAwaitRegister;
@@ -28,7 +30,10 @@ export default defineNitroPlugin(async (nitroApp) => {
           if (typeof module.onAwaitResolve === "function") {
             hooks.onAwaitResolve = module.onAwaitResolve;
           }
-          if (Object.keys(hooks).length > 0) {
+          if (typeof module.onAwaitTimeout === "function") {
+            hooks.onAwaitTimeout = module.onAwaitTimeout;
+          }
+          if (Object.keys(hooks).length > 0 && w?.flow) {
             const hookRegistry = useHookRegistry();
             const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
             for (const flowName of flowNames) {
@@ -36,6 +41,20 @@ export default defineNitroPlugin(async (nitroApp) => {
                 hookRegistry.register(flowName, jobName, hooks);
               }
             }
+            queuesWithHooks.add(queue);
+          }
+          if (w?.flow?.awaitBefore || w?.flow?.awaitAfter) {
+            queuesWithHooks.add(queue);
+          }
+          if (w?.flow?.role === "entry") {
+            const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
+            for (const flowName of flowNames) {
+              const flowRegistry = (registry?.flows || {})[flowName];
+              if (flowRegistry?.entry?.awaitBefore || flowRegistry?.entry?.awaitAfter) {
+                queuesWithHooks.add(queue);
+                break;
+              }
+            }
           }
         }
         if (typeof handler === "function") {
@@ -52,6 +71,16 @@ export default defineNitroPlugin(async (nitroApp) => {
           registeredQueues.add(queue);
         }
       }
+      for (const queueName of queuesWithHooks) {
+        try {
+          const queueWorker = registry.workers.find((w) => w?.queue?.name === queueName);
+          const concurrency = queueWorker?.worker?.concurrency;
+          registerSystemHandlersOnQueue(queueName, concurrency);
+          registeredQueues.add(queueName);
+        } catch (err) {
+          console.error(`[nvent] Failed to register system handlers on queue ${queueName}:`, err);
+        }
+      }
       if (queueAdapter.startProcessingQueue) {
         for (const queueName of Array.from(registeredQueues)) {
           queueAdapter.startProcessingQueue(queueName);

package/dist/runtime/nitro/routes/webhook.await.js

@@ -30,8 +30,8 @@ export default defineEventHandler(async (event) => {
     });
   }
   const status = flowEntry.metadata?.status;
-  if (status && status !== "running") {
-    logger.warn(`Flow is not running`, { flowName, runId, stepName, status });
+  if (status && status !== "running" && status !== "awaiting") {
+    logger.warn(`Flow is not running or awaiting`, { flowName, runId, stepName, status });
     setResponseStatus(event, 410);
     throw createError({
       statusCode: 410,
@@ -39,9 +39,32 @@ export default defineEventHandler(async (event) => {
       message: `This webhook is no longer valid because the flow is ${status}.`
     });
   }
-  const awaitState = flowEntry.metadata?.awaitingSteps?.[stepName];
-  if (!awaitState || awaitState.status !== "awaiting") {
-    logger.warn(`Step is not awaiting`, { flowName, runId, stepName, awaitState });
+  const awaitingSteps = flowEntry.metadata?.awaitingSteps || {};
+  const awaitKeyBefore = `${stepName}:before`;
+  const awaitKeyAfter = `${stepName}:after`;
+  let awaitState = null;
+  let position = "before";
+  const awaitStateBefore = awaitingSteps[awaitKeyBefore];
+  if (awaitStateBefore && awaitStateBefore.status === "awaiting") {
+    awaitState = awaitStateBefore;
+    position = "before";
+  }
+  if (!awaitState) {
+    const awaitStateAfter = awaitingSteps[awaitKeyAfter];
+    if (awaitStateAfter && awaitStateAfter.status === "awaiting") {
+      awaitState = awaitStateAfter;
+      position = "after";
+    }
+  }
+  if (!awaitState) {
+    const legacyAwaitState = awaitingSteps[stepName];
+    if (legacyAwaitState && legacyAwaitState.status === "awaiting") {
+      awaitState = legacyAwaitState;
+      position = "after";
+    }
+  }
+  if (!awaitState) {
+    logger.warn(`Step is not awaiting`, { flowName, runId, stepName, awaitingSteps });
     setResponseStatus(event, 410);
     throw createError({
       statusCode: 410,
@@ -66,7 +89,6 @@ export default defineEventHandler(async (event) => {
       message: `This webhook expects ${expectedMethod} requests.`
     });
   }
-  const position = awaitState.position || "after";
   let webhookData;
   if (event.method === "GET") {
     webhookData = getRouterParams(event, { decode: true });