nvent 0.4.3 → 0.4.5

package/dist/runtime/events/utils/stallDetector.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Flow Stall Detection System
+ *
+ * Detects and marks flows that have been in "running" state for too long without activity.
+ * Uses a hybrid approach:
+ * 1. Lazy detection: Check stall status when flows are queried (zero overhead)
+ * 2. Periodic cleanup: Background job that checks all running flows periodically (safety net)
+ *
+ * A flow is considered "stalled" when:
+ * - Status is "running"
+ * - No activity (step events) for longer than STALL_TIMEOUT
+ * - lastActivityAt timestamp is older than threshold
+ */
+import type { StoreAdapter } from '../../adapters/interfaces/store.js';
+export interface StallDetectorConfig {
+    /**
+     * Time in milliseconds after which a running flow without activity is considered stalled
+     * @default 1800000 (30 minutes)
+     */
+    stallTimeout?: number;
+    /**
+     * Interval in milliseconds for periodic stall checks
+     * @default 900000 (15 minutes)
+     */
+    checkInterval?: number;
+    /**
+     * Enable periodic background checks
+     * Set to false to use only lazy detection
+     * @default true
+     */
+    enablePeriodicCheck?: boolean;
+}
+export type FlowStatus = 'running' | 'completed' | 'failed' | 'canceled' | 'stalled';
+export interface FlowActivity {
+    runId: string;
+    flowName: string;
+    status: FlowStatus;
+    startedAt: number;
+    lastActivityAt: number;
+    metadata?: any;
+}
+export declare class FlowStallDetector {
+    private store;
+    private config;
+    private logger;
+    private intervalId?;
+    private started;
+    constructor(store: StoreAdapter, config?: StallDetectorConfig);
+    /**
+     * Start the periodic stall detector
+     * Should be called once per instance after adapters are initialized
+     */
+    start(): void;
+    /**
+     * Stop the periodic stall detector
+     */
+    stop(): void;
+    /**
+     * Update activity timestamp for a flow
+     * Should be called on every step event (started, completed, failed, retry)
+     */
+    updateActivity(flowName: string, runId: string): Promise<void>;
+    /**
+     * Check if a specific flow is stalled (lazy detection)
+     * Returns true if the flow should be marked as stalled
+     */
+    isStalled(flowName: string, runId: string): Promise<boolean>;
+    /**
+     * Mark a flow as stalled
+     * Emits a flow.stalled event and updates the flow status
+     */
+    markAsStalled(flowName: string, runId: string, reason?: string): Promise<void>;
+    /**
+     * Check all running flows and mark stalled ones
+     * This is called by the periodic background job
+     *
+     * Note: This method requires knowledge of which flows exist.
+     * For now, we'll need to pass flow names to check, or iterate known flows from registry.
+     */
+    checkFlowsForStalls(flowNames: string[]): Promise<void>;
+    /**
+     * Internal method for periodic checks
+     * Gets flow names from registry and checks them
+     */
+    private checkAllRunningFlows;
+    /**
+     * Get stall detector statistics
+     */
+    getStats(): {
+        enabled: boolean;
+        periodicCheckEnabled: boolean;
+        stallTimeout: number;
+        checkInterval: number;
+    };
+}
+/**
+ * Create and configure a flow stall detector
+ */
+export declare function createStallDetector(store: StoreAdapter, config?: StallDetectorConfig): FlowStallDetector;

package/dist/runtime/events/utils/stallDetector.js

@@ -0,0 +1,237 @@
+import { useNventLogger, useStreamTopics } from "#imports";
+const DEFAULT_STALL_TIMEOUT = 30 * 60 * 1e3;
+const DEFAULT_CHECK_INTERVAL = 15 * 60 * 1e3;
+export class FlowStallDetector {
+  store;
+  config;
+  logger = useNventLogger("stall-detector");
+  intervalId;
+  started = false;
+  constructor(store, config = {}) {
+    this.store = store;
+    this.config = {
+      stallTimeout: config.stallTimeout ?? DEFAULT_STALL_TIMEOUT,
+      checkInterval: config.checkInterval ?? DEFAULT_CHECK_INTERVAL,
+      enablePeriodicCheck: config.enablePeriodicCheck ?? true
+    };
+  }
+  /**
+   * Start the periodic stall detector
+   * Should be called once per instance after adapters are initialized
+   */
+  start() {
+    if (this.started) {
+      this.logger.warn("Stall detector already started");
+      return;
+    }
+    this.started = true;
+    if (this.config.enablePeriodicCheck) {
+      this.logger.info("Starting periodic stall detector", {
+        stallTimeout: `${this.config.stallTimeout / 1e3}s`,
+        checkInterval: `${this.config.checkInterval / 1e3}s`
+      });
+      setTimeout(() => {
+        this.checkAllRunningFlows();
+      }, 60 * 1e3);
+      this.intervalId = setInterval(() => {
+        this.checkAllRunningFlows();
+      }, this.config.checkInterval);
+    } else {
+      this.logger.info("Periodic stall detector disabled, using lazy detection only");
+    }
+  }
+  /**
+   * Stop the periodic stall detector
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+      this.logger.info("Stopped periodic stall detector");
+    }
+    this.started = false;
+  }
+  /**
+   * Update activity timestamp for a flow
+   * Should be called on every step event (started, completed, failed, retry)
+   */
+  async updateActivity(flowName, runId) {
+    const { SubjectPatterns } = useStreamTopics();
+    const indexKey = SubjectPatterns.flowRunIndex(flowName);
+    try {
+      if (!this.store.indexUpdate) {
+        this.logger.warn("Store does not support indexUpdate, cannot update activity");
+        return;
+      }
+      await this.store.indexUpdate(indexKey, runId, {
+        lastActivityAt: Date.now()
+      });
+    } catch (error) {
+      this.logger.warn("Failed to update flow activity", {
+        flowName,
+        runId,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Check if a specific flow is stalled (lazy detection)
+   * Returns true if the flow should be marked as stalled
+   */
+  async isStalled(flowName, runId) {
+    const { SubjectPatterns } = useStreamTopics();
+    const indexKey = SubjectPatterns.flowRunIndex(flowName);
+    try {
+      if (!this.store.indexGet) return false;
+      const flowEntry = await this.store.indexGet(indexKey, runId);
+      if (!flowEntry?.metadata) return false;
+      if (flowEntry.metadata.status !== "running") return false;
+      const lastActivity = flowEntry.metadata.lastActivityAt || flowEntry.metadata.startedAt || 0;
+      const timeSinceActivity = Date.now() - lastActivity;
+      if (timeSinceActivity > this.config.stallTimeout) {
+        this.logger.info("Flow detected as stalled (lazy check)", {
+          flowName,
+          runId,
+          timeSinceActivity: `${Math.round(timeSinceActivity / 1e3)}s`,
+          stallTimeout: `${this.config.stallTimeout / 1e3}s`
+        });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logger.warn("Failed to check if flow is stalled", {
+        flowName,
+        runId,
+        error: error.message
+      });
+      return false;
+    }
+  }
+  /**
+   * Mark a flow as stalled
+   * Emits a flow.stalled event and updates the flow status
+   */
+  async markAsStalled(flowName, runId, reason = "No activity timeout") {
+    const { SubjectPatterns } = useStreamTopics();
+    const indexKey = SubjectPatterns.flowRunIndex(flowName);
+    try {
+      if (!this.store.indexGet) {
+        this.logger.warn("Store does not support indexGet, cannot mark as stalled");
+        return;
+      }
+      const flowEntry = await this.store.indexGet(indexKey, runId);
+      if (!flowEntry?.metadata) return;
+      if (flowEntry.metadata.status !== "running") return;
+      if (this.store.indexUpdate) {
+        await this.store.indexUpdate(indexKey, runId, {
+          status: "stalled",
+          stalledAt: Date.now(),
+          stallReason: reason
+        });
+      }
+      const streamName = SubjectPatterns.flowRun(runId);
+      await this.store.append(streamName, {
+        type: "flow.stalled",
+        runId,
+        flowName,
+        data: {
+          reason
+        }
+      });
+      this.logger.info("Marked flow as stalled", {
+        flowName,
+        runId,
+        reason
+      });
+    } catch (error) {
+      this.logger.error("Failed to mark flow as stalled", {
+        flowName,
+        runId,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Check all running flows and mark stalled ones
+   * This is called by the periodic background job
+   *
+   * Note: This method requires knowledge of which flows exist.
+   * For now, we'll need to pass flow names to check, or iterate known flows from registry.
+   */
+  async checkFlowsForStalls(flowNames) {
+    this.logger.debug("Running periodic stall check", { flows: flowNames.length });
+    try {
+      if (!this.store.indexGet || !this.store.indexRead) {
+        this.logger.warn("Store does not support required index operations");
+        return;
+      }
+      const { SubjectPatterns } = useStreamTopics();
+      let checkedCount = 0;
+      let stalledCount = 0;
+      for (const flowName of flowNames) {
+        const indexKey = SubjectPatterns.flowRunIndex(flowName);
+        const entries = await this.store.indexRead(indexKey, { limit: 1e3 });
+        for (const entry of entries) {
+          if (!entry.metadata) continue;
+          checkedCount++;
+          if (entry.metadata.status !== "running") continue;
+          const lastActivity = entry.metadata.lastActivityAt || entry.metadata.startedAt || 0;
+          const timeSinceActivity = Date.now() - lastActivity;
+          if (timeSinceActivity > this.config.stallTimeout) {
+            await this.markAsStalled(flowName, entry.id, "Periodic check detected no activity");
+            stalledCount++;
+          }
+        }
+      }
+      if (stalledCount > 0) {
+        this.logger.info("Periodic stall check completed", {
+          checked: checkedCount,
+          stalled: stalledCount
+        });
+      } else {
+        this.logger.debug("Periodic stall check completed", {
+          checked: checkedCount,
+          stalled: 0
+        });
+      }
+    } catch (error) {
+      this.logger.error("Failed to run periodic stall check", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Internal method for periodic checks
+   * Gets flow names from registry and checks them
+   */
+  async checkAllRunningFlows() {
+    try {
+      const { $useAnalyzedFlows } = await import("#imports");
+      const analyzedFlows = $useAnalyzedFlows();
+      const flowNames = analyzedFlows.map((f) => f.id).filter(Boolean);
+      if (flowNames.length === 0) {
+        this.logger.debug("No flows registered, skipping stall check");
+        return;
+      }
+      await this.checkFlowsForStalls(flowNames);
+    } catch (error) {
+      this.logger.error("Failed to run periodic stall check", {
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Get stall detector statistics
+   */
+  getStats() {
+    return {
+      enabled: this.started,
+      periodicCheckEnabled: this.config.enablePeriodicCheck,
+      stallTimeout: this.config.stallTimeout,
+      checkInterval: this.config.checkInterval
+    };
+  }
+}
+export function createStallDetector(store, config) {
+  return new FlowStallDetector(store, config);
+}

package/dist/runtime/{server-utils/events → events}/wiring/flowWiring.d.ts

@@ -1,8 +1,3 @@
-import type { EventStoreAdapter } from '../types.js';
-import type { EventRecord } from '../../types.js';
-export interface FlowWiringDeps {
-    adapter: EventStoreAdapter;
-}
 /**
  * Check if all dependencies for a step are met
  * Returns true if all subscriptions have been emitted or completed
@@ -12,8 +7,8 @@ export declare function checkPendingStepTriggers(step: any, emittedEvents: Set<s
  * Analyze flow completion status from events
  * Returns status, step counts, and timestamps
  */
-export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, entryStep: string | undefined, events: EventRecord[]): {
-    status: 'running' | 'completed' | 'failed';
+export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, entryStep: string | undefined, events: any[]): {
+    status: 'running' | 'completed' | 'failed' | 'canceled';
     totalSteps: number;
     completedSteps: number;
     startedAt: number;
@@ -27,7 +22,7 @@ export declare function analyzeFlowCompletion(flowSteps: Record<string, any>, en
  *
  * Events arrive as "ingress" (no id/ts) and are persisted to `nq:flow:{runId}` streams.
  */
-export declare function createFlowWiring(deps: FlowWiringDeps): {
+export declare function createFlowWiring(): {
     start: () => void;
     stop: () => void;
 };

package/dist/runtime/{server-utils/events → events}/wiring/flowWiring.js

@@ -1,5 +1,6 @@
 import { getEventBus } from "../eventBus.js";
-import { useEventStore, $useAnalyzedFlows, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
+import { useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useQueueRegistry, useStreamTopics, useRuntimeConfig } from "#imports";
+import { createStallDetector } from "../utils/stallDetector.js";
 export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   if (!step.subscribes || step.subscribes.length === 0) {
     return true;
@@ -18,15 +19,22 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
   try {
     const analyzedFlows = $useAnalyzedFlows();
     const registry = $useQueueRegistry();
-    const { enqueue } = useQueue();
+    const queue = useQueueAdapter();
+    const { SubjectPatterns } = useStreamTopics();
     const flowDef = analyzedFlows.find((f) => f.id === flowName);
     if (!flowDef?.steps) return;
-    const indexKey = store.names().flowIndex(flowName);
+    const indexKey = SubjectPatterns.flowRunIndex(flowName);
+    if (!store.indexGet) return;
     const flowEntry = await store.indexGet(indexKey, runId);
     if (!flowEntry?.metadata) return;
-    const emittedEvents = new Set(flowEntry.metadata.emittedEvents || []);
-    const streamName = store.names().flow(runId);
+    const streamName = SubjectPatterns.flowRun(runId);
     const allEvents = await store.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 completedSteps = /* @__PURE__ */ new Set();
     for (const event of allEvents) {
       if (event.type === "step.completed" && "stepName" in event) {
@@ -58,8 +66,13 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
             // Keyed by event name
           };
           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 enqueue(stepMeta.queue, { name: stepName, data: payload, opts: { jobId } });
+            await queue.enqueue(stepMeta.queue, { name: stepName, data: payload, opts });
             logger.debug("Triggered pending step", {
               flowName,
               runId,
@@ -80,6 +93,7 @@ async function checkAndTriggerPendingSteps(flowName, runId, store) {
   }
 }
 export function analyzeFlowCompletion(flowSteps, entryStep, events) {
+  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();
@@ -90,6 +104,9 @@ export function analyzeFlowCompletion(flowSteps, entryStep, 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);
     }
@@ -102,7 +119,7 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
     }
   }
   const finalFailedSteps = /* @__PURE__ */ new Set();
-  for (const stepName of failedSteps) {
+  for (const stepName of Array.from(failedSteps)) {
     let lastRetryIndex = -1;
     let lastFailedIndex = -1;
     for (let i = 0; i < events.length; i++) {
@@ -124,7 +141,7 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
   const hasFinalFailures = finalFailedSteps.size > 0;
   let hasBlockingFailure = false;
   if (hasFinalFailures) {
-    for (const failedStepName of finalFailedSteps) {
+    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)) {
@@ -146,6 +163,15 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
       if (hasBlockingFailure) break;
     }
   }
+  if (isCanceled) {
+    return {
+      status: "canceled",
+      totalSteps,
+      completedSteps: completedSteps.size,
+      startedAt,
+      completedAt
+    };
+  }
   if (hasBlockingFailure) {
     return {
       status: "failed",
@@ -171,17 +197,20 @@ export function analyzeFlowCompletion(flowSteps, entryStep, events) {
     completedAt
   };
 }
-export function createFlowWiring(deps) {
-  const { adapter } = deps;
+export function createFlowWiring() {
   const bus = getEventBus();
   const unsubs = [];
   let wired = false;
+  let stallDetector;
   const indexFlowRun = async (flowName, flowId, timestamp, metadata) => {
     const logger = useNventLogger("flow-wiring");
     try {
-      const store = useEventStore();
-      const names = store.names();
-      const indexKey = names.flowIndex(flowName);
+      const store = useStoreAdapter();
+      const { SubjectPatterns } = useStreamTopics();
+      const indexKey = SubjectPatterns.flowRunIndex(flowName);
+      if (!store.indexAdd) {
+        throw new Error("StoreAdapter does not support indexAdd");
+      }
       await store.indexAdd(indexKey, flowId, timestamp, metadata);
       logger.debug("Indexed run", { flowName, flowId, indexKey, timestamp, metadata });
     } catch (err) {
@@ -192,8 +221,15 @@ export function createFlowWiring(deps) {
     if (wired) return;
     wired = true;
     const logger = useNventLogger("flow-wiring");
-    const store = useEventStore();
-    const names = store.names();
+    const { SubjectPatterns } = useStreamTopics();
+    const store = useStoreAdapter();
+    if (!store || !store.append) {
+      logger.error("StoreAdapter not properly initialized or missing append method", {
+        hasStore: !!store,
+        hasAppend: !!(store && store.append)
+      });
+      throw new Error("StoreAdapter not initialized");
+    }
     const handlePersistence = async (e) => {
       try {
         if (e.id && e.ts) {
@@ -207,7 +243,11 @@ export function createFlowWiring(deps) {
         if (!flowName) {
           return;
         }
-        const streamName = names.flow(runId);
+        const streamName = SubjectPatterns.flowRun(runId);
+        if (!e.type) {
+          logger.error("Event missing type field", { event: e });
+          return;
+        }
         const eventData = {
           type: e.type,
           runId: e.runId,
@@ -217,19 +257,22 @@ export function createFlowWiring(deps) {
         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;
-        await adapter.append(streamName, eventData);
+        const persistedEvent = await store.append(streamName, eventData);
+        await bus.publish(persistedEvent);
         if (e.type === "flow.completed" || e.type === "flow.failed") {
-          logger.info("Stored terminal event to stream", {
+          logger.info("Stored terminal event", {
             type: e.type,
             flowName,
-            runId
+            runId,
+            id: persistedEvent.id
           });
         } else {
-          logger.debug("Stored event to stream", {
+          logger.debug("Stored event", {
             type: e.type,
             flowName,
             runId,
-            stepName: "stepName" in e ? e.stepName : void 0
+            stepName: "stepName" in e ? e.stepName : void 0,
+            id: persistedEvent.id
           });
         }
       } catch (err) {
@@ -253,27 +296,53 @@ export function createFlowWiring(deps) {
         if (!runId) return;
         const flowName = e.flowName;
         if (!flowName) return;
-        const streamName = names.flow(runId);
-        const indexKey = names.flowIndex(flowName);
+        const streamName = SubjectPatterns.flowRun(runId);
+        const indexKey = SubjectPatterns.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: []
           });
         }
-        if (e.type === "step.completed") {
+        if (e.type === "flow.cancel") {
           try {
-            const newCount = await store.indexIncrement(indexKey, runId, "completedSteps", 1);
-            logger.debug("Incremented completedSteps", {
+            if (store.indexUpdateWithRetry) {
+              await store.indexUpdateWithRetry(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,
-              stepName: "stepName" in e ? e.stepName : "unknown",
-              newCount
+              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.indexIncrement) {
+              const newCount = await store.indexIncrement(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,
@@ -283,12 +352,15 @@ export function createFlowWiring(deps) {
           }
         }
         if (e.type === "emit") {
-          const emitEvent = e;
-          const eventName = emitEvent.data?.name || emitEvent.data?.topic;
+          const eventName = e.data?.name || e.data?.topic;
           if (!eventName) {
-            logger.warn("Emit event missing name/topic", { flowName, runId, data: emitEvent.data });
+            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");
+                return;
+              }
               const currentEntry = await store.indexGet(indexKey, runId);
               const emittedEvents = (currentEntry?.metadata?.emittedEvents || []).filter((item) => item != null && typeof item === "string");
               if (!emittedEvents.includes(eventName)) {
@@ -310,7 +382,6 @@ export function createFlowWiring(deps) {
                 error: err?.message
               });
             }
-            await checkAndTriggerPendingSteps(flowName, runId, store);
           }
         }
         if (e.type === "step.completed" || e.type === "step.failed") {
@@ -330,12 +401,12 @@ export function createFlowWiring(deps) {
               if (analysis.status !== "running" && analysis.completedAt) {
                 updateMetadata.completedAt = analysis.completedAt;
               }
-              await store.indexUpdateWithRetry(indexKey, runId, updateMetadata);
+              if (store.indexUpdateWithRetry) {
+                await store.indexUpdateWithRetry(indexKey, runId, updateMetadata);
+              }
               if (analysis.status === "completed" || analysis.status === "failed") {
                 const eventType = analysis.status === "completed" ? "flow.completed" : "flow.failed";
-                const terminalEventExists = allEvents.some(
-                  (evt) => evt.type === "flow.completed" || evt.type === "flow.failed"
-                );
+                const terminalEventExists = allEvents.some((evt) => evt.type === "flow.completed" || evt.type === "flow.failed");
                 if (terminalEventExists) {
                   logger.debug("Terminal event already exists, skipping publish", {
                     flowName,
@@ -379,6 +450,7 @@ export function createFlowWiring(deps) {
       "flow.start",
       "flow.completed",
       "flow.failed",
+      "flow.cancel",
       "step.started",
       "step.completed",
       "step.failed",
@@ -393,9 +465,20 @@ export function createFlowWiring(deps) {
     for (const type of eventTypes) {
       unsubs.push(bus.onType(type, handleOrchestration));
     }
+    const config = useRuntimeConfig();
+    const flowConfig = config.nvent.flows;
+    stallDetector = createStallDetector(store, flowConfig.stallDetection);
+    if (flowConfig.stallDetection.enabled) {
+      stallDetector.start();
+      logger.info("Stall detector started");
+    }
   }
   function stop() {
     const logger = useNventLogger("flow-wiring");
+    if (stallDetector) {
+      stallDetector.stop();
+      stallDetector = void 0;
+    }
     for (const u of unsubs.splice(0)) {
       try {
         u();