nvent 0.5.5 → 0.5.7

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "configKey": "nvent",
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -639,9 +639,8 @@ function analyzeFlow(flow, config) {
       dependsOn: dependencies[stepName] || [],
       triggers: findTriggeredSteps(stepName, step, steps),
       level: levels[stepName] ?? 1,
-      hasAwaitPattern,
-      stepTimeout: void 0
-      // Step execution timeout from config
+      hasAwaitPattern
+      // stepTimeout from ...step spread above (per-function config)
     };
     analyzedStep.stepTimeout = getStepExecutionTimeout(analyzedStep, config);
     analyzedSteps[stepName] = analyzedStep;
@@ -982,6 +981,26 @@ export type {
   ListOptions,
 } from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/store"))}
 
+// Flow Types
+export type {
+  FlowStats,
+  StartFlowResult,
+  CancelFlowResult,
+  RestartFlowResult,
+  RunningFlow,
+  FlowComposable,
+} from ${JSON.stringify(resolverFn("./runtime/nitro/utils/useFlow"))}
+
+// Runner Context Types
+export type {
+  QueueJob,
+  RunLogger,
+  RunState,
+  RunContextFlow,
+  RunContext,
+  NodeHandler,
+} from ${JSON.stringify(resolverFn("./runtime/worker/node/runner"))}
+
 // Event Types
 export type {
   EventType,

package/dist/runtime/adapters/builtin/memory-store.d.ts

@@ -43,6 +43,7 @@ export declare class MemoryStoreAdapter implements StoreAdapter {
         read: (key: string, opts?: {
             offset?: number;
             limit?: number;
+            filter?: Record<string, any>;
         }) => Promise<Array<{
             id: string;
             score: number;
@@ -61,7 +62,7 @@ export declare class MemoryStoreAdapter implements StoreAdapter {
     /**
      * Convert dot notation keys to nested objects
      * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
-     * null values are preserved for deletion
+     * null values are tracked for deletion after merge
      */
     private expandDotNotation;
     private generateId;

package/dist/runtime/adapters/builtin/memory-store.js

@@ -173,7 +173,19 @@ export class MemoryStoreAdapter {
       return entry ? { ...entry } : null;
     },
     read: async (key, opts) => {
-      const index = this.sortedIndices.get(key) || [];
+      let index = this.sortedIndices.get(key) || [];
+      if (opts?.filter) {
+        index = index.filter((entry) => {
+          for (const [field, value] of Object.entries(opts.filter)) {
+            if (Array.isArray(value)) {
+              if (!value.includes(entry.metadata?.[field])) return false;
+            } else if (entry.metadata?.[field] !== value) {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
       const offset = opts?.offset || 0;
       const limit = opts?.limit || 50;
       return index.slice(offset, offset + limit).map((e) => ({ ...e }));
@@ -291,9 +303,9 @@ export class MemoryStoreAdapter {
   /**
    * Convert dot notation keys to nested objects
    * e.g., { 'stats.totalFires': 5 } -> { stats: { totalFires: 5 } }
-   * null values are preserved for deletion
+   * null values are tracked for deletion after merge
    */
-  expandDotNotation(obj) {
+  expandDotNotation(obj, parentPath = []) {
     const result = {};
     const deleteMarkers = [];
     for (const [key, value] of Object.entries(obj)) {
@@ -303,7 +315,7 @@ export class MemoryStoreAdapter {
       if (key.includes(".")) {
         const keys = key.split(".");
         if (value === null || value === void 0) {
-          deleteMarkers.push({ path: keys, delete: true });
+          deleteMarkers.push({ path: [...parentPath, ...keys], delete: true });
           continue;
         }
         let current = result;
@@ -315,6 +327,18 @@ export class MemoryStoreAdapter {
           current = current[k];
         }
         current[keys[keys.length - 1]] = value;
+      } else if (value === null || value === void 0) {
+        deleteMarkers.push({ path: [...parentPath, key], delete: true });
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const nested = this.expandDotNotation(value, [...parentPath, key]);
+        const nestedDeleteMarkers = nested.__deleteMarkers;
+        delete nested.__deleteMarkers;
+        if (nestedDeleteMarkers) {
+          deleteMarkers.push(...nestedDeleteMarkers);
+        }
+        if (Object.keys(nested).length > 0) {
+          result[key] = nested;
+        }
       } else {
         result[key] = value;
       }

package/dist/runtime/adapters/interfaces/store.d.ts

@@ -167,14 +167,16 @@ export interface StoreAdapter {
         /**
          * Read entries from a sorted index (ordered by score descending)
          * @param key - Index key
-         * @param opts - Pagination options
+         * @param opts - Pagination and filter options
          * @param opts.offset - Number of entries to skip
          * @param opts.limit - Maximum number of entries to return
+         * @param opts.filter - Optional filter criteria for metadata fields (adapter-dependent efficiency)
          * @returns Array of entries with scores and metadata
          */
         read(key: string, opts?: {
             offset?: number;
             limit?: number;
+            filter?: Record<string, any>;
         }): Promise<Array<{
             id: string;
             score: number;

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

@@ -6,6 +6,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
   const eventBus = getEventBus();
   try {
     const jobId = `trigger:${triggerName}`;
+    const isEnabled = triggerStatus === "active";
     const handler = async () => {
       logger.debug("Schedule trigger fired", { trigger: triggerName });
       await eventBus.publish({
@@ -28,7 +29,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
         type: "schedule-trigger",
         scheduleConfig
       },
-      enabled: triggerStatus === "active"
+      enabled: isEnabled
     };
     if (scheduleConfig.cron) {
       jobConfig.cron = scheduleConfig.cron;
@@ -39,6 +40,7 @@ export async function scheduleTrigger(triggerName, scheduleConfig, triggerStatus
     await scheduler.schedule(jobConfig);
     logger.info("Scheduled trigger", {
       trigger: triggerName,
+      enabled: isEnabled,
       cron: scheduleConfig.cron,
       interval: scheduleConfig.interval,
       timezone: scheduleConfig.timezone

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

@@ -39,8 +39,15 @@ export declare class FlowStallDetector {
     /**
      * Mark a flow as stalled
      * Emits a flow.stalled event and updates the flow status
+     * Also emits step.stalled events for any steps that were running when the flow stalled
      */
     markAsStalled(flowName: string, runId: string, reason?: string): Promise<void>;
+    /**
+     * Find steps that were running when the flow stalled
+     * A step is considered "running" if it has step.started but no terminal event
+     * (step.completed, step.failed, step.stalled)
+     */
+    private findStalledSteps;
     /**
      * Run startup recovery to clean up flows left in running state from previous server instance
      * This marks all running flows as stalled since their in-memory state is lost

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

@@ -34,6 +34,7 @@ export class FlowStallDetector {
   /**
    * Mark a flow as stalled
    * Emits a flow.stalled event and updates the flow status
+   * Also emits step.stalled events for any steps that were running when the flow stalled
    */
   async markAsStalled(flowName, runId, reason = "No activity timeout") {
     const { StoreSubjects } = useStreamTopics();
@@ -57,14 +58,46 @@ export class FlowStallDetector {
         });
       }
       const streamName = StoreSubjects.flowRun(runId);
+      const stalledAt = Date.now();
+      try {
+        const allEvents = await this.store.stream.read(streamName);
+        const stalledSteps = this.findStalledSteps(allEvents);
+        for (const stepName of stalledSteps) {
+          await this.store.stream.append(streamName, {
+            type: "step.stalled",
+            runId,
+            flowName,
+            stepName,
+            data: {
+              reason: "Flow stalled - step execution interrupted",
+              stalledAt
+            }
+          });
+          this.logger.debug(`Emitted step.stalled for step '${stepName}'`, { flowName, runId });
+        }
+        if (stalledSteps.length > 0) {
+          this.logger.info(`Marked ${stalledSteps.length} step(s) as stalled`, {
+            flowName,
+            runId,
+            steps: stalledSteps
+          });
+        }
+      } catch (err) {
+        this.logger.warn("Failed to emit step.stalled events", {
+          flowName,
+          runId,
+          error: err.message
+        });
+      }
       await this.store.stream.append(streamName, {
         type: "flow.stalled",
         runId,
         flowName,
         data: {
           reason,
-          previousStatus
+          previousStatus,
           // Include previous status so stats handler knows which counter to decrement
+          stalledAt
         }
       });
       this.logger.info(`Marked flow as stalled - '${flowName}' runId '${runId}': ${reason}`);
@@ -72,6 +105,39 @@ export class FlowStallDetector {
       this.logger.error(`Failed to mark flow as stalled for '${flowName}' runId '${runId}': ${error.message}`);
     }
   }
+  /**
+   * Find steps that were running when the flow stalled
+   * A step is considered "running" if it has step.started but no terminal event
+   * (step.completed, step.failed, step.stalled)
+   */
+  findStalledSteps(events) {
+    const stepStates = /* @__PURE__ */ new Map();
+    for (const e of events) {
+      const stepName = e.stepName;
+      if (!stepName) continue;
+      if (e.type === "step.started") {
+        if (!stepStates.has(stepName) || stepStates.get(stepName) === "started") {
+          stepStates.set(stepName, "started");
+        }
+      } else if (e.type === "step.completed") {
+        stepStates.set(stepName, "completed");
+      } else if (e.type === "step.failed") {
+        const willRetry = e.data?.willRetry || e.data?.retry;
+        if (!willRetry) {
+          stepStates.set(stepName, "failed");
+        }
+      } else if (e.type === "step.stalled") {
+        stepStates.set(stepName, "stalled");
+      }
+    }
+    const stalledSteps = [];
+    for (const [stepName, state] of stepStates) {
+      if (state === "started") {
+        stalledSteps.push(stepName);
+      }
+    }
+    return stalledSteps;
+  }
   /**
    * Run startup recovery to clean up flows left in running state from previous server instance
    * This marks all running flows as stalled since their in-memory state is lost

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

@@ -530,7 +530,12 @@ export function createFlowWiring() {
           logger.debug("Updated flow stats for failure", { flowName });
         } else if (e.type === "flow.cancel") {
           if (store.index.increment) {
-            await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            const previousStatus = e.data?.previousStatus;
+            if (previousStatus === "awaiting") {
+              await store.index.increment(flowIndexKey, flowName, "stats.awaiting", -1);
+            } else {
+              await store.index.increment(flowIndexKey, flowName, "stats.running", -1);
+            }
             await store.index.increment(flowIndexKey, flowName, "stats.cancel", 1);
           }
           if (store.index.updateWithRetry) {
@@ -538,7 +543,7 @@ export function createFlowWiring() {
               lastCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          logger.debug("Updated flow stats for cancellation", { flowName });
+          logger.debug("Updated flow stats for cancellation", { flowName, previousStatus: e.data?.previousStatus });
         } else if (e.type === "flow.stalled") {
           if (store.index.increment && e.data?.previousStatus) {
             if (e.data.previousStatus === "awaiting") {
@@ -735,6 +740,14 @@ export function createFlowWiring() {
           const { stepName, awaitType, position, config: config2 } = awaitEvent;
           try {
             if (store.index.updateWithRetry) {
+              if (store.index.get) {
+                const currentEntry = await store.index.get(indexKey, runId);
+                const currentStatus = currentEntry?.metadata?.status;
+                if (currentStatus === "canceled") {
+                  logger.debug("Flow already canceled, skipping await registration", { flowName, runId, stepName });
+                  return;
+                }
+              }
               const now = Date.now();
               let timeoutAt;
               if (awaitType === "time" && config2.delay) {
@@ -785,6 +798,14 @@ export function createFlowWiring() {
           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, {
@@ -870,6 +891,14 @@ export function createFlowWiring() {
           const timeoutEvent = e;
           const { stepName, timeoutAction, position, awaitType } = timeoutEvent;
           const action = timeoutAction || "fail";
+          if (store.index.get) {
+            const currentEntry = await store.index.get(indexKey, runId);
+            const currentStatus = currentEntry?.metadata?.status;
+            if (currentStatus === "canceled") {
+              logger.debug("Flow already canceled, skipping await timeout handling", { flowName, runId, stepName });
+              return;
+            }
+          }
           logger.warn("Await timeout occurred", {
             runId,
             stepName,
@@ -1049,6 +1078,11 @@ export function createFlowWiring() {
               }
               if (store.index.get) {
                 const currentEntry = await store.index.get(indexKey, runId);
+                const currentStatus = currentEntry?.metadata?.status;
+                if (currentStatus === "canceled") {
+                  logger.debug("Flow already canceled, skipping status update", { flowName, runId });
+                  return;
+                }
                 const awaitingStepsObj = currentEntry?.metadata?.awaitingSteps || {};
                 let hasActiveAwaits = false;
                 let hasTimedOutAwaits = false;

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

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

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

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

package/dist/runtime/nitro/routes/webhook.trigger.d.ts

@@ -16,6 +16,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     triggerName?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -27,6 +28,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     message: string;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -38,6 +40,19 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     expectedType: string;
     actualType: any;
     message?: undefined;
+    status?: undefined;
+    expectedMethod?: undefined;
+    actualMethod?: undefined;
+    success?: undefined;
+    subscribedFlows?: undefined;
+    timestamp?: undefined;
+} | {
+    error: string;
+    triggerName: string;
+    status: any;
+    message: string;
+    expectedType?: undefined;
+    actualType?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
     success?: undefined;
@@ -51,6 +66,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     triggerName?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     success?: undefined;
     subscribedFlows?: undefined;
     timestamp?: undefined;
@@ -63,6 +79,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     error?: undefined;
     expectedType?: undefined;
     actualType?: undefined;
+    status?: undefined;
     expectedMethod?: undefined;
     actualMethod?: undefined;
 }>>;

package/dist/runtime/nitro/routes/webhook.trigger.js

@@ -30,6 +30,15 @@ export default defineEventHandler(async (event) => {
       actualType: triggerEntry.type
     };
   }
+  if (triggerEntry.status !== "active") {
+    logger.info(`Trigger '${triggerName}' is ${triggerEntry.status}, rejecting webhook`);
+    return {
+      error: "Trigger not active",
+      triggerName,
+      status: triggerEntry.status,
+      message: `Trigger '${triggerName}' is ${triggerEntry.status}. Update status to 'active' to enable.`
+    };
+  }
   const expectedMethod = triggerEntry.webhook?.method || "POST";
   if (event.method !== expectedMethod) {
     logger.warn(`Method mismatch: expected ${expectedMethod}, got ${event.method}`);

package/dist/runtime/nitro/utils/useFlow.d.ts

@@ -14,55 +14,53 @@ export interface FlowStats {
     };
     version?: number;
 }
+export interface StartFlowResult {
+    id: string;
+    queue: string;
+    step: string;
+    flowId: string;
+}
+export interface CancelFlowResult {
+    success: boolean;
+    runId: string;
+    flowName: string;
+}
+export interface RestartFlowResult {
+    success: boolean;
+    oldRunId: string;
+    newRunId: string;
+    flowName: string;
+}
+export interface RunningFlow {
+    id: string;
+    flowName: string;
+    status: string;
+    startedAt: string | undefined;
+    stepCount: number;
+    completedSteps: number;
+}
+export interface FlowComposable {
+    startFlow: (flowName: string, payload?: any) => Promise<StartFlowResult>;
+    emit: (trigger: string, payload?: any) => Promise<any[]>;
+    cancelFlow: (flowName: string, runId: string) => Promise<CancelFlowResult>;
+    restartFlow: (flowName: string, runId: string) => Promise<RestartFlowResult>;
+    isRunning: (flowName: string, runId?: string, options?: {
+        excludeRunIds?: string[];
+    }) => Promise<boolean>;
+    getRunningFlows: (flowName: string, options?: {
+        excludeRunIds?: string[];
+    }) => Promise<RunningFlow[]>;
+    getFlowStats: (flowName: string) => Promise<FlowStats | null>;
+    getAllFlowStats: (options?: {
+        sortBy?: 'registeredAt' | 'lastRunAt' | 'name';
+        order?: 'asc' | 'desc';
+        limit?: number;
+        offset?: number;
+    }) => Promise<FlowStats[]>;
+    hasFlowStats: (flowName: string) => Promise<boolean>;
+}
 /**
  * Flow composable for managing flows and accessing flow statistics
  * Provides methods for starting, canceling, and querying flows
  */
-export declare function useFlow(): {
-    /**
-     * Start a flow with the given payload
-     */
-    startFlow(flowName: string, payload?: any): Promise<{
-        id: any;
-        queue: any;
-        step: any;
-        flowId: `${string}-${string}-${string}-${string}-${string}`;
-    }>;
-    /**
-     * Emit a trigger event for flow coordination
-     */
-    emit(trigger: string, payload?: any): Promise<never[]>;
-    /**
-     * Cancel a running flow
-     */
-    cancelFlow(flowName: string, runId: string): Promise<{
-        success: boolean;
-        runId: string;
-        flowName: string;
-    }>;
-    /**
-     * Check if a flow is currently running
-     */
-    isRunning(flowName: string, runId?: string): Promise<any>;
-    /**
-     * Get all currently running flows
-     */
-    getRunningFlows(flowName: string): Promise<any>;
-    /**
-     * Get flow statistics by name
-     */
-    getFlowStats(flowName: string): Promise<FlowStats | null>;
-    /**
-     * Get all flows with their statistics
-     */
-    getAllFlowStats(options?: {
-        sortBy?: "registeredAt" | "lastRunAt" | "name";
-        order?: "asc" | "desc";
-        limit?: number;
-        offset?: number;
-    }): Promise<FlowStats[]>;
-    /**
-     * Check if a flow has statistics in the index
-     */
-    hasFlowStats(flowName: string): Promise<boolean>;
-};
+export declare function useFlow(): FlowComposable;

package/dist/runtime/nitro/utils/useFlow.js

@@ -70,15 +70,24 @@ export function useFlow() {
      */
     async cancelFlow(flowName, runId) {
       try {
+        let previousStatus;
+        try {
+          const runIndexKey = StoreSubjects.flowRunIndex(flowName);
+          const entry = await store.index.get(runIndexKey, runId);
+          previousStatus = entry?.metadata?.status;
+        } catch {
+        }
         await eventsManager.publishBus({
           type: "flow.cancel",
           runId,
           flowName,
           data: {
-            canceledAt: (/* @__PURE__ */ new Date()).toISOString()
+            canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
+            previousStatus
+            // Include for correct stats counter decrement
           }
         });
-        logger.info("Flow canceled", { flowName, runId });
+        logger.info("Flow canceled", { flowName, runId, previousStatus });
         return { success: true, runId, flowName };
       } catch (err) {
         logger.error("Failed to cancel flow", { flowName, runId, error: err });
@@ -86,36 +95,100 @@ export function useFlow() {
       }
     },
     /**
-     * Check if a flow is currently running
+     * Restart a flow by canceling the current run and starting a new one with the same input
+     * @param flowName - The name of the flow
+     * @param runId - The run ID to restart
+     */
+    async restartFlow(flowName, runId) {
+      try {
+        const streamName = StoreSubjects.flowRun(runId);
+        const events = await store.stream.read(streamName);
+        const startEvent = events.find((e) => e.type === "flow.start" || e.type === "flow.started");
+        const originalInput = startEvent?.data?.input || {};
+        logger.debug("Found original input for restart", { flowName, runId, hasInput: !!startEvent });
+        const runIndexKey = StoreSubjects.flowRunIndex(flowName);
+        const entry = await store.index.get(runIndexKey, runId);
+        const currentStatus = entry?.metadata?.status;
+        if (currentStatus === "running" || currentStatus === "awaiting") {
+          await eventsManager.publishBus({
+            type: "flow.cancel",
+            runId,
+            flowName,
+            data: {
+              canceledAt: (/* @__PURE__ */ new Date()).toISOString(),
+              previousStatus: currentStatus,
+              reason: "Restarted"
+            }
+          });
+          logger.info("Canceled flow for restart", { flowName, runId, previousStatus: currentStatus });
+        }
+        const newResult = await this.startFlow(flowName, originalInput);
+        logger.info("Flow restarted", {
+          flowName,
+          oldRunId: runId,
+          newRunId: newResult.flowId
+        });
+        return {
+          success: true,
+          oldRunId: runId,
+          newRunId: newResult.flowId,
+          flowName
+        };
+      } catch (err) {
+        logger.error("Failed to restart flow", { flowName, runId, error: err });
+        throw err;
+      }
+    },
+    /**
+     * Check if a flow is currently running (includes 'running' and 'awaiting' status)
+     * @param flowName - The name of the flow to check
+     * @param runId - Optional specific run ID to check (if provided, only checks that run)
+     * @param options - Optional configuration
+     * @param options.excludeRunIds - Exclude these run IDs from the check (useful when called from within a flow)
      */
-    async isRunning(flowName, runId) {
+    async isRunning(flowName, runId, options) {
       try {
         if (!store.index.read) {
           return false;
         }
         const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const entries = await store.index.read(runIndexKey, { limit: 1e3 });
+        const activeStatuses = ["running", "awaiting"];
         if (runId) {
-          const run = entries.find((e) => e.id === runId);
-          return run?.metadata?.status === "running";
+          const run = await store.index.get(runIndexKey, runId);
+          return activeStatuses.includes(run?.metadata?.status);
         }
-        return entries.some((e) => e.metadata?.status === "running");
+        const entries = await store.index.read(runIndexKey, {
+          limit: 1e3,
+          filter: { status: activeStatuses }
+        });
+        const excludeSet = new Set(options?.excludeRunIds || []);
+        const matchingRuns = entries.filter((e) => !excludeSet.has(e.id));
+        return matchingRuns.length > 0;
       } catch (err) {
         logger.error("Error checking flow status:", err);
         return false;
       }
     },
     /**
-     * Get all currently running flows
+     * Get all currently running flows (includes 'running' and 'awaiting' status)
+     * @param flowName - The name of the flow to check
+     * @param options - Optional configuration
+     * @param options.excludeRunIds - Exclude these run IDs from the results (useful when called from within a flow)
      */
-    async getRunningFlows(flowName) {
+    async getRunningFlows(flowName, options) {
       try {
         if (!store.index.read) {
           return [];
         }
         const runIndexKey = StoreSubjects.flowRunIndex(flowName);
-        const entries = await store.index.read(runIndexKey, { limit: 1e3 });
-        return entries.filter((e) => e.metadata?.status === "running").map((e) => ({
+        const activeStatuses = ["running", "awaiting"];
+        const entries = await store.index.read(runIndexKey, {
+          limit: 1e3,
+          filter: { status: activeStatuses }
+        });
+        const excludeSet = new Set(options?.excludeRunIds || []);
+        const filteredEntries = entries.filter((e) => !excludeSet.has(e.id));
+        return filteredEntries.map((e) => ({
           id: e.id,
           flowName,
           status: e.metadata?.status,

package/dist/runtime/nitro/utils/useTrigger.js

@@ -110,6 +110,12 @@ export function useTrigger() {
           `Emitting unregistered trigger '${name}'. Consider registering it first with registerTrigger().`
         );
       }
+      if (trigger && trigger.status !== "active") {
+        logger.info(
+          `Trigger '${name}' is ${trigger.status}, not emitting. Update status to 'active' to enable firing.`
+        );
+        return;
+      }
       const threshold = opts?.payloadThreshold || trigger?.config?.payloadThreshold || 10 * 1024;
       const eventData = await runtime.handleLargePayload(name, data, threshold);
       logger.debug(`Emitting trigger: ${name}`, {
@@ -208,6 +214,7 @@ export function useTrigger() {
           }
           if (metadata.subscriptions) {
             for (const [flowName, subData] of Object.entries(metadata.subscriptions)) {
+              if (!subData) continue;
               const subscription = {
                 triggerName: entry.id,
                 flowName,
@@ -223,22 +230,6 @@ export function useTrigger() {
         logger.info(
           `Loaded ${activeCount} active triggers with ${totalSubscriptions} subscriptions from index`
         );
-      } else {
-        logger.warn("Store does not support indexRead, falling back to doc-based loading");
-        if (store.list) {
-          const triggers = await store.list("triggers");
-          for (const { id, doc } of triggers) {
-            runtime.addTrigger(id, doc);
-          }
-          const subscriptions = await store.list("trigger-subscriptions");
-          for (const { doc } of subscriptions) {
-            const sub = doc;
-            runtime.addSubscription(sub.triggerName, sub.flowName, sub);
-          }
-          logger.info(
-            `Loaded ${triggers.length} triggers and ${subscriptions.length} subscriptions from doc store (legacy)`
-          );
-        }
       }
       runtime.setInitialized(true);
     },

package/dist/runtime/scheduler/index.js

@@ -1,6 +1,7 @@
 import { Scheduler } from "./scheduler.js";
 import { useRuntimeConfig } from "#imports";
-let schedulerInstance = null;
+const SCHEDULER_KEY = "__nvent_scheduler__";
+let schedulerInstance = globalThis[SCHEDULER_KEY] || null;
 export function createScheduler(store) {
   const config = useRuntimeConfig();
   const prefix = config.nvent.store?.prefix || "nvent";
@@ -24,6 +25,7 @@ export async function initializeScheduler(store) {
     return schedulerInstance;
   }
   schedulerInstance = createScheduler(store);
+  globalThis[SCHEDULER_KEY] = schedulerInstance;
   await schedulerInstance.start();
   return schedulerInstance;
 }
@@ -31,8 +33,10 @@ export async function shutdownScheduler() {
   if (schedulerInstance) {
     await schedulerInstance.stop();
     schedulerInstance = null;
+    globalThis[SCHEDULER_KEY] = null;
   }
 }
 export function resetScheduler() {
   schedulerInstance = null;
+  globalThis[SCHEDULER_KEY] = null;
 }

package/dist/runtime/worker/node/runner.d.ts

@@ -1,4 +1,4 @@
-import { useFlow } from '#imports';
+import type { FlowStats, StartFlowResult, CancelFlowResult, RunningFlow } from '../../nitro/utils/useFlow.js';
 /**
  * Generic job interface that works with any queue adapter
  * Adapters should provide jobs in this format
@@ -22,6 +22,48 @@ export interface RunState {
     }): Promise<void>;
     delete(key: string): Promise<void>;
 }
+/**
+ * Flow context available within step handlers
+ * Provides context-aware versions of flow operations with auto-injected flowId/flowName
+ */
+export interface RunContextFlow {
+    /** Start a new flow with the given payload */
+    startFlow: (flowName: string, payload?: any) => Promise<StartFlowResult>;
+    /** Emit a trigger event (auto-injects flowId, flowName, stepName from context) */
+    emit: (trigger: string, payload?: any) => Promise<any[]>;
+    /** Cancel a specific flow by name and runId */
+    cancelFlow: (flowName: string, runId: string) => Promise<CancelFlowResult>;
+    /** Cancel the current flow (uses flowId from context) */
+    cancel: () => Promise<CancelFlowResult>;
+    /**
+     * Check if a flow is currently running
+     * @param flowName - Optional flow name (defaults to current flow)
+     * @param runId - Optional specific run ID to check
+     * @param options - Optional configuration (auto-excludes current flow if not specified)
+     */
+    isRunning: (flowName?: string, runId?: string, options?: {
+        excludeRunIds?: string[];
+    }) => Promise<boolean>;
+    /**
+     * Get all currently running flows
+     * @param flowName - Optional flow name (defaults to current flow)
+     * @param options - Optional configuration (auto-excludes current flow if not specified)
+     */
+    getRunningFlows: (flowName?: string, options?: {
+        excludeRunIds?: string[];
+    }) => Promise<RunningFlow[]>;
+    /** Get flow statistics by name */
+    getFlowStats: (flowName: string) => Promise<FlowStats | null>;
+    /** Get all flows with their statistics */
+    getAllFlowStats: (options?: {
+        sortBy?: 'registeredAt' | 'lastRunAt' | 'name';
+        order?: 'asc' | 'desc';
+        limit?: number;
+        offset?: number;
+    }) => Promise<FlowStats[]>;
+    /** Check if a flow has statistics in the index */
+    hasFlowStats: (flowName: string) => Promise<boolean>;
+}
 export interface RunContext {
     jobId?: string;
     queue?: string;
@@ -32,7 +74,7 @@ export interface RunContext {
     attempt?: number;
     logger: RunLogger;
     state: RunState;
-    flow: ReturnType<typeof useFlow>;
+    flow: RunContextFlow;
     /**
      * Resolved data from await pattern (awaitBefore only)
      * Available when step resumes after await resolution

package/dist/runtime/worker/node/runner.js

@@ -52,14 +52,15 @@ export function buildContext(partial) {
       log: (level, msg, meta) => {
         const runId = partial?.flowId || "unknown";
         const flowName = meta?.flowName || "unknown";
+        const metaObj = meta !== null && meta !== void 0 ? typeof meta === "object" && !Array.isArray(meta) ? meta : { value: meta } : {};
         void eventManager.publishBus({
           type: "log",
           runId,
           flowName,
-          stepName: meta?.stepName,
-          stepId: meta?.stepId || meta?.stepRunId,
-          attempt: meta?.attempt,
-          data: { level, message: msg, ...meta }
+          stepName: metaObj?.stepName,
+          stepId: metaObj?.stepId || metaObj?.stepRunId,
+          attempt: metaObj?.attempt,
+          data: { level, message: msg, ...metaObj }
         });
       }
     };
@@ -82,19 +83,21 @@ export function buildContext(partial) {
       }
       return baseFlowEngine.cancelFlow(partial.flowName, partial.flowId);
     },
-    isRunning: async (flowName, runId) => {
+    isRunning: async (flowName, runId, options) => {
       const targetFlowName = flowName || partial?.flowName;
       if (!targetFlowName) {
         throw new Error("flowName is required to check if flow is running");
       }
-      return baseFlowEngine.isRunning(targetFlowName, runId);
+      const effectiveOptions = options || (partial?.flowId ? { excludeRunIds: [partial.flowId] } : void 0);
+      return baseFlowEngine.isRunning(targetFlowName, runId, effectiveOptions);
     },
-    getRunningFlows: async (flowName) => {
+    getRunningFlows: async (flowName, options) => {
       const targetFlowName = flowName || partial?.flowName;
       if (!targetFlowName) {
         throw new Error("flowName is required to get running flows");
       }
-      return baseFlowEngine.getRunningFlows(targetFlowName);
+      const effectiveOptions = options || (partial?.flowId ? { excludeRunIds: [partial.flowId] } : void 0);
+      return baseFlowEngine.getRunningFlows(targetFlowName, effectiveOptions);
     }
   };
   return {
@@ -148,7 +151,8 @@ export function createJobProcessor(handler, queueName) {
     });
     const attemptLogger = {
       log: (level, msg, meta) => {
-        const enriched = { ...meta || {}, stepName: job.name, attempt, stepRunId, flowName };
+        const metaObj = meta !== null && meta !== void 0 ? typeof meta === "object" && !Array.isArray(meta) ? meta : { value: meta } : {};
+        const enriched = { ...metaObj, stepName: job.name, attempt, stepRunId, flowName };
         ctx.logger.log(level, msg, enriched);
       }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Event-driven workflows for Nuxt",
   "repository": "DevJoghurt/nvent",
   "license": "MIT",