nvent 0.5.15 → 1.0.0-alpha.2

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

@@ -1,1258 +0,0 @@
-import { getEventBus } from "../eventBus.js";
-import { useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useFunctionRegistry, useStreamTopics, useRuntimeConfig, useScheduler } from "#imports";
-import { createStallDetector } from "../utils/stallDetector.js";
-import { SYSTEM_HANDLERS } from "../../worker/system/index.js";
-export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
-  if (!step.subscribes || step.subscribes.length === 0) {
-    return true;
-  }
-  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 awaitBeforeKey = `${stepName}:before`;
-      const awaitState = flowEntry?.metadata?.awaitingSteps?.[awaitBeforeKey];
-      if (awaitState && awaitState.status === "awaiting") continue;
-      if (awaitState && awaitState.status === "timeout") continue;
-      const isDependencyAwaiting = step.subscribes.some((sub) => {
-        const emitEvent = allEvents.find(
-          (evt) => evt.type === "emit" && evt.data?.name === sub
-        );
-        if (!emitEvent) return false;
-        const emitStepName = emitEvent.stepName;
-        if (!emitStepName) {
-          return false;
-        }
-        const awaitAfterKey = `${emitStepName}:after`;
-        const awaitState2 = awaitingSteps[awaitAfterKey];
-        if (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 && evt.position === "after"
-            );
-            if (!awaitResolved) return true;
-          }
-        }
-        return false;
-      });
-      if (isDependencyAwaiting) continue;
-      const canTrigger = checkPendingStepTriggers(step, emittedEvents, completedSteps);
-      if (canTrigger && step.awaitBefore) {
-        if (awaitState?.status === "awaiting") continue;
-        if (awaitState?.status !== "resolved") {
-          try {
-            const emitData = {};
-            const subscribes = step.subscribes || [];
-            for (const sub of subscribes) {
-              const emitEvent = allEvents.find(
-                (evt) => evt.type === "emit" && evt.data?.name === sub
-              );
-              if (emitEvent && emitEvent.data?.payload !== void 0) {
-                emitData[sub] = emitEvent.data.payload;
-              }
-            }
-            const payload = {
-              flowId: runId,
-              flowName,
-              stepName,
-              position: "before",
-              awaitConfig: step.awaitBefore,
-              input: emitData
-            };
-            const jobId = `${runId}__${stepName}__await-register-before`;
-            const flowRegistry = (registry?.flows || {})[flowName];
-            const stepMeta = flowRegistry?.steps?.[stepName];
-            let stepQueue = stepMeta?.queue;
-            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
-              stepQueue = flowRegistry.entry.queue;
-            }
-            if (!stepQueue && registry?.workers) {
-              const worker = registry.workers.find((w) => {
-                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
-                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
-                return flowNames.includes(flowName) && stepMatch;
-              });
-              stepQueue = worker?.queue?.name;
-            }
-            if (!stepQueue) {
-              logger.error("Cannot find queue for step", {
-                stepName,
-                flowName,
-                availableSteps: Object.keys(flowRegistry?.steps || {}),
-                entryStep: flowRegistry?.entry?.step
-              });
-              throw new Error(`Cannot register await: queue not found for step ${stepName} in flow ${flowName}`);
-            }
-            const analyzedAwaitStep = (flowDef.analyzed?.steps || {})[stepName];
-            const awaitStepTimeout = analyzedAwaitStep?.stepTimeout;
-            await queue.enqueue(stepQueue, {
-              name: SYSTEM_HANDLERS.AWAIT_REGISTER,
-              data: payload,
-              opts: { jobId, timeout: awaitStepTimeout }
-            });
-          } catch (err) {
-            logger.error("Failed to register awaitBefore pattern", {
-              flowName,
-              stepName,
-              error: err.message
-            });
-          }
-          continue;
-        }
-      }
-      const shouldEnqueueStep = canTrigger && (!step.awaitBefore || awaitState?.status === "resolved");
-      if (shouldEnqueueStep) {
-        const flowRegistry = (registry?.flows || {})[flowName];
-        const stepMeta = flowRegistry?.steps?.[stepName];
-        if (stepMeta?.queue) {
-          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
-          };
-          const isAwaitResuming = awaitState?.status === "resolved" && awaitState?.position === "before";
-          if (isAwaitResuming) {
-            payload.awaitResolved = true;
-            payload.awaitData = awaitState.triggerData;
-            payload.awaitPosition = "before";
-          }
-          const jobId = isAwaitResuming ? `${runId}__${stepName}__resumed` : `${runId}__${stepName}`;
-          const worker = registry?.workers?.find(
-            (w) => w?.flow?.step === stepName && w?.queue?.name === stepMeta.queue
-          );
-          const defaultOpts = worker?.queue?.defaultJobOptions || {};
-          const analyzedStep = (flowDef.analyzed?.steps || {})[stepName];
-          const stepTimeout = analyzedStep?.stepTimeout;
-          const opts = { ...defaultOpts, jobId, timeout: stepTimeout };
-          try {
-            await queue.enqueue(stepMeta.queue, { name: stepName, data: payload, opts });
-          } catch {
-          }
-        }
-      }
-    }
-  } 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") {
-          try {
-            const scheduler = useScheduler();
-            const flowJobs = await scheduler.getJobsByPattern(runId);
-            for (const job of flowJobs) {
-              await scheduler.unschedule(job.id);
-              logger.debug(`Unscheduled job for ${e.type} flow: ${job.id}`);
-            }
-            logger.debug(`Unscheduled ${flowJobs.length} scheduled jobs for ${e.type} flow runId '${runId}'`, {
-              jobs: flowJobs.map((j) => j.id)
-            });
-          } catch (error) {
-            logger.debug(`Could not unschedule jobs for runId '${runId}'`, {
-              error: error.message
-            });
-          }
-          const publishKey = `${runId}:terminal`;
-          setTimeout(() => {
-            try {
-              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) {
-            const previousStatus = e.data?.previousStatus;
-            if (previousStatus === "awaiting") {
-              await store.index.increment(flowIndexKey, flowName, "stats.awaiting", -1);
-            } else {
-              await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
-            }
-            await store.index.increment(flowIndexKey, flowName, "stats.cancel", 1);
-          }
-          if (store.index.updateWithRetry) {
-            await store.index.updateWithRetry(flowIndexKey, flowName, {
-              lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-          logger.debug("Updated flow stats for cancellation", { flowName, previousStatus: e.data?.previousStatus });
-        } else if (e.type === "flow.stalled") {
-          if (store.index.increment && e.data?.previousStatus) {
-            if (e.data.previousStatus === "awaiting") {
-              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) {
-        const errorMsg = err?.message || "";
-        if (!errorMsg.includes("Entry not found")) {
-          logger.warn("Failed to update flow stats", {
-            type: e.type,
-            flowName: e.flowName,
-            error: errorMsg
-          });
-        } else {
-          logger.debug("Flow entry not found (will be created)", {
-            type: e.type,
-            flowName: e.flowName
-          });
-        }
-      }
-    };
-    const handleOrchestration = async (e) => {
-      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
-          });
-          try {
-            const analyzedFlows = $useAnalyzedFlows();
-            const flowMeta = analyzedFlows.find((f) => f.id === flowName);
-            const stallTimeout = flowMeta?.analyzed?.stallTimeout || 30 * 60 * 1e3;
-            const scheduler = useScheduler();
-            const stallJobId = `stall-timeout:${runId}`;
-            await scheduler.schedule({
-              id: stallJobId,
-              name: `Stall Timeout - ${flowName}`,
-              type: "one-time",
-              executeAt: timestamp + stallTimeout,
-              handler: async () => {
-                if (stallDetector) {
-                  logger.info(`Per-flow stall timeout fired for '${flowName}' runId '${runId}'`);
-                  await stallDetector.markAsStalled(flowName, runId, "Stall timeout reached");
-                }
-              },
-              metadata: {
-                component: "stall-detector",
-                flowName,
-                runId
-              }
-            });
-            logger.debug(`Scheduled stall timeout for flow '${flowName}' runId '${runId}' in ${stallTimeout / 1e3}s`, { jobId: stallJobId });
-          } catch (error) {
-            logger.warn(`Failed to schedule stall timeout for flow '${flowName}' runId '${runId}'`, {
-              error: error.message
-            });
-          }
-        }
-        if (e.type === "flow.cancel") {
-          try {
-            if (store.index.updateWithRetry) {
-              await store.index.updateWithRetry(indexKey, runId, {
-                status: "canceled",
-                completedAt: Date.now()
-              });
-              logger.info("Marked flow as canceled", { flowName, runId });
-            }
-            const scheduler = useScheduler();
-            const flowJobs = await scheduler.getJobsByPattern(runId);
-            for (const job of flowJobs) {
-              await scheduler.unschedule(job.id);
-              logger.debug(`Unscheduled job for canceled flow: ${job.id}`);
-            }
-            logger.debug(`Unscheduled ${flowJobs.length} scheduled jobs for canceled flow runId '${runId}'`, {
-              jobs: flowJobs.map((j) => j.id)
-            });
-          } catch (err) {
-            logger.warn("Failed to update canceled status or unschedule flow jobs", {
-              flowName,
-              runId,
-              error: err?.message
-            });
-          }
-        }
-        if (e.type === "step.started" || e.type === "step.completed" || e.type === "step.failed" || e.type === "step.retry") {
-          try {
-            const scheduler = useScheduler();
-            const stallJobId = `stall-timeout:${runId}`;
-            const analyzedFlows = $useAnalyzedFlows();
-            const flowMeta = analyzedFlows.find((f) => f.id === flowName);
-            const stallTimeout = flowMeta?.analyzed?.stallTimeout || 30 * 60 * 1e3;
-            await scheduler.unschedule(stallJobId);
-            await scheduler.schedule({
-              id: stallJobId,
-              name: `Stall Timeout - ${flowName}`,
-              type: "one-time",
-              executeAt: Date.now() + stallTimeout,
-              handler: async () => {
-                if (stallDetector) {
-                  logger.info(`Per-flow stall timeout fired for '${flowName}' runId '${runId}'`);
-                  await stallDetector.markAsStalled(flowName, runId, "Stall timeout reached");
-                }
-              },
-              metadata: {
-                component: "stall-detector",
-                flowName,
-                runId,
-                stallTimeout
-              }
-            });
-            logger.debug(`Rescheduled stall timeout for flow '${flowName}' runId '${runId}' (activity: ${e.type})`);
-          } catch (error) {
-            logger.debug(`Could not reschedule stall timeout for flow '${flowName}' runId '${runId}'`, {
-              error: error.message
-            });
-          }
-        }
-        if (e.type === "step.completed") {
-          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) {
-              if (store.index.get) {
-                const currentEntry = await store.index.get(indexKey, runId);
-                const currentStatus = currentEntry?.metadata?.status;
-                if (currentStatus === "canceled") {
-                  logger.debug("Flow already canceled, skipping await registration", { flowName, runId, stepName });
-                  return;
-                }
-              }
-              const now = Date.now();
-              let timeoutAt;
-              if (awaitType === "time" && config2.delay) {
-                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 awaitKey = `${stepName}:${position}`;
-              const updatePayload = {
-                status: "awaiting",
-                // Set flow status to awaiting
-                awaitingSteps: {
-                  [awaitKey]: {
-                    status: "awaiting",
-                    stepName,
-                    // Keep stepName for queries
-                    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, position } = awaitEvent;
-          try {
-            if (store.index.get) {
-              const currentEntry = await store.index.get(indexKey, runId);
-              const currentStatus = currentEntry?.metadata?.status;
-              if (currentStatus === "canceled") {
-                logger.debug("Flow already canceled, skipping await resolution", { flowName, runId, stepName });
-                return;
-              }
-            }
-            if (store.index.updateWithRetry) {
-              const awaitKey = `${stepName}:${position}`;
-              await store.index.updateWithRetry(indexKey, runId, {
-                awaitingSteps: {
-                  [awaitKey]: {
-                    status: "resolved",
-                    stepName,
-                    // Keep stepName for queries
-                    triggerData,
-                    position
-                  }
-                }
-              });
-            }
-            const queue = useQueueAdapter();
-            const { StoreSubjects: StoreSubjects2 } = useStreamTopics();
-            const streamName2 = StoreSubjects2.flowRun(runId);
-            const inputData = {};
-            if (store.stream.read) {
-              const events = await store.stream.read(streamName2, { limit: 100 });
-              const registry2 = $useFunctionRegistry();
-              const flowRegistry2 = (registry2?.flows || {})[flowName];
-              const stepMeta2 = flowRegistry2?.steps?.[stepName];
-              const subscribes = stepMeta2?.subscribes || [];
-              for (const sub of subscribes) {
-                const emitEvent = events.find(
-                  (evt) => evt.type === "emit" && evt.data?.name === sub
-                );
-                if (emitEvent && emitEvent.data?.payload !== void 0) {
-                  inputData[sub] = emitEvent.data.payload;
-                }
-              }
-            }
-            const { SYSTEM_HANDLERS: SYSTEM_HANDLERS2 } = await import("../../worker/system/index.js");
-            const payload = {
-              flowId: runId,
-              flowName,
-              stepName,
-              position,
-              triggerData,
-              input: inputData
-            };
-            const jobId = `${runId}__${stepName}__await-resolve`;
-            const registry = $useFunctionRegistry();
-            const flowRegistry = (registry?.flows || {})[flowName];
-            const stepMeta = flowRegistry?.steps?.[stepName];
-            let stepQueue = stepMeta?.queue;
-            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
-              stepQueue = flowRegistry.entry.queue;
-            }
-            if (!stepQueue && registry?.workers) {
-              const worker = registry.workers.find((w) => {
-                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
-                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
-                return flowNames.includes(flowName) && stepMatch;
-              });
-              stepQueue = worker?.queue?.name;
-            }
-            if (!stepQueue) {
-              logger.error("Cannot find queue for step", {
-                stepName,
-                flowName,
-                availableSteps: Object.keys(flowRegistry?.steps || {}),
-                entryStep: flowRegistry?.entry?.step
-              });
-              throw new Error(`Cannot resolve await: queue not found for step ${stepName} in flow ${flowName}`);
-            }
-            await queue.enqueue(stepQueue, {
-              name: SYSTEM_HANDLERS2.AWAIT_RESOLVE,
-              data: payload,
-              opts: { jobId }
-            });
-            await checkAndTriggerPendingSteps(flowName, runId, store);
-          } catch (err) {
-            logger.error("Error handling await resolution", {
-              runId,
-              stepName,
-              error: err?.message
-            });
-          }
-        }
-        if (e.type === "await.timeout") {
-          const timeoutEvent = e;
-          const { stepName, timeoutAction, position, awaitType } = timeoutEvent;
-          const action = timeoutAction || "fail";
-          if (store.index.get) {
-            const currentEntry = await store.index.get(indexKey, runId);
-            const currentStatus = currentEntry?.metadata?.status;
-            if (currentStatus === "canceled") {
-              logger.debug("Flow already canceled, skipping await timeout handling", { flowName, runId, stepName });
-              return;
-            }
-          }
-          logger.warn("Await timeout occurred", {
-            runId,
-            stepName,
-            awaitType,
-            position,
-            action
-          });
-          try {
-            const queue = useQueueAdapter();
-            const { StoreSubjects: StoreSubjects2 } = useStreamTopics();
-            const streamName2 = StoreSubjects2.flowRun(runId);
-            const inputData = {};
-            if (store.stream.read) {
-              const events = await store.stream.read(streamName2, { limit: 100 });
-              const registry2 = $useFunctionRegistry();
-              const flowRegistry2 = (registry2?.flows || {})[flowName];
-              const stepMeta2 = flowRegistry2?.steps?.[stepName];
-              const subscribes = stepMeta2?.subscribes || [];
-              for (const sub of subscribes) {
-                const emitEvent = events.find(
-                  (evt) => evt.type === "emit" && evt.data?.name === sub
-                );
-                if (emitEvent && emitEvent.data?.payload !== void 0) {
-                  inputData[sub] = emitEvent.data.payload;
-                }
-              }
-            }
-            const payload = {
-              flowId: runId,
-              flowName,
-              stepName,
-              position,
-              timeoutAction: action,
-              input: inputData
-            };
-            const jobId = `${runId}__${stepName}__await-timeout`;
-            const registry = $useFunctionRegistry();
-            const flowRegistry = (registry?.flows || {})[flowName];
-            const stepMeta = flowRegistry?.steps?.[stepName];
-            let stepQueue = stepMeta?.queue;
-            if (!stepQueue && flowRegistry?.entry?.step === stepName) {
-              stepQueue = flowRegistry.entry.queue;
-            }
-            if (!stepQueue && registry?.workers) {
-              const worker = registry.workers.find((w) => {
-                const flowNames = w?.flow?.names || (w?.flow?.name ? [w?.flow?.name] : []);
-                const stepMatch = w?.flow?.step === stepName || Array.isArray(w?.flow?.step) && w?.flow?.step.includes(stepName);
-                return flowNames.includes(flowName) && stepMatch;
-              });
-              stepQueue = worker?.queue?.name;
-            }
-            if (!stepQueue) {
-              logger.error("Cannot find queue for step", {
-                stepName,
-                flowName,
-                availableSteps: Object.keys(flowRegistry?.steps || {}),
-                entryStep: flowRegistry?.entry?.step
-              });
-              throw new Error(`Cannot handle await timeout: queue not found for step ${stepName} in flow ${flowName}`);
-            }
-            await queue.enqueue(stepQueue, {
-              name: SYSTEM_HANDLERS.AWAIT_TIMEOUT,
-              data: payload,
-              opts: { jobId }
-            });
-            if (action === "fail") {
-              if (store.index.updateWithRetry) {
-                await store.index.updateWithRetry(indexKey, runId, {
-                  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 currentStatus = currentEntry?.metadata?.status;
-                if (currentStatus === "canceled") {
-                  logger.debug("Flow already canceled, skipping status update", { flowName, runId });
-                  return;
-                }
-                const awaitingStepsObj = currentEntry?.metadata?.awaitingSteps || {};
-                let hasActiveAwaits = false;
-                let hasTimedOutAwaits = false;
-                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 !== false) {
-      await stallDetector.start();
-      logger.info("Stall detector initialized - using per-flow scheduler jobs");
-    }
-  }
-  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 };
-}