nvent 0.5.4 → 0.5.6

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 {
@@ -477,7 +530,12 @@ export function createFlowWiring() {
           logger.debug("Updated flow stats for failure", { flowName });
         } else if (e.type === "flow.cancel") {
           if (store.index.increment) {
-            await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            const previousStatus = e.data?.previousStatus;
+            if (previousStatus === "awaiting") {
+              await store.index.increment(flowIndexKey, flowName, "stats.awaiting", -1);
+            } else {
+              await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            }
             await store.index.increment(flowIndexKey, flowName, "stats.cancel", 1);
           }
           if (store.index.updateWithRetry) {
@@ -485,7 +543,7 @@ export function createFlowWiring() {
               lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          logger.debug("Updated flow stats for cancellation", { flowName });
+          logger.debug("Updated flow stats for cancellation", { flowName, previousStatus: e.data?.previousStatus });
         } else if (e.type === "flow.stalled") {
           if (store.index.increment && e.data?.previousStatus) {
             if (e.data.previousStatus === "awaiting") {
@@ -528,11 +586,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 +627,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 +666,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 +684,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") {
@@ -608,6 +740,14 @@ export function createFlowWiring() {
           const { stepName, awaitType, position, config: config2 } = awaitEvent;
           try {
             if (store.index.updateWithRetry) {
+              if (store.index.get) {
+                const currentEntry = await store.index.get(indexKey, runId);
+                const currentStatus = currentEntry?.metadata?.status;
+                if (currentStatus === "canceled") {
+                  logger.debug("Flow already canceled, skipping await registration", { flowName, runId, stepName });
+                  return;
+                }
+              }
               const now = Date.now();
               let timeoutAt;
               if (awaitType === "time" && config2.delay) {
@@ -620,10 +760,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 +796,88 @@ export function createFlowWiring() {
         }
         if (e.type === "await.resolved") {
           const awaitEvent = e;
-          const { stepName, triggerData } = awaitEvent;
+          const { stepName, triggerData, position } = awaitEvent;
           try {
+            if (store.index.get) {
+              const currentEntry = await store.index.get(indexKey, runId);
+              const currentStatus = currentEntry?.metadata?.status;
+              if (currentStatus === "canceled") {
+                logger.debug("Flow already canceled, skipping await resolution", { flowName, runId, stepName });
+                return;
+              }
+            }
             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", {
@@ -676,6 +891,14 @@ export function createFlowWiring() {
           const timeoutEvent = e;
           const { stepName, timeoutAction, position, awaitType } = timeoutEvent;
           const action = timeoutAction || "fail";
+          if (store.index.get) {
+            const currentEntry = await store.index.get(indexKey, runId);
+            const currentStatus = currentEntry?.metadata?.status;
+            if (currentStatus === "canceled") {
+              logger.debug("Flow already canceled, skipping await timeout handling", { flowName, runId, stepName });
+              return;
+            }
+          }
           logger.warn("Await timeout occurred", {
             runId,
             stepName,
@@ -684,6 +907,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, {
@@ -798,6 +1078,11 @@ export function createFlowWiring() {
               }
               if (store.index.get) {
                 const currentEntry = await store.index.get(indexKey, runId);
+                const currentStatus = currentEntry?.metadata?.status;
+                if (currentStatus === "canceled") {
+                  logger.debug("Flow already canceled, skipping status update", { flowName, runId });
+                  return;
+                }
                 const awaitingStepsObj = currentEntry?.metadata?.awaitingSteps || {};
                 let hasActiveAwaits = false;
                 let hasTimedOutAwaits = false;
@@ -938,56 +1223,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/registry.js

@@ -2,7 +2,12 @@ import { createFlowWiring } from "./flowWiring.js";
 import { createStreamWiring } from "./streamWiring.js";
 import { createStateWiring } from "./stateWiring.js";
 import { createTriggerWiring } from "./triggerWiring.js";
+const WIRING_KEY = "__nvent_wiring__";
 export function createWiringRegistry(opts) {
+  const existingWiring = globalThis[WIRING_KEY];
+  if (existingWiring) {
+    return existingWiring;
+  }
   const wirings = [
     // 1. Flow orchestration (persistence, completion tracking, step triggering)
     createFlowWiring(),
@@ -16,7 +21,7 @@ export function createWiringRegistry(opts) {
     createTriggerWiring()
   ];
   let started = false;
-  return {
+  const wiring = {
     async start() {
       if (started) return;
       started = true;
@@ -30,6 +35,9 @@ export function createWiringRegistry(opts) {
         }
       }
       started = false;
+      globalThis[WIRING_KEY] = null;
     }
   };
+  globalThis[WIRING_KEY] = wiring;
+  return wiring;
 }

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

@@ -312,6 +312,14 @@ export async function handleTriggerFired(event) {
   const trigger = useTrigger();
   const { triggerName, data } = event;
   logger.debug("Trigger fired", { trigger: triggerName });
+  const triggerEntry = trigger.getTrigger(triggerName);
+  if (triggerEntry && triggerEntry.status !== "active") {
+    logger.info(`Trigger '${triggerName}' is ${triggerEntry.status}, skipping flow starts`, {
+      trigger: triggerName,
+      status: triggerEntry.status
+    });
+    return [];
+  }
   const subscriptions = trigger.getAllSubscriptions().filter((sub) => sub.triggerName === triggerName);
   if (subscriptions.length === 0) {
     logger.warn(`No flows subscribed to trigger: ${triggerName}`);
@@ -380,8 +388,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,