nvent 0.4.4 → 0.5.0

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

@@ -0,0 +1,1020 @@
+import { getEventBus } from "../eventBus.js";
+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) {
+    return true;
+  }
+  return step.subscribes.every((sub) => {
+    if (emittedEvents.has(sub)) return true;
+    const [prefix, value] = sub.split(":");
+    if (prefix === "step" && value) {
+      return completedSteps.has(value);
+    }
+    return false;
+  });
+}
+export async function checkAndTriggerPendingSteps(flowName, runId, store) {
+  const logger = useNventLogger("flow-wiring");
+  try {
+    const analyzedFlows = $useAnalyzedFlows();
+    const registry = $useFunctionRegistry();
+    const queue = useQueueAdapter();
+    const { StoreSubjects } = useStreamTopics();
+    const flowDef = analyzedFlows.find((f) => f.id === flowName);
+    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 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];
+        const stepMeta = flowRegistry?.steps?.[stepName];
+        if (stepMeta?.queue) {
+          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,
+            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
+          );
+          const defaultOpts = worker?.queue?.defaultJobOptions || {};
+          const opts = { ...defaultOpts, jobId };
+          try {
+            await queue.enqueue(stepMeta.queue, { name: stepName, data: payload, opts });
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (err) {
+    logger.warn("Failed to check pending steps", {
+      flowName,
+      runId,
+      error: err?.message
+    });
+  }
+}
+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();
+  const failedSteps = /* @__PURE__ */ new Set();
+  const retriedSteps = /* @__PURE__ */ new Map();
+  let startedAt = 0;
+  let completedAt = 0;
+  for (const event of events) {
+    if (event.type === "flow.start") {
+      startedAt = typeof event.ts === "string" ? new Date(event.ts).getTime() : 0;
+    }
+    if (event.type === "flow.cancel") {
+      completedAt = typeof event.ts === "string" ? new Date(event.ts).getTime() : Date.now();
+    }
+    if (event.type === "step.completed" && "stepName" in event) {
+      completedSteps.add(event.stepName);
+    }
+    if (event.type === "step.retry" && "stepName" in event) {
+      const currentAttempts = retriedSteps.get(event.stepName) || 0;
+      retriedSteps.set(event.stepName, currentAttempts + 1);
+    }
+    if (event.type === "step.failed" && "stepName" in event) {
+      failedSteps.add(event.stepName);
+    }
+  }
+  const finalFailedSteps = /* @__PURE__ */ new Set();
+  for (const stepName of Array.from(failedSteps)) {
+    let lastRetryIndex = -1;
+    let lastFailedIndex = -1;
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      if ("stepName" in event && event.stepName === stepName) {
+        if (event.type === "step.retry") {
+          lastRetryIndex = i;
+        }
+        if (event.type === "step.failed") {
+          lastFailedIndex = i;
+        }
+      }
+    }
+    if (lastFailedIndex > lastRetryIndex) {
+      finalFailedSteps.add(stepName);
+    }
+  }
+  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 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 {
+      status: "canceled",
+      totalSteps,
+      completedSteps: completedSteps.size,
+      startedAt,
+      completedAt
+    };
+  }
+  if (hasBlockingFailure || hasCriticalLayerFailure) {
+    return {
+      status: "failed",
+      totalSteps,
+      completedSteps: completedSteps.size,
+      startedAt,
+      completedAt: Date.now()
+    };
+  }
+  const allStepsTerminal = allSteps.every(
+    (step) => completedSteps.has(step) || finalFailedSteps.has(step)
+  );
+  let status = "running";
+  if (allStepsTerminal) {
+    status = "completed";
+    completedAt = Date.now();
+  }
+  return {
+    status,
+    totalSteps,
+    completedSteps: completedSteps.size,
+    startedAt,
+    completedAt
+  };
+}
+export function createFlowWiring() {
+  const bus = getEventBus();
+  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 { StoreSubjects } = useStreamTopics();
+      const indexKey = StoreSubjects.flowRunIndex(flowName);
+      if (!store.index.add) {
+        throw new Error("StoreAdapter does not support indexAdd");
+      }
+      await store.index.add(indexKey, flowId, timestamp, metadata);
+    } catch (err) {
+      logger.error("Failed to index run", { error: err });
+    }
+  };
+  const flowProcessingChain = /* @__PURE__ */ new Map();
+  const cleanupTimers = /* @__PURE__ */ new Map();
+  async function start() {
+    if (wired) return;
+    wired = true;
+    const logger = useNventLogger("flow-wiring");
+    const { StoreSubjects } = useStreamTopics();
+    logger.info("Flow wiring starting");
+    const store = useStoreAdapter();
+    if (!store || !store.stream.append) {
+      logger.error("StoreAdapter not properly initialized or missing append method", {
+        hasStore: !!store,
+        hasAppend: !!(store && store.stream.append)
+      });
+      throw new Error("StoreAdapter not initialized");
+    }
+    const handlePersistence = async (e) => {
+      try {
+        if (e.id && e.ts) {
+          return;
+        }
+        const runId = e.runId;
+        if (!runId) {
+          return;
+        }
+        const flowName = e.flowName;
+        if (!flowName) {
+          return;
+        }
+        const streamName = StoreSubjects.flowRun(runId);
+        if (!e.type) {
+          logger.error("Event missing type field", { event: e });
+          return;
+        }
+        const eventData = {
+          type: e.type,
+          runId: e.runId,
+          flowName: e.flowName,
+          data: e.data
+        };
+        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.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,
+            runId,
+            id: persistedEvent.id
+          });
+        } else {
+          logger.debug("Stored event", {
+            type: e.type,
+            flowName,
+            runId,
+            stepName: "stepName" in e ? e.stepName : void 0,
+            id: persistedEvent.id
+          });
+        }
+      } catch (err) {
+        logger.error("ERROR persisting event", {
+          type: e.type,
+          runId: e.runId,
+          flowName: e.flowName,
+          error: err?.message
+        });
+      }
+    };
+    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) {
+          return;
+        }
+        if (e.type === "flow.completed" || e.type === "flow.failed") {
+          return;
+        }
+        const runId = e.runId;
+        if (!runId) return;
+        const flowName = e.flowName;
+        if (!flowName) return;
+        const streamName = StoreSubjects.flowRun(runId);
+        const indexKey = StoreSubjects.flowRunIndex(flowName);
+        if (e.type === "flow.start") {
+          const timestamp = Date.now();
+          await indexFlowRun(flowName, runId, timestamp, {
+            status: "running",
+            startedAt: timestamp,
+            lastActivityAt: timestamp,
+            // Initialize for stall detection
+            stepCount: 0,
+            completedSteps: 0,
+            emittedEvents: {}
+            // Object for atomic updates
+          });
+        }
+        if (e.type === "flow.cancel") {
+          try {
+            if (store.index.updateWithRetry) {
+              await store.index.updateWithRetry(indexKey, runId, {
+                status: "canceled",
+                completedAt: Date.now()
+              });
+              logger.info("Marked flow as canceled", { flowName, runId });
+            }
+          } catch (err) {
+            logger.warn("Failed to update canceled status", {
+              flowName,
+              runId,
+              error: err?.message
+            });
+          }
+        }
+        if (e.type === "step.started" || e.type === "step.completed" || e.type === "step.failed" || e.type === "step.retry") {
+          if (stallDetector) {
+            await stallDetector.updateActivity(flowName, runId);
+          }
+        }
+        if (e.type === "step.completed") {
+          try {
+            if (store.index.increment) {
+              const newCount = await store.index.increment(indexKey, runId, "completedSteps", 1);
+              logger.debug("Incremented completedSteps", {
+                flowName,
+                runId,
+                stepName: "stepName" in e ? e.stepName : "unknown",
+                newCount
+              });
+            }
+          } catch (err) {
+            logger.warn("Failed to update completedSteps", {
+              flowName,
+              runId,
+              error: err?.message
+            });
+          }
+        }
+        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.index.updateWithRetry) {
+                logger.warn("StoreAdapter does not support indexUpdateWithRetry");
+                return;
+              }
+              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,
+                runId,
+                event: eventName,
+                error: err?.message
+              });
+            }
+          }
+        }
+        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") {
+          try {
+            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 entryStepDef = flowDef.entry;
+              const analysis = analyzeFlowCompletion(flowDef.steps, entryStepName, allEvents, entryStepDef);
+              const updateMetadata = {
+                status: analysis.status,
+                stepCount: analysis.totalSteps
+              };
+              if (analysis.status !== "running" && analysis.completedAt) {
+                updateMetadata.completedAt = analysis.completedAt;
+              }
+              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);
+              }
+              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("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,
+                    eventType
+                  });
+                  await bus.publish({
+                    type: eventType,
+                    runId,
+                    flowName,
+                    data: {}
+                  });
+                }
+              }
+            }
+          } catch (err) {
+            logger.warn("Failed to analyze flow completion", {
+              flowName,
+              runId,
+              error: err?.message
+            });
+          }
+        }
+      } catch (err) {
+        logger.error("ERROR handling event", {
+          type: e.type,
+          runId: e.runId,
+          flowName: e.flowName,
+          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",
+      "flow.failed",
+      "flow.cancel",
+      "step.started",
+      "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, processEventSequentially));
+    }
+    const config = useRuntimeConfig();
+    const flowConfig = config.nvent.flow || {};
+    stallDetector = createStallDetector(store, flowConfig.stallDetection);
+    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)");
+      }
+    }
+  }
+  async function stop() {
+    const logger = useNventLogger("flow-wiring");
+    if (stallDetector) {
+      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 {
+        u();
+      } catch {
+      }
+    }
+    publishingTerminalEvents.clear();
+    for (const timer of cleanupTimers.values()) {
+      clearTimeout(timer);
+    }
+    cleanupTimers.clear();
+    flowProcessingChain.clear();
+    wired = false;
+  }
+  return { start, stop };
+}