nvent 0.5.4 → 0.5.6

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

@@ -110,6 +110,14 @@ export interface FlowConfig {
          */
         mode?: 'auto' | 'manual';
     };
+    /**
+     * Step execution timeout in milliseconds (v0.5.1)
+     * Overrides global flow.stepTimeout and queue.defaultJobOptions.timeout for this specific step
+     *
+     * @example 600000 // 10 minutes
+     * @example 3600000 // 1 hour
+     */
+    stepTimeout?: number;
     /**
      * Await pattern: Wait BEFORE step execution (v0.5)
      * Step won't execute until trigger fires
@@ -123,53 +131,113 @@ export interface FlowConfig {
 }
 /**
  * Await configuration (run-scoped triggers)
- * Declared in config, no functions allowed (AST-parsed)
+ *
+ * Pauses flow execution until a specific condition is met. Can be used with:
+ * - `awaitBefore`: Wait before step execution starts
+ * - `awaitAfter`: Wait after step completes before triggering next steps
+ *
+ * Declared in config, no functions allowed (AST-parsed at build time)
  */
 export interface AwaitConfig {
     /**
-     * Trigger type
+     * Type of trigger to wait for
+     * - `webhook`: Wait for HTTP request to specific endpoint
+     * - `event`: Wait for custom event with optional data matching
+     * - `schedule`: Wait until specific cron schedule time
+     * - `time`: Wait for fixed time delay
      */
     type: 'webhook' | 'event' | 'schedule' | 'time';
     /**
-     * URL path for webhook (supports template variables: {runId}, {stepId})
+     * URL path for webhook trigger (supports template variables)
+     *
+     * Only used when `type: 'webhook'`
+     *
+     * Template variables available:
+     * - `{runId}`: Current flow run ID
+     * - `{stepId}`: Current step execution ID
+     *
+     * @example '/webhooks/approve/{runId}'
+     * @example '/api/confirm/{stepId}'
      */
     path?: string;
     /**
-     * HTTP method for webhook
+     * HTTP method for webhook endpoint
+     *
+     * Only used when `type: 'webhook'`
+     *
+     * @default 'POST'
      */
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
     /**
      * Event name to wait for
+     *
+     * Only used when `type: 'event'`
+     *
+     * @example 'payment.completed'
+     * @example 'order.shipped'
      */
     event?: string;
     /**
-     * Key to match between event and step data
-     * e.g., 'orderId' matches event.orderId === step.orderId
-     * Supports nested paths: 'order.id' matches event.order.id === step.order.id
+     * Key to match between event data and step output
+     *
+     * Only used when `type: 'event'`
+     *
+     * Matches incoming event data against step output data.
+     * Supports nested paths using dot notation.
+     *
+     * @example 'orderId' - matches event.orderId === stepOutput.orderId
+     * @example 'order.id' - matches event.order.id === stepOutput.order.id
      */
     filterKey?: string;
     /**
-     * Cron expression (e.g., '0 9 * * *' for 9 AM daily)
+     * Cron expression defining when to trigger (one-time schedule)
+     *
+     * Only used when `type: 'schedule'`
+     *
+     * Note: This is a one-time trigger, not recurring. The next occurrence
+     * of the cron expression after step completion will trigger continuation.
+     *
+     * @example '0 9 * * *' - 9 AM daily (triggers at next 9 AM occurrence)
+     * @example '0 0 * * MON' - Midnight every Monday
      */
     cron?: string;
     /**
-     * Hours to add after step completion before calculating next cron occurrence
-     */
-    nextAfterHours?: number;
-    /**
-     * Timezone for cron expression
+     * Timezone for cron expression evaluation
+     *
+     * Only used when `type: 'schedule'`
+     *
+     * @example 'America/New_York'
+     * @example 'Europe/Berlin'
+     * @default 'UTC'
      */
     timezone?: string;
     /**
-     * Delay in milliseconds
+     * Fixed delay in milliseconds before continuation
+     *
+     * Only used when `type: 'time'`
+     *
+     * @example 60000 - 1 minute
+     * @example 3600000 - 1 hour
      */
     delay?: number;
     /**
-     * Maximum wait time in milliseconds
+     * Maximum wait time in milliseconds before timeout
+     *
+     * Applies to all trigger types. If the trigger doesn't fire within
+     * this duration, the timeout action will be taken.
+     *
+     * @example 86400000 - 24 hours
+     * @example 604800000 - 7 days
      */
     timeout?: number;
     /**
-     * Action to take on timeout
+     * Action to take when timeout is reached
+     *
+     * - `fail`: Mark step/flow as failed
+     * - `continue`: Continue flow execution anyway
+     * - `retry`: Retry waiting (reset timeout)
+     *
+     * @default 'fail'
      */
     timeoutAction?: 'fail' | 'continue' | 'retry';
 }

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

@@ -2,30 +2,65 @@
  * Type-safe hook definitions for await patterns
  * v0.5 - Await Integration
  */
-import type { RunContext } from '../worker/node/runner.js';
-export interface AwaitRegisterContext extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
-    awaitType: 'webhook' | 'event' | 'schedule' | 'time';
+import type { RunContext } from '../../worker/node/runner.js';
+export type AwaitType = 'webhook' | 'event' | 'schedule' | 'time';
+/**
+ * Hook data types specific to each await type
+ */
+export interface WebhookHookData {
+    webhookUrl: string;
+}
+export interface EventHookData {
+    eventName: string;
+}
+export interface ScheduleHookData {
+    cronExpression: string;
+    nextOccurrence: Date;
+}
+export interface TimeHookData {
+    delayMs: number;
+}
+/**
+ * Conditional type to get the correct hook data based on await type
+ */
+export type HookDataForAwaitType<T extends AwaitType> = T extends 'webhook' ? WebhookHookData : T extends 'event' ? EventHookData : T extends 'schedule' ? ScheduleHookData : T extends 'time' ? TimeHookData : never;
+export interface AwaitRegisterContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
+    awaitType: T;
     awaitConfig: any;
+    position: 'before' | 'after';
 }
-export interface AwaitResolveContext extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
-    awaitType: 'webhook' | 'event' | 'schedule' | 'time';
+export interface AwaitResolveContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
+    awaitType: T;
     resolvedData: any;
+    position: 'before' | 'after';
+}
+export interface AwaitTimeoutContext<T extends AwaitType = AwaitType> extends Pick<RunContext, 'flowId' | 'flowName' | 'stepName' | 'logger' | 'state'> {
+    awaitType: T;
+    timeoutAction: 'fail' | 'continue' | 'retry';
+    position: 'before' | 'after';
 }
 /**
  * Define onAwaitRegister hook with proper types
  * Called when an await pattern is registered (before handler execution or after completion)
  *
  * @example
- * export const onAwaitRegister = defineAwaitRegisterHook(async (webhookUrl, stepData, ctx) => {
- *   // Send notification email with webhook URL
+ * // Webhook example
+ * export const onAwaitRegister = defineAwaitRegisterHook(async (hookData, stepData, ctx) => {
+ *   // hookData.webhookUrl is typed correctly for webhook awaits
  *   await sendEmail({
  *     to: stepData.reviewerEmail,
  *     subject: 'Approval Required',
- *     approveUrl: webhookUrl
+ *     approveUrl: hookData.webhookUrl
  *   })
  * })
+ *
+ * // Event example
+ * export const onAwaitRegister = defineAwaitRegisterHook(async (hookData, stepData, ctx) => {
+ *   // hookData.eventName is available for event awaits
+ *   console.log(`Waiting for event: ${hookData.eventName}`)
+ * })
  */
-export declare function defineAwaitRegisterHook(hook: (webhookUrl: string, stepData: any, ctx: AwaitRegisterContext) => Promise<void>): (webhookUrl: string, stepData: any, ctx: AwaitRegisterContext) => Promise<void>;
+export declare function defineAwaitRegisterHook<T extends AwaitType = AwaitType>(hook: (hookData: HookDataForAwaitType<T>, stepData: any, ctx: AwaitRegisterContext<T>) => Promise<void>): (hookData: HookDataForAwaitType<T>, stepData: any, ctx: AwaitRegisterContext<T>) => Promise<void>;
 /**
  * Define onAwaitResolve hook with proper types
  * Called when an await pattern is resolved (external trigger fired)
@@ -38,4 +73,23 @@ export declare function defineAwaitRegisterHook(hook: (webhookUrl: string, stepD
  *   await updateTicketStatus(stepData.ticketId, resolvedData.approved ? 'approved' : 'rejected')
  * })
  */
-export declare function defineAwaitResolveHook(hook: (resolvedData: any, stepData: any, ctx: AwaitResolveContext) => Promise<void>): (resolvedData: any, stepData: any, ctx: AwaitResolveContext) => Promise<void>;
+export declare function defineAwaitResolveHook<T extends AwaitType = AwaitType>(hook: (resolvedData: any, stepData: any, ctx: AwaitResolveContext<T>) => Promise<void>): (resolvedData: any, stepData: any, ctx: AwaitResolveContext<T>) => Promise<void>;
+/**
+ * Define onAwaitTimeout hook with proper types
+ * Called when an await pattern times out (timeout exceeded without resolution)
+ *
+ * @example
+ * export const onAwaitTimeout = defineAwaitTimeoutHook(async (stepData, ctx) => {
+ *   ctx.logger.log('warn', 'Approval request timed out', {
+ *     action: ctx.timeoutAction
+ *   })
+ *
+ *   // Send timeout notification
+ *   await sendEmail({
+ *     to: stepData.reviewerEmail,
+ *     subject: 'Approval Request Expired',
+ *     message: 'The approval request was not completed in time'
+ *   })
+ * })
+ */
+export declare function defineAwaitTimeoutHook<T extends AwaitType = AwaitType>(hook: (stepData: any, ctx: AwaitTimeoutContext<T>) => Promise<void>): (stepData: any, ctx: AwaitTimeoutContext<T>) => Promise<void>;

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

@@ -4,3 +4,6 @@ export function defineAwaitRegisterHook(hook) {
 export function defineAwaitResolveHook(hook) {
   return hook;
 }
+export function defineAwaitTimeoutHook(hook) {
+  return hook;
+}

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

@@ -1,5 +1,17 @@
 import type { AwaitConfig } from '../../../registry/types.js';
 import { registerAwaitPattern, resolveAwaitPattern, registerWebhookAwait, resolveWebhookAwait, registerEventAwait, resolveEventAwait, registerScheduleAwait, resolveScheduleAwait, registerTimeAwait, resolveTimeAwait } from './awaitPatterns/index.js';
+/**
+ * Get default timeout values for await patterns from runtime config
+ * These are configurable via module options and used throughout the system
+ * Exported for use by await pattern implementations
+ */
+export declare function useAwaitDefaults(): {
+    webhookTimeout: any;
+    eventTimeout: any;
+    timeTimeout: any;
+    scheduleTimeout: any;
+    timeoutAction: any;
+};
 /**
  * Await pattern composable
  * Provides unified API for managing await patterns in flows

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

@@ -10,7 +10,34 @@ import {
   registerTimeAwait,
   resolveTimeAwait
 } from "./awaitPatterns/index.js";
-import { useStoreAdapter, useStreamTopics, useNventLogger } from "#imports";
+import { useStoreAdapter, useStreamTopics, useNventLogger, useRuntimeConfig } from "#imports";
+export function useAwaitDefaults() {
+  try {
+    const config = useRuntimeConfig();
+    const awaitDefaults = config?.nvent?.flow?.awaitDefaults;
+    return {
+      webhookTimeout: awaitDefaults?.webhookTimeout ?? 24 * 60 * 60 * 1e3,
+      // 24 hours
+      eventTimeout: awaitDefaults?.eventTimeout ?? 24 * 60 * 60 * 1e3,
+      // 24 hours
+      timeTimeout: awaitDefaults?.timeTimeout,
+      // undefined by default
+      scheduleTimeout: awaitDefaults?.scheduleTimeout,
+      // undefined by default
+      timeoutAction: awaitDefaults?.timeoutAction ?? "fail"
+    };
+  } catch {
+    return {
+      webhookTimeout: 24 * 60 * 60 * 1e3,
+      // 24 hours
+      eventTimeout: 24 * 60 * 60 * 1e3,
+      // 24 hours
+      timeTimeout: void 0,
+      scheduleTimeout: void 0,
+      timeoutAction: "fail"
+    };
+  }
+}
 export function useAwait() {
   const logger = useNventLogger("await");
   const store = useStoreAdapter();
@@ -62,7 +89,10 @@ export function useAwait() {
       }
       const awaitingSteps = entry.metadata.awaitingSteps || {};
       if (stepName) {
-        return awaitingSteps[stepName] || null;
+        const awaitKeyBefore = `${stepName}:before`;
+        const awaitKeyAfter = `${stepName}:after`;
+        const awaitState = awaitingSteps[awaitKeyBefore] || awaitingSteps[awaitKeyAfter] || awaitingSteps[stepName];
+        return awaitState || null;
       }
       return awaitingSteps;
     },
@@ -78,8 +108,8 @@ export function useAwait() {
      */
     async getAllActiveAwaits(flowName) {
       const activeAwaits = [];
-      if (!store.indexScan) {
-        logger.warn("Store does not support indexScan");
+      if (!store.index.read) {
+        logger.warn("Store does not support index read");
         return activeAwaits;
       }
       if (flowName) {

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

@@ -14,55 +14,46 @@ 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 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>;
+    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

@@ -20,9 +20,20 @@ export function useFlow() {
       );
       const opts = entryWorker?.queue?.defaultJobOptions || {};
       const flowId = randomUUID();
-      const id = await queueAdapter.enqueue(queueName, { name: flow.entry.step, data: { ...payload, flowId, flowName }, opts });
+      const id = await queueAdapter.enqueue(queueName, {
+        name: flow.entry.step,
+        data: { ...payload, flowId, flowName },
+        opts
+      });
       try {
-        await eventsManager.publishBus({ type: "flow.start", runId: flowId, flowName, data: { input: payload } });
+        await eventsManager.publishBus({
+          type: "flow.start",
+          runId: flowId,
+          flowName,
+          data: {
+            input: payload
+          }
+        });
       } catch {
       }
       return { id, queue: queueName, step: flow.entry.step, flowId };
@@ -59,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 });
@@ -75,36 +95,55 @@ export function useFlow() {
       }
     },
     /**
-     * Check if a flow is currently running
+     * 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/useHookRegistry.d.ts

@@ -5,18 +5,24 @@
 export interface LifecycleHooks {
     /**
      * Called when await pattern is registered
-     * @param webhookUrl - Generated webhook URL (for webhook awaits) or event/schedule info
+     * @param hookData - Type-safe data based on await type (webhookUrl, eventName, etc.)
      * @param stepData - Current step data
-     * @param ctx - Worker context
+     * @param ctx - Worker context with awaitType and awaitConfig
      */
-    onAwaitRegister?: (webhookUrl: string, stepData: any, ctx: any) => Promise<void>;
+    onAwaitRegister?: (hookData: any, stepData: any, ctx: any) => Promise<void>;
     /**
      * Called when await pattern is resolved
      * @param resolvedData - Data from the trigger that resolved the await
      * @param stepData - Current step data
-     * @param ctx - Worker context
+     * @param ctx - Worker context with awaitType
      */
     onAwaitResolve?: (resolvedData: any, stepData: any, ctx: any) => Promise<void>;
+    /**
+     * Called when await pattern times out
+     * @param stepData - Current step data
+     * @param ctx - Worker context with awaitType and timeoutAction
+     */
+    onAwaitTimeout?: (stepData: any, ctx: any) => Promise<void>;
 }
 export declare function useHookRegistry(): {
     /**

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;
 }