nvent 0.4.5 → 0.5.0

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

@@ -1,5 +1,5 @@
 import { getEventBus } from "../eventBus.js";
-import { useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useQueueRegistry, useStreamTopics, useRuntimeConfig } from "#imports";
+import { useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useFunctionRegistry, useStreamTopics, useRuntimeConfig, useScheduler } from "#imports";
 import { createStallDetector } from "../utils/stallDetector.js";
 export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   if (!step.subscribes || step.subscribes.length === 0) {
@@ -14,36 +14,132 @@ export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
     return false;
   });
 }
-async function checkAndTriggerPendingSteps(flowName, runId, store) {
+export async function checkAndTriggerPendingSteps(flowName, runId, store) {
   const logger = useNventLogger("flow-wiring");
   try {
     const analyzedFlows = $useAnalyzedFlows();
-    const registry = $useQueueRegistry();
+    const registry = $useFunctionRegistry();
     const queue = useQueueAdapter();
-    const { SubjectPatterns } = useStreamTopics();
+    const { StoreSubjects } = useStreamTopics();
     const flowDef = analyzedFlows.find((f) => f.id === flowName);
-    if (!flowDef?.steps) return;
-    const indexKey = SubjectPatterns.flowRunIndex(flowName);
-    if (!store.indexGet) return;
-    const flowEntry = await store.indexGet(indexKey, runId);
-    if (!flowEntry?.metadata) return;
-    const streamName = SubjectPatterns.flowRun(runId);
-    const allEvents = await store.read(streamName);
+    if (!flowDef?.steps) {
+      logger.info("No flow definition or steps found", { flowName });
+      return;
+    }
+    const indexKey = StoreSubjects.flowRunIndex(flowName);
+    if (!store.index.get) {
+      logger.info("No indexGet method on store", { flowName });
+      return;
+    }
+    const flowEntry = await store.index.get(indexKey, runId);
+    if (!flowEntry?.metadata) {
+      logger.info("No flow entry or metadata found", { flowName, runId });
+      return;
+    }
+    const streamName = StoreSubjects.flowRun(runId);
+    const allEvents = await store.stream.read(streamName);
     const isCanceled = allEvents.some((event) => event.type === "flow.cancel");
     if (isCanceled) {
       logger.debug("Flow is canceled, skipping pending step triggers", { flowName, runId });
       return;
     }
-    const emittedEvents = new Set(flowEntry.metadata.emittedEvents || []);
+    const emittedEventsObj = flowEntry.metadata.emittedEvents || {};
+    const flattenEmittedEvents = (obj, prefix = "") => {
+      const result = [];
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "undefined" || key === "null") continue;
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          result.push(...flattenEmittedEvents(value, fullKey));
+        } else {
+          result.push(fullKey);
+        }
+      }
+      return result;
+    };
+    const emittedEvents = new Set(
+      typeof emittedEventsObj === "object" && !Array.isArray(emittedEventsObj) ? flattenEmittedEvents(emittedEventsObj) : Array.isArray(emittedEventsObj) ? emittedEventsObj : []
+    );
     const completedSteps = /* @__PURE__ */ new Set();
     for (const event of allEvents) {
       if (event.type === "step.completed" && "stepName" in event) {
         completedSteps.add(event.stepName);
       }
     }
+    const awaitingSteps = flowEntry?.metadata?.awaitingSteps || {};
     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 isDependencyAwaiting = step.subscribes.some((sub) => {
+        const emitEvent = allEvents.find(
+          (evt) => evt.type === "emit" && evt.data?.name === sub
+        );
+        if (!emitEvent) {
+          return false;
+        }
+        const emitStepName = emitEvent.stepName;
+        if (!emitStepName) {
+          return false;
+        }
+        const awaitState2 = awaitingSteps[emitStepName];
+        if (awaitState2?.position === "after" && awaitState2?.status === "awaiting") {
+          return true;
+        }
+        if (awaitState2?.status === "resolved") {
+          return false;
+        }
+        let emittingStepMeta = flowDef.steps[emitStepName];
+        if (!emittingStepMeta && emitStepName === flowDef.entry?.step) {
+          emittingStepMeta = flowDef.entry;
+        }
+        if (emittingStepMeta?.awaitAfter) {
+          const stepCompleted = allEvents.some(
+            (evt) => evt.type === "step.completed" && evt.stepName === emitStepName
+          );
+          if (stepCompleted) {
+            const awaitResolved = allEvents.some(
+              (evt) => evt.type === "await.resolved" && evt.stepName === emitStepName
+            );
+            if (!awaitResolved) {
+              return true;
+            }
+          }
+        }
+        return false;
+      });
+      if (isDependencyAwaiting) {
+        continue;
+      }
       const canTrigger = checkPendingStepTriggers(step, emittedEvents, completedSteps);
       if (canTrigger) {
         const flowRegistry = (registry?.flows || {})[flowName];
@@ -65,6 +161,10 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
             input: emitData
             // Keyed by event name
           };
+          if (awaitState?.status === "resolved" && awaitState?.position === "before") {
+            payload.awaitResolved = true;
+            payload.awaitData = awaitState.triggerData;
+          }
           const jobId = `${runId}__${stepName}`;
           const worker = registry?.workers?.find(
             (w) => w?.flow?.step === stepName && w?.queue?.name === stepMeta.queue
@@ -73,12 +173,6 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
           const opts = { ...defaultOpts, jobId };
           try {
             await queue.enqueue(stepMeta.queue, { name: stepName, data: payload, opts });
-            logger.debug("Triggered pending step", {
-              flowName,
-              runId,
-              step: stepName,
-              subscribes: step.subscribes
-            });
           } catch {
           }
         }
@@ -92,7 +186,7 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
     });
   }
 }
-export function analyzeFlowCompletion(flowSteps, entryStep, events) {
+export function analyzeFlowCompletion(flowSteps, entryStep, events, entryStepDef) {
   const isCanceled = events.some((event) => event.type === "flow.cancel");
   const allSteps = entryStep ? [entryStep, ...Object.keys(flowSteps)] : Object.keys(flowSteps);
   const completedSteps = /* @__PURE__ */ new Set();
@@ -139,29 +233,74 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
   }
   const totalSteps = allSteps.length;
   const hasFinalFailures = finalFailedSteps.size > 0;
+  const stepDependencies = /* @__PURE__ */ new Map();
+  const stepDependents = /* @__PURE__ */ new Map();
+  for (const stepName of allSteps) {
+    stepDependencies.set(stepName, /* @__PURE__ */ new Set());
+    stepDependents.set(stepName, /* @__PURE__ */ new Set());
+  }
+  for (const [stepName, stepDef] of Object.entries(flowSteps)) {
+    const step = stepDef;
+    const subscribes = step.subscribes || [];
+    for (const sub of subscribes) {
+      for (const [emitStepName, emitStepDef] of Object.entries(flowSteps)) {
+        const emitStep = emitStepDef;
+        const emits = emitStep.emits || [];
+        if (emits.some((emit) => sub === `${emitStepName}.${emit}` || sub === emit)) {
+          stepDependencies.get(stepName)?.add(emitStepName);
+          stepDependents.get(emitStepName)?.add(stepName);
+        }
+      }
+      if (entryStep && entryStepDef?.emits) {
+        const entryEmits = entryStepDef.emits || [];
+        if (entryEmits.some((emit) => sub === `${entryStep}.${emit}` || sub === emit)) {
+          stepDependencies.get(stepName)?.add(entryStep);
+          stepDependents.get(entryStep)?.add(stepName);
+        }
+      }
+    }
+  }
   let hasBlockingFailure = false;
+  let hasCriticalLayerFailure = false;
   if (hasFinalFailures) {
     for (const failedStepName of Array.from(finalFailedSteps)) {
-      const failedStepDef = flowSteps[failedStepName];
-      if (failedStepDef?.emits && failedStepDef.emits.length > 0) {
-        for (const [stepName, stepDef] of Object.entries(flowSteps)) {
-          const step = stepDef;
-          if (stepName === failedStepName) continue;
-          if (step.subscribes && step.subscribes.length > 0) {
-            const dependsOnFailedStep = step.subscribes.some((sub) => {
-              return failedStepDef.emits.some(
-                (emit) => sub === `${failedStepName}.${emit}` || sub === emit
-              );
-            });
-            if (dependsOnFailedStep && !completedSteps.has(stepName)) {
-              hasBlockingFailure = true;
-              break;
-            }
+      const dependents = stepDependents.get(failedStepName);
+      if (dependents && dependents.size > 0) {
+        for (const dependentName of Array.from(dependents)) {
+          if (!completedSteps.has(dependentName)) {
+            hasBlockingFailure = true;
+            break;
           }
         }
       }
       if (hasBlockingFailure) break;
     }
+    const layerGroups = /* @__PURE__ */ new Map();
+    for (const stepName of allSteps) {
+      const deps = stepDependencies.get(stepName);
+      const depsKey = Array.from(deps || []).sort().join(",");
+      if (!layerGroups.has(depsKey)) {
+        layerGroups.set(depsKey, /* @__PURE__ */ new Set());
+      }
+      layerGroups.get(depsKey)?.add(stepName);
+    }
+    for (const [_depsKey, layerSteps] of Array.from(layerGroups)) {
+      const layerHasFailures = Array.from(layerSteps).some((s) => finalFailedSteps.has(s));
+      if (!layerHasFailures) continue;
+      const allLayerStepsFailed = Array.from(layerSteps).every(
+        (s) => finalFailedSteps.has(s)
+      );
+      if (allLayerStepsFailed) {
+        const hasLeafNode = Array.from(layerSteps).some((s) => {
+          const deps = stepDependents.get(s);
+          return !deps || deps.size === 0;
+        });
+        if (hasLeafNode) {
+          hasCriticalLayerFailure = true;
+          break;
+        }
+      }
+    }
   }
   if (isCanceled) {
     return {
@@ -172,7 +311,7 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
       completedAt
     };
   }
-  if (hasBlockingFailure) {
+  if (hasBlockingFailure || hasCriticalLayerFailure) {
     return {
       status: "failed",
       totalSteps,
@@ -181,11 +320,11 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
       completedAt: Date.now()
     };
   }
-  const allCompleted = allSteps.every(
+  const allStepsTerminal = allSteps.every(
     (step) => completedSteps.has(step) || finalFailedSteps.has(step)
   );
   let status = "running";
-  if (allCompleted) {
+  if (allStepsTerminal) {
     status = "completed";
     completedAt = Date.now();
   }
@@ -202,31 +341,34 @@ export function createFlowWiring() {
   const unsubs = [];
   let wired = false;
   let stallDetector;
+  const publishingTerminalEvents = /* @__PURE__ */ new Set();
   const indexFlowRun = async (flowName, flowId, timestamp, metadata) => {
     const logger = useNventLogger("flow-wiring");
     try {
       const store = useStoreAdapter();
-      const { SubjectPatterns } = useStreamTopics();
-      const indexKey = SubjectPatterns.flowRunIndex(flowName);
-      if (!store.indexAdd) {
+      const { StoreSubjects } = useStreamTopics();
+      const indexKey = StoreSubjects.flowRunIndex(flowName);
+      if (!store.index.add) {
         throw new Error("StoreAdapter does not support indexAdd");
       }
-      await store.indexAdd(indexKey, flowId, timestamp, metadata);
-      logger.debug("Indexed run", { flowName, flowId, indexKey, timestamp, metadata });
+      await store.index.add(indexKey, flowId, timestamp, metadata);
     } catch (err) {
       logger.error("Failed to index run", { error: err });
     }
   };
-  function start() {
+  const flowProcessingChain = /* @__PURE__ */ new Map();
+  const cleanupTimers = /* @__PURE__ */ new Map();
+  async function start() {
     if (wired) return;
     wired = true;
     const logger = useNventLogger("flow-wiring");
-    const { SubjectPatterns } = useStreamTopics();
+    const { StoreSubjects } = useStreamTopics();
+    logger.info("Flow wiring starting");
     const store = useStoreAdapter();
-    if (!store || !store.append) {
+    if (!store || !store.stream.append) {
       logger.error("StoreAdapter not properly initialized or missing append method", {
         hasStore: !!store,
-        hasAppend: !!(store && store.append)
+        hasAppend: !!(store && store.stream.append)
       });
       throw new Error("StoreAdapter not initialized");
     }
@@ -243,7 +385,7 @@ export function createFlowWiring() {
         if (!flowName) {
           return;
         }
-        const streamName = SubjectPatterns.flowRun(runId);
+        const streamName = StoreSubjects.flowRun(runId);
         if (!e.type) {
           logger.error("Event missing type field", { event: e });
           return;
@@ -257,9 +399,17 @@ export function createFlowWiring() {
         if ("stepName" in e && e.stepName) eventData.stepName = e.stepName;
         if ("stepId" in e && e.stepId) eventData.stepId = e.stepId;
         if ("attempt" in e && e.attempt) eventData.attempt = e.attempt;
-        const persistedEvent = await store.append(streamName, eventData);
+        const persistedEvent = await store.stream.append(streamName, eventData);
         await bus.publish(persistedEvent);
         if (e.type === "flow.completed" || e.type === "flow.failed") {
+          const publishKey = `${runId}:terminal`;
+          setTimeout(() => {
+            try {
+              publishingTerminalEvents.delete(publishKey);
+            } catch (err) {
+              logger.debug("Error cleaning up terminal event tracker", { publishKey, error: err?.message });
+            }
+          }, 200);
           logger.info("Stored terminal event", {
             type: e.type,
             flowName,
@@ -284,6 +434,107 @@ export function createFlowWiring() {
         });
       }
     };
+    const handleFlowStats = async (e) => {
+      try {
+        if (!e.id || !e.ts) {
+          return;
+        }
+        const flowName = e.flowName;
+        if (!flowName) return;
+        const flowIndexKey = StoreSubjects.flowIndex();
+        if (e.type === "flow.start") {
+          if (store.index.increment) {
+            await store.index.increment(flowIndexKey, flowName, "stats.total", 1);
+            await store.index.increment(flowIndexKey, flowName, "stats.running", 1);
+          }
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(flowIndexKey, flowName, {
+              lastRunAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          logger.debug("Updated flow stats for start", { flowName });
+        } else if (e.type === "flow.completed") {
+          if (store.index.increment) {
+            await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            await store.index.increment(flowIndexKey, flowName, "stats.success", 1);
+          }
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(flowIndexKey, flowName, {
+              lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          logger.debug("Updated flow stats for completion", { flowName });
+        } else if (e.type === "flow.failed") {
+          if (store.index.increment) {
+            await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            await store.index.increment(flowIndexKey, flowName, "stats.failure", 1);
+          }
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(flowIndexKey, flowName, {
+              lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          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);
+            await store.index.increment(flowIndexKey, flowName, "stats.cancel", 1);
+          }
+          if (store.index.updateWithRetry) {
+            await store.index.updateWithRetry(flowIndexKey, flowName, {
+              lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+          logger.debug("Updated flow stats for cancellation", { flowName });
+        } else if (e.type === "flow.stalled") {
+          if (store.index.increment && e.data?.previousStatus) {
+            if (e.data.previousStatus === "awaiting") {
+              await store.index.increment(flowIndexKey, flowName, "stats.awaiting", -1);
+              logger.debug("Updated flow stats for stalled detection (was awaiting)", { flowName });
+            } else if (e.data.previousStatus === "running") {
+              await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+              logger.debug("Updated flow stats for stalled detection (was running)", { flowName });
+            }
+          }
+        } else if (e.type === "await.registered") {
+          if (store.index.increment) {
+            await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            await store.index.increment(flowIndexKey, flowName, "stats.awaiting", 1);
+          }
+          logger.debug("Updated flow stats for await registered", { flowName });
+        } else if (e.type === "await.resolved" || e.type === "await.timeout") {
+          if (store.index.increment) {
+            await store.index.increment(flowIndexKey, flowName, "stats.awaiting", -1);
+            await store.index.increment(flowIndexKey, flowName, "stats.running", 1);
+          }
+          logger.debug("Updated flow stats for await resolved/timeout", { flowName, type: e.type });
+        }
+        try {
+          const indexEntry = await store.index.get(flowIndexKey, flowName);
+          if (indexEntry) {
+            await bus.publish({
+              type: "flow.stats.updated",
+              flowName,
+              id: indexEntry.id,
+              metadata: indexEntry.metadata,
+              ts: Date.now()
+            });
+            logger.debug("Published flow stats update event to bus", { flowName });
+          }
+        } catch (err) {
+          logger.warn("Failed to publish flow stats update event", {
+            flowName,
+            error: err?.message
+          });
+        }
+      } catch (err) {
+        logger.warn("Failed to update flow stats", {
+          type: e.type,
+          flowName: e.flowName,
+          error: err?.message
+        });
+      }
+    };
     const handleOrchestration = async (e) => {
       try {
         if (e.id && e.ts) {
@@ -296,8 +547,8 @@ export function createFlowWiring() {
         if (!runId) return;
         const flowName = e.flowName;
         if (!flowName) return;
-        const streamName = SubjectPatterns.flowRun(runId);
-        const indexKey = SubjectPatterns.flowRunIndex(flowName);
+        const streamName = StoreSubjects.flowRun(runId);
+        const indexKey = StoreSubjects.flowRunIndex(flowName);
         if (e.type === "flow.start") {
           const timestamp = Date.now();
           await indexFlowRun(flowName, runId, timestamp, {
@@ -307,13 +558,14 @@ export function createFlowWiring() {
             // Initialize for stall detection
             stepCount: 0,
             completedSteps: 0,
-            emittedEvents: []
+            emittedEvents: {}
+            // Object for atomic updates
           });
         }
         if (e.type === "flow.cancel") {
           try {
-            if (store.indexUpdateWithRetry) {
-              await store.indexUpdateWithRetry(indexKey, runId, {
+            if (store.index.updateWithRetry) {
+              await store.index.updateWithRetry(indexKey, runId, {
                 status: "canceled",
                 completedAt: Date.now()
               });
@@ -334,8 +586,8 @@ export function createFlowWiring() {
         }
         if (e.type === "step.completed") {
           try {
-            if (store.indexIncrement) {
-              const newCount = await store.indexIncrement(indexKey, runId, "completedSteps", 1);
+            if (store.index.increment) {
+              const newCount = await store.index.increment(indexKey, runId, "completedSteps", 1);
               logger.debug("Incremented completedSteps", {
                 flowName,
                 runId,
@@ -351,29 +603,161 @@ export function createFlowWiring() {
             });
           }
         }
+        if (e.type === "await.registered") {
+          const awaitEvent = e;
+          const { stepName, awaitType, position, config: config2 } = awaitEvent;
+          try {
+            if (store.index.updateWithRetry) {
+              const now = Date.now();
+              let timeoutAt;
+              if (awaitType === "time" && config2.delay) {
+                timeoutAt = now + config2.delay;
+              } else if (awaitType === "schedule" && config2.nextOccurrence) {
+                timeoutAt = config2.nextOccurrence;
+              } else if (config2.timeout) {
+                timeoutAt = now + config2.timeout;
+              }
+              if (!timeoutAt) {
+                timeoutAt = now + 24 * 60 * 60 * 1e3;
+              }
+              const updatePayload = {
+                awaitingSteps: {
+                  [stepName]: {
+                    status: "awaiting",
+                    awaitType,
+                    position,
+                    config: config2,
+                    registeredAt: now,
+                    timeoutAt
+                  }
+                }
+              };
+              await store.index.updateWithRetry(indexKey, runId, updatePayload);
+              logger.info("Await registered in index", {
+                runId,
+                stepName,
+                awaitType,
+                position,
+                timeoutAt: new Date(timeoutAt).toISOString()
+              });
+            }
+          } catch (err) {
+            logger.error("Error updating await status", {
+              runId,
+              stepName,
+              error: err?.message
+            });
+          }
+        }
+        if (e.type === "await.resolved") {
+          const awaitEvent = e;
+          const { stepName, triggerData } = awaitEvent;
+          try {
+            if (store.index.updateWithRetry) {
+              await store.index.updateWithRetry(indexKey, runId, {
+                awaitingSteps: {
+                  [stepName]: {
+                    status: "resolved",
+                    triggerData
+                  }
+                }
+              });
+            }
+            await checkAndTriggerPendingSteps(flowName, runId, store);
+          } catch (err) {
+            logger.error("Error handling await resolution", {
+              runId,
+              stepName,
+              error: err?.message
+            });
+          }
+        }
+        if (e.type === "await.timeout") {
+          const timeoutEvent = e;
+          const { stepName, timeoutAction, position, awaitType } = timeoutEvent;
+          const action = timeoutAction || "fail";
+          logger.warn("Await timeout occurred", {
+            runId,
+            stepName,
+            awaitType,
+            position,
+            action
+          });
+          try {
+            if (action === "fail") {
+              if (store.index.updateWithRetry) {
+                await store.index.updateWithRetry(indexKey, runId, {
+                  awaitingSteps: {
+                    [stepName]: {
+                      status: "timeout",
+                      timedOutAt: Date.now()
+                    }
+                  }
+                });
+              }
+              bus.publish({
+                type: "step.failed",
+                runId,
+                flowName,
+                stepName,
+                stepId: `${runId}__${stepName}__timeout`,
+                attempt: 1,
+                data: {
+                  error: `Await timeout: ${awaitType} await exceeded timeout`
+                }
+              });
+            } else if (action === "continue") {
+              if (store.index.updateWithRetry) {
+                await store.index.updateWithRetry(indexKey, runId, {
+                  awaitingSteps: {
+                    [stepName]: {
+                      status: "resolved",
+                      triggerData: null,
+                      timedOutAt: Date.now()
+                    }
+                  }
+                });
+              }
+              logger.info("Await timeout - continuing with null data", { runId, stepName });
+              await checkAndTriggerPendingSteps(flowName, runId, store);
+            }
+          } catch (err) {
+            logger.error("Error handling await timeout", {
+              runId,
+              stepName,
+              error: err?.message
+            });
+          }
+        }
         if (e.type === "emit") {
           const eventName = e.data?.name || e.data?.topic;
           if (!eventName) {
             logger.warn("Emit event missing name/topic", { flowName, runId, data: e.data });
           } else {
             try {
-              if (!store.indexGet || !store.indexUpdateWithRetry) {
-                logger.warn("StoreAdapter does not support indexGet or indexUpdateWithRetry");
+              if (!store.index.updateWithRetry) {
+                logger.warn("StoreAdapter does not support indexUpdateWithRetry");
                 return;
               }
-              const currentEntry = await store.indexGet(indexKey, runId);
-              const emittedEvents = (currentEntry?.metadata?.emittedEvents || []).filter((item) => item != null && typeof item === "string");
-              if (!emittedEvents.includes(eventName)) {
-                await store.indexUpdateWithRetry(indexKey, runId, {
-                  emittedEvents: [...emittedEvents, eventName]
-                });
-                logger.debug("Tracked emit event", {
-                  flowName,
-                  runId,
-                  name: eventName,
-                  allEmitted: [...emittedEvents, eventName]
-                });
+              const timestamp = Date.now();
+              const eventParts = eventName.split(".");
+              const emittedEventsUpdate = {};
+              let current = emittedEventsUpdate;
+              for (let i = 0; i < eventParts.length - 1; i++) {
+                current[eventParts[i]] = {};
+                current = current[eventParts[i]];
               }
+              current[eventParts[eventParts.length - 1]] = timestamp;
+              const updatePayload = {
+                emittedEvents: emittedEventsUpdate
+              };
+              await store.index.updateWithRetry(indexKey, runId, updatePayload);
+              logger.debug("Tracked emit event", {
+                flowName,
+                runId,
+                name: eventName,
+                timestamp
+              });
             } catch (err) {
               logger.warn("Failed to track emitted event", {
                 flowName,
@@ -384,16 +768,27 @@ export function createFlowWiring() {
             }
           }
         }
+        if (e.type === "step.completed") {
+          try {
+            await checkAndTriggerPendingSteps(flowName, runId, store);
+          } catch (err) {
+            logger.error("Error checking pending steps", {
+              flowName,
+              runId,
+              error: err.message
+            });
+            throw err;
+          }
+        }
         if (e.type === "step.completed" || e.type === "step.failed") {
-          await checkAndTriggerPendingSteps(flowName, runId, store);
-          await new Promise((resolve) => setTimeout(resolve, 50));
           try {
-            const allEvents = await store.read(streamName);
+            const allEvents = await store.stream.read(streamName);
             const analyzedFlows = $useAnalyzedFlows();
             const flowDef = analyzedFlows.find((f) => f.id === flowName);
             if (flowDef?.steps) {
               const entryStepName = flowDef.entry?.step;
-              const analysis = analyzeFlowCompletion(flowDef.steps, entryStepName, allEvents);
+              const entryStepDef = flowDef.entry;
+              const analysis = analyzeFlowCompletion(flowDef.steps, entryStepName, allEvents, entryStepDef);
               const updateMetadata = {
                 status: analysis.status,
                 stepCount: analysis.totalSteps
@@ -401,19 +796,57 @@ export function createFlowWiring() {
               if (analysis.status !== "running" && analysis.completedAt) {
                 updateMetadata.completedAt = analysis.completedAt;
               }
-              if (store.indexUpdateWithRetry) {
-                await store.indexUpdateWithRetry(indexKey, runId, updateMetadata);
+              if (store.index.get) {
+                const currentEntry = await store.index.get(indexKey, runId);
+                const awaitingStepsObj = currentEntry?.metadata?.awaitingSteps || {};
+                let hasActiveAwaits = false;
+                let hasTimedOutAwaits = false;
+                for (const [_stepName, awaitState] of Object.entries(awaitingStepsObj)) {
+                  if (awaitState?.status === "awaiting") {
+                    hasActiveAwaits = true;
+                  } else if (awaitState?.status === "timeout") {
+                    hasTimedOutAwaits = true;
+                  }
+                }
+                if (hasActiveAwaits) {
+                  updateMetadata.status = "awaiting";
+                }
+                if (hasTimedOutAwaits) {
+                  updateMetadata.status = "failed";
+                  if (!updateMetadata.completedAt) {
+                    updateMetadata.completedAt = Date.now();
+                  }
+                }
+              }
+              if (store.index.updateWithRetry) {
+                await store.index.updateWithRetry(indexKey, runId, updateMetadata);
               }
-              if (analysis.status === "completed" || analysis.status === "failed") {
-                const eventType = analysis.status === "completed" ? "flow.completed" : "flow.failed";
+              const finalStatus = updateMetadata.status || analysis.status;
+              if (finalStatus === "completed" || finalStatus === "failed") {
+                const eventType = finalStatus === "completed" ? "flow.completed" : "flow.failed";
+                let currentStatus = null;
+                if (store.index.get) {
+                  const currentEntry = await store.index.get(indexKey, runId);
+                  currentStatus = currentEntry?.metadata?.status;
+                }
                 const terminalEventExists = allEvents.some((evt) => evt.type === "flow.completed" || evt.type === "flow.failed");
+                const publishKey = `${runId}:terminal`;
+                const alreadyPublishing = publishingTerminalEvents.has(publishKey);
                 if (terminalEventExists) {
-                  logger.debug("Terminal event already exists, skipping publish", {
+                  logger.debug("Flow terminal event already exists in stream, skipping publish", {
+                    flowName,
+                    runId,
+                    currentStatus,
+                    eventType
+                  });
+                } else if (alreadyPublishing) {
+                  logger.debug("Flow terminal event already being published, skipping duplicate", {
                     flowName,
                     runId,
                     eventType
                   });
                 } else {
+                  publishingTerminalEvents.add(publishKey);
                   logger.info("Publishing terminal event to bus", {
                     flowName,
                     runId,
@@ -441,11 +874,48 @@ export function createFlowWiring() {
           type: e.type,
           runId: e.runId,
           flowName: e.flowName,
-          error: err?.message,
-          stack: err?.stack
+          error: err?.message
         });
       }
     };
+    const processEventSequentially = async (event) => {
+      const runId = event.runId;
+      if (!runId) {
+        await handlePersistence(event);
+        await handleOrchestration(event);
+        await handleFlowStats(event);
+        return;
+      }
+      const previousProcessing = flowProcessingChain.get(runId) || Promise.resolve();
+      const currentProcessing = previousProcessing.then(async () => {
+        try {
+          await handlePersistence(event);
+          await handleOrchestration(event);
+          await handleFlowStats(event);
+        } catch (err) {
+          logger.error("Error in sequential event processing", {
+            runId,
+            type: event.type,
+            error: err.message,
+            stack: err.stack
+          });
+        } finally {
+          const existingTimer = cleanupTimers.get(runId);
+          if (existingTimer) {
+            clearTimeout(existingTimer);
+          }
+          const timer = setTimeout(() => {
+            if (flowProcessingChain.get(runId) === currentProcessing) {
+              flowProcessingChain.delete(runId);
+              cleanupTimers.delete(runId);
+            }
+          }, 6e4);
+          cleanupTimers.set(runId, timer);
+        }
+      });
+      flowProcessingChain.set(runId, currentProcessing);
+      return currentProcessing;
+    };
     const eventTypes = [
       "flow.start",
       "flow.completed",
@@ -455,29 +925,82 @@ export function createFlowWiring() {
       "step.completed",
       "step.failed",
       "step.retry",
+      "await.registered",
+      "await.resolved",
+      "await.timeout",
       "log",
       "emit",
       "state"
     ];
     for (const type of eventTypes) {
-      unsubs.push(bus.onType(type, handlePersistence));
-    }
-    for (const type of eventTypes) {
-      unsubs.push(bus.onType(type, handleOrchestration));
+      unsubs.push(bus.onType(type, processEventSequentially));
     }
     const config = useRuntimeConfig();
-    const flowConfig = config.nvent.flows;
+    const flowConfig = config.nvent.flow || {};
     stallDetector = createStallDetector(store, flowConfig.stallDetection);
-    if (flowConfig.stallDetection.enabled) {
-      stallDetector.start();
-      logger.info("Stall detector started");
+    if (flowConfig.stallDetection?.enabled) {
+      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)");
+      }
     }
   }
-  function stop() {
+  async function stop() {
     const logger = useNventLogger("flow-wiring");
     if (stallDetector) {
-      stallDetector.stop();
-      stallDetector = void 0;
+      try {
+        await stallDetector.stop();
+        stallDetector = void 0;
+      } catch (error) {
+        logger.error("Error stopping stall detector", {
+          error: error.message
+        });
+      }
     }
     for (const u of unsubs.splice(0)) {
       try {
@@ -485,8 +1008,13 @@ export function createFlowWiring() {
       } catch {
       }
     }
+    publishingTerminalEvents.clear();
+    for (const timer of cleanupTimers.values()) {
+      clearTimeout(timer);
+    }
+    cleanupTimers.clear();
+    flowProcessingChain.clear();
     wired = false;
-    logger.debug("Flow wiring stopped");
   }
   return { start, stop };
 }