nvent 0.4.4 → 0.5.0

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { dirname, join, extname, relative } from 'node:path';
-import { useLogger, defineNuxtModule, createResolver, addServerScanDir, addImportsDir, addPlugin, addComponentsDir, addComponent, addTemplate, addServerImports, updateTemplates } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTemplate, addTypeTemplate, addServerPlugin, addServerHandler, addServerImports, updateTemplates } from '@nuxt/kit';
 import defu from 'defu';
 import { existsSync, realpathSync } from 'node:fs';
 import { globby } from 'globby';
@@ -10,6 +10,7 @@ import { spawn } from 'node:child_process';
 import chokidar from 'chokidar';
 import { join as join$1 } from 'pathe';
 import { debounce } from 'perfect-debounce';
+import { normalizeModuleOptions, getRedisStorageConfig, toRuntimeConfig } from '../dist/runtime/config/index.js';
 
 async function loadJsConfig(absPath) {
   const cacheBust = `?t=${Date.now()}`;
@@ -29,7 +30,10 @@ async function loadJsConfig(absPath) {
         role: flowCfg.role,
         step: flowCfg.step,
         emits: flowCfg.emits,
-        subscribes
+        subscribes,
+        triggers: flowCfg.triggers,
+        awaitBefore: flowCfg.awaitBefore,
+        awaitAfter: flowCfg.awaitAfter
       };
     }
   }
@@ -41,7 +45,8 @@ async function loadJsConfig(absPath) {
   } : void 0;
   const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
   const hasDefaultExport = !!(mod && mod.default);
-  return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport };
+  const hasHooks = !!(mod && typeof mod.onAwaitRegister === "function" || mod && typeof mod.onAwaitResolve === "function");
+  return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
 }
 
 async function loadTsConfig(absPath) {
@@ -68,7 +73,10 @@ async function loadTsConfig(absPath) {
           role: flowCfg.role,
           step: flowCfg.step,
           emits: flowCfg.emits,
-          subscribes
+          subscribes,
+          triggers: flowCfg.triggers,
+          awaitBefore: flowCfg.awaitBefore,
+          awaitAfter: flowCfg.awaitAfter
         };
       }
     }
@@ -79,7 +87,8 @@ async function loadTsConfig(absPath) {
       limiter: cfg.queue.limiter
     } : void 0;
     const workerCfg = cfg?.worker && typeof cfg.worker === "object" ? { ...cfg.worker } : void 0;
-    return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport };
+    const hasHooks = !!(mod.exports.onAwaitRegister || mod.exports.onAwaitResolve);
+    return { queueName, flow, runtype, queue: queueCfg, worker: workerCfg, hasDefaultExport, hasHooks };
   } catch (error) {
     throw new Error(`Failed to parse config from ${absPath}: ${error}`);
   }
@@ -127,7 +136,7 @@ function astToValue(node) {
 
 async function loadPyConfig(absPath, logger) {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
-  const helper = join(moduleDir, "..", "..", "runtime", "python", "get_config.py");
+  const helper = join(moduleDir, "..", "..", "runtime", "worker", "python", "get_config.py");
   let pyConfig;
   if (existsSync(helper)) {
     pyConfig = await new Promise((resolve) => {
@@ -174,7 +183,10 @@ async function loadPyConfig(absPath, logger) {
           role: flowCfg.role,
           step: flowCfg.step,
           emits: flowCfg.emits,
-          subscribes
+          subscribes,
+          triggers: flowCfg.triggers,
+          awaitBefore: flowCfg.awaitBefore,
+          awaitAfter: flowCfg.awaitAfter
         };
       }
     }
@@ -182,13 +194,13 @@ async function loadPyConfig(absPath, logger) {
   return { queueName, flow, hasDefaultExport: true };
 }
 
-async function scanWorkers(layers, queuesDir = "queues") {
+async function scanWorkers(layers, functionsDir = "functions") {
   const logger = useLogger();
   const workerByVirtualPath = /* @__PURE__ */ new Map();
   const seenFiles = /* @__PURE__ */ new Set();
   const flowSources = [];
   for (const layer of layers) {
-    const base = join(layer.serverDir, queuesDir);
+    const base = join(layer.serverDir, functionsDir);
     if (!existsSync(base)) continue;
     const files = await globby("**/*.{ts,js,mjs,cjs,mts,cts,py}", { cwd: base, dot: false });
     for (const rel of files) {
@@ -216,6 +228,7 @@ async function scanWorkers(layers, queuesDir = "queues") {
             queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
             workerByVirtualPath.set(virtualPath, {
               id,
+              name: queueName,
               kind,
               filePath: virtualPath,
               absPath: abs,
@@ -239,6 +252,7 @@ async function scanWorkers(layers, queuesDir = "queues") {
           queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
           workerByVirtualPath.set(virtualPath, {
             id,
+            name: queueName,
             kind,
             filePath: virtualPath,
             absPath: abs,
@@ -262,6 +276,7 @@ async function scanWorkers(layers, queuesDir = "queues") {
               queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
               workerByVirtualPath.set(virtualPath, {
                 id,
+                name: queueName,
                 kind,
                 filePath: virtualPath,
                 absPath: abs,
@@ -314,20 +329,41 @@ function buildFlows(flowSources) {
         const key = `${flowId}:${f.role}:${mainStep}`;
         if (!seenFlowKeys.has(key)) {
           seenFlowKeys.add(key);
-          bucket.entry = { step: mainStep, queue, workerId: id };
+          bucket.entry = {
+            step: mainStep,
+            queue,
+            workerId: id,
+            emits: f.emits,
+            awaitBefore: f.awaitBefore,
+            awaitAfter: f.awaitAfter
+          };
         }
         for (const s of steps.slice(1)) {
           const skey = `${flowId}:step:${s}`;
           if (seenFlowKeys.has(skey)) continue;
           seenFlowKeys.add(skey);
-          bucket.steps[s] = { queue, workerId: id, subscribes: f.subscribes };
+          bucket.steps[s] = {
+            queue,
+            workerId: id,
+            subscribes: f.subscribes,
+            emits: f.emits,
+            awaitBefore: f.awaitBefore,
+            awaitAfter: f.awaitAfter
+          };
         }
       } else {
         for (const s of steps) {
           const skey = `${flowId}:${f.role}:${s}`;
           if (seenFlowKeys.has(skey)) continue;
           seenFlowKeys.add(skey);
-          bucket.steps[s] = { queue, workerId: id, subscribes: f.subscribes };
+          bucket.steps[s] = {
+            queue,
+            workerId: id,
+            subscribes: f.subscribes,
+            emits: f.emits,
+            awaitBefore: f.awaitBefore,
+            awaitAfter: f.awaitAfter
+          };
         }
       }
       if (f.subscribes) {
@@ -484,6 +520,46 @@ function findTriggeredSteps(stepName, step, allSteps) {
   }
   return Array.from(triggered);
 }
+function getStepAwaitTimeout(step) {
+  let timeout = 0;
+  if (step.awaitBefore?.timeout) timeout += step.awaitBefore.timeout;
+  if (step.awaitAfter?.timeout) timeout += step.awaitAfter.timeout;
+  return timeout;
+}
+function calculateFlowStallTimeout(steps, levels) {
+  const DEFAULT_STALL_TIMEOUT = 30 * 60 * 1e3;
+  const MIN_BUFFER = 5 * 60 * 1e3;
+  const BUFFER_PERCENTAGE = 0.1;
+  const levelTimeouts = [];
+  let awaitCount = 0;
+  for (const levelSteps of levels) {
+    let maxLevelTimeout = 0;
+    for (const stepName of levelSteps) {
+      const step = steps[stepName];
+      if (!step) continue;
+      const stepTimeout = getStepAwaitTimeout(step);
+      if (stepTimeout > 0) {
+        awaitCount++;
+        maxLevelTimeout = Math.max(maxLevelTimeout, stepTimeout);
+      }
+    }
+    if (maxLevelTimeout > 0) {
+      levelTimeouts.push(maxLevelTimeout);
+    }
+  }
+  if (levelTimeouts.length === 0) {
+    return DEFAULT_STALL_TIMEOUT;
+  }
+  const totalAwaitTimeout = levelTimeouts.reduce((sum, timeout) => sum + timeout, 0);
+  const buffer = Math.max(totalAwaitTimeout * BUFFER_PERCENTAGE, MIN_BUFFER);
+  const calculatedTimeout = totalAwaitTimeout + buffer;
+  if (calculatedTimeout > DEFAULT_STALL_TIMEOUT * 2) {
+    console.log(
+      `[flow-analyzer] Flow has ${awaitCount} await patterns across ${levelTimeouts.length} levels, calculated stall timeout: ${calculatedTimeout / 1e3}s (total await time: ${totalAwaitTimeout / 1e3}s, level timeouts: [${levelTimeouts.map((t) => `${t / 1e3}s`).join(", ")}])`
+    );
+  }
+  return calculatedTimeout;
+}
 function analyzeFlow(flow) {
   const entryStepName = flow.entry?.step;
   const steps = flow.steps || {};
@@ -491,12 +567,14 @@ function analyzeFlow(flow) {
   const levels = calculateLevels(entryStepName, dependencies);
   const analyzedSteps = {};
   for (const [stepName, step] of Object.entries(steps)) {
+    const hasAwaitPattern = !!(step.awaitBefore || step.awaitAfter);
     analyzedSteps[stepName] = {
       ...step,
       name: stepName,
       dependsOn: dependencies[stepName] || [],
       triggers: findTriggeredSteps(stepName, step, steps),
-      level: levels[stepName] ?? 1
+      level: levels[stepName] ?? 1,
+      hasAwaitPattern
     };
   }
   const maxLevel = Math.max(0, ...Object.values(levels));
@@ -507,12 +585,28 @@ function analyzeFlow(flow) {
       levelArray.push(stepName);
     }
   }
+  const stallTimeout = calculateFlowStallTimeout(analyzedSteps, levelGroups);
+  const awaitSteps = Object.values(analyzedSteps).filter((s) => s.hasAwaitPattern);
+  const totalTimeout = awaitSteps.reduce((sum, s) => {
+    let stepTimeout = 0;
+    if (s.awaitBefore?.timeout) stepTimeout += s.awaitBefore.timeout;
+    if (s.awaitAfter?.timeout) stepTimeout += s.awaitAfter.timeout;
+    return sum + stepTimeout;
+  }, 0);
+  const awaitPatterns = awaitSteps.length > 0 ? {
+    steps: awaitSteps.map((s) => s.name),
+    beforeCount: awaitSteps.filter((s) => s.awaitBefore).length,
+    afterCount: awaitSteps.filter((s) => s.awaitAfter).length,
+    totalTimeout
+  } : void 0;
   return {
     id: flow.id,
     entry: flow.entry,
     steps: analyzedSteps,
     levels: levelGroups,
-    maxLevel
+    maxLevel,
+    stallTimeout,
+    awaitPatterns
   };
 }
 
@@ -528,7 +622,7 @@ async function compileRegistryFromServerWorkers(layers, queuesDir = "queues", de
   return compiled;
 }
 
-const logger = useLogger("nuxt-queue");
+const logger = useLogger("nvent");
 function watchQueueFiles(options) {
   const { nuxt, layerInfos, queuesDir, onRefresh } = options;
   const dirsToWatch = layerInfos.map((layer) => {
@@ -590,13 +684,73 @@ function watchQueueFiles(options) {
   return watcher;
 }
 
+function analyzeTriggerDefinitions(workers) {
+  const triggers = [];
+  const seenTriggers = /* @__PURE__ */ new Set();
+  for (const worker of workers) {
+    const triggerDef = worker.flow?.triggers?.define;
+    if (!triggerDef) continue;
+    if (seenTriggers.has(triggerDef.name)) continue;
+    seenTriggers.add(triggerDef.name);
+    triggers.push({
+      name: triggerDef.name,
+      type: triggerDef.type,
+      scope: triggerDef.scope || "flow",
+      displayName: triggerDef.displayName,
+      description: triggerDef.description,
+      source: `function:${worker.name}`,
+      expectedSubscribers: triggerDef.expectedSubscribers,
+      webhook: triggerDef.webhook,
+      schedule: triggerDef.schedule,
+      config: triggerDef.config,
+      registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      registeredBy: "code"
+    });
+  }
+  return triggers;
+}
+function analyzeTriggerSubscriptions(workers) {
+  const subscriptions = [];
+  for (const worker of workers) {
+    if (!worker.flow?.triggers?.subscribe) continue;
+    const flowNames = Array.isArray(worker.flow.names) ? worker.flow.names : [worker.flow.names];
+    for (const flowName of flowNames) {
+      for (const triggerName of worker.flow.triggers.subscribe) {
+        subscriptions.push({
+          triggerName,
+          flowName,
+          mode: worker.flow.triggers.mode || "auto",
+          source: "config",
+          registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+  return subscriptions;
+}
+function buildTriggerIndex(subscriptions) {
+  const triggerToFlows = /* @__PURE__ */ new Map();
+  const flowToTriggers = /* @__PURE__ */ new Map();
+  for (const sub of subscriptions) {
+    if (!triggerToFlows.has(sub.triggerName)) {
+      triggerToFlows.set(sub.triggerName, /* @__PURE__ */ new Set());
+    }
+    triggerToFlows.get(sub.triggerName).add(sub.flowName);
+    if (!flowToTriggers.has(sub.flowName)) {
+      flowToTriggers.set(sub.flowName, /* @__PURE__ */ new Set());
+    }
+    flowToTriggers.get(sub.flowName).add(sub.triggerName);
+  }
+  return { triggerToFlows, flowToTriggers };
+}
+
 function generateRegistryTemplate(registry) {
-  return `// auto-generated by nuxt-queue
+  return `// auto-generated by nvent
 export const registry = ${JSON.stringify(registry, null, 2)};
 
-export const useQueueRegistry = () => registry;
+export const useFunctionRegistry = () => registry;
 
-export default useQueueRegistry;
+export default useFunctionRegistry;
 `;
 }
 function generateHandlersTemplate(registry) {
@@ -605,16 +759,18 @@ function generateHandlersTemplate(registry) {
   const entries = [];
   regWorkers.filter((w) => w?.kind === "ts" && (w?.runtype ? w.runtype !== "task" : registry?.runner?.ts?.isolate !== "task")).forEach((w, i) => {
     const varName = `h${i}`;
+    const moduleVar = `m${i}`;
     const src = w && (w.absPath || w.abs || w.cwd && w.file && join(w.cwd, w.file) || w.entry || w.path) || "";
     if (!src) return;
     const importPath = String(src);
     lines.push(`import ${varName} from '${importPath}'`);
+    lines.push(`import * as ${moduleVar} from '${importPath}'`);
     const queue = String(w?.queue?.name || `w${i}`);
     const id = String(w?.id || `w${i}`);
     const absPath = importPath;
-    entries.push(`{ queue: '${queue}', id: '${id}', absPath: '${absPath}', handler: ${varName} }`);
+    entries.push(`{ queue: '${queue}', id: '${id}', absPath: '${absPath}', handler: ${varName}, module: ${moduleVar} }`);
   });
-  return `// auto-generated by nuxt-queue
+  return `// auto-generated by nvent
 ${lines.join("\n")}
 
 export const handlers = [
@@ -672,11 +828,13 @@ function generateAnalyzedFlowsTemplate(registry) {
       analyzed: {
         levels: analyzed.levels,
         maxLevel: analyzed.maxLevel,
+        stallTimeout: analyzed.stallTimeout,
+        awaitPatterns: analyzed.awaitPatterns,
         steps: analyzed.steps
       }
     };
   });
-  return `// auto-generated by nuxt-queue
+  return `// auto-generated by nvent
 export const analyzedFlows = ${JSON.stringify(analyzedFlows, null, 2)};
 
 export const useAnalyzedFlows = () => analyzedFlows;
@@ -684,145 +842,240 @@ export const useAnalyzedFlows = () => analyzedFlows;
 export default useAnalyzedFlows;
 `;
 }
-
-function normalizeModuleOptions(options) {
-  const defaults = {
-    dir: "queues",
-    ui: true,
-    debug: {},
-    queue: {
-      adapter: "redis",
-      redis: {
-        host: "127.0.0.1",
-        port: 6379
-      },
-      defaultConfig: {
-        // Queue options
-        prefix: "nq",
-        defaultJobOptions: {},
-        // Worker options
-        worker: {
-          concurrency: 2,
-          autorun: true
-        }
-      }
-    },
-    state: {
-      adapter: "redis",
-      namespace: "nq",
-      autoScope: "always",
-      cleanup: {
-        strategy: "never"
-      },
-      redis: {
-        host: "127.0.0.1",
-        port: 6379
-      }
-    },
-    eventStore: {
-      adapter: "memory",
-      options: {
-        file: {
-          dir: ".data/nq-events",
-          ext: ".ndjson",
-          pollMs: 1e3
-        }
-      },
-      retention: {
-        eventTTL: 604800,
-        // 7 days
-        metadataTTL: 2592e3
-        // 30 days
-      }
-    }
-  };
-  if (options.store) {
-    const storeConfig = expandStoreShortcut(options.store);
-    return defu(options, storeConfig, defaults);
-  }
-  return defu(options, defaults);
-}
-function expandStoreShortcut(store) {
-  if (!store) return {};
-  const storeAdapter = store.adapter;
-  if (storeAdapter === "redis") {
-    const redisConfig = store.redis || {
-      host: "127.0.0.1",
-      port: 6379
-    };
-    return {
-      queue: {
-        adapter: "redis",
-        redis: redisConfig,
-        defaultConfig: {}
-      },
-      state: {
-        adapter: "redis",
-        namespace: "nq",
-        autoScope: "always",
-        cleanup: { strategy: "never" },
-        redis: redisConfig
-      },
-      eventStore: {
-        adapter: "redis",
-        redis: redisConfig
-      }
-    };
+function generateTriggerRegistryTemplate(registry) {
+  const workers = registry?.workers || [];
+  const triggers = analyzeTriggerDefinitions(workers);
+  const subscriptions = analyzeTriggerSubscriptions(workers);
+  const index = buildTriggerIndex(subscriptions);
+  const triggerToFlows = {};
+  for (const [trigger, subs] of index.triggerToFlows.entries()) {
+    triggerToFlows[trigger] = Array.from(subs);
   }
-  if (storeAdapter === "postgres") {
-    const postgresConfig = store.postgres || {
-      connectionString: process.env.DATABASE_URL || "postgresql://localhost:5432/nuxt_queue"
-    };
-    return {
-      queue: {
-        adapter: "postgres",
-        postgres: postgresConfig,
-        defaultConfig: {}
-      },
-      state: {
-        adapter: "postgres",
-        postgres: postgresConfig
-      },
-      eventStore: {
-        adapter: "postgres",
-        postgres: postgresConfig
-      }
-    };
+  const flowToTriggers = {};
+  for (const [flow, triggers2] of index.flowToTriggers.entries()) {
+    flowToTriggers[flow] = Array.from(triggers2);
   }
-  return {};
-}
-function toRuntimeConfig(normalizedOptions) {
-  return {
-    debug: normalizedOptions.debug,
-    workers: [],
-    queue: normalizedOptions.queue,
-    state: normalizedOptions.state,
-    eventStore: normalizedOptions.eventStore
+  const triggerRegistry = {
+    triggers,
+    subscriptions,
+    index: {
+      triggerToFlows,
+      flowToTriggers
+    },
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString()
   };
+  return `// auto-generated by nvent
+export const triggerRegistry = ${JSON.stringify(triggerRegistry, null, 2)};
+
+export const useTriggerRegistry = () => triggerRegistry;
+
+export default useTriggerRegistry;
+`;
 }
-function getRedisStorageConfig(normalizedOptions) {
-  const redisConfig = normalizedOptions.queue.redis || normalizedOptions.state.redis;
-  if (!redisConfig) {
-    return {
-      host: "127.0.0.1",
-      port: 6379
-    };
-  }
-  return {
-    host: redisConfig.host,
-    port: redisConfig.port,
-    username: redisConfig.username,
-    password: redisConfig.password,
-    db: redisConfig.db
-  };
+function generateAdapterTypesTemplate(resolverFn) {
+  return `// Auto-generated adapter type definitions
+// External adapter packages can import these types
+
+// Queue Adapter
+export type {
+  QueueAdapter,
+  JobInput,
+  Job,
+  JobsQuery,
+  JobOptions,
+  JobState,
+  ScheduleOptions,
+  JobCounts,
+  QueueEvent,
+  WorkerHandler,
+  WorkerContext,
+  WorkerOptions,
+} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/queue"))}
+
+// Stream Adapter
+export type {
+  StreamAdapter,
+  StreamEvent,
+  SubscribeOptions,
+  SubscriptionHandle,
+} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/stream"))}
+
+// Store Adapter
+export type {
+  StoreAdapter,
+  EventRecord,
+  EventReadOptions,
+  EventSubscription,
+  ListOptions,
+} from ${JSON.stringify(resolverFn("./runtime/adapters/interfaces/store"))}
+
+// Event Types
+export type {
+  EventType,
+  BaseEvent,
+  StepEvent,
+  FlowStartEvent,
+  FlowCompletedEvent,
+  FlowFailedEvent,
+  FlowCancelEvent,
+  FlowStalledEvent,
+  StepStartedEvent,
+  StepCompletedEvent,
+  StepFailedEvent,
+  StepRetryEvent,
+  LogEvent,
+  EmitEvent,
+  StateEvent,
+  FlowEvent,
+} from ${JSON.stringify(resolverFn("./runtime/events/types"))}
+
+// Adapter Registry
+export type { AdapterRegistry } from ${JSON.stringify(resolverFn("./runtime/adapters/registry"))}`;
+}
+
+function getServerImports(resolverFn, buildDir) {
+  return [
+    // Generated templates
+    {
+      name: "useFunctionRegistry",
+      as: "$useFunctionRegistry",
+      from: resolverFn(buildDir + "/function-registry")
+    },
+    {
+      name: "useWorkerHandlers",
+      as: "$useWorkerHandlers",
+      from: resolverFn(buildDir + "/worker-handlers")
+    },
+    {
+      name: "useAnalyzedFlows",
+      as: "$useAnalyzedFlows",
+      from: resolverFn(buildDir + "/analyzed-flows")
+    },
+    {
+      name: "useTriggerRegistry",
+      as: "$useTriggerRegistry",
+      from: resolverFn(buildDir + "/trigger-registry")
+    },
+    // Core utilities for user code
+    {
+      name: "defineFunctionConfig",
+      from: resolverFn("./runtime/nitro/utils/defineFunctionConfig")
+    },
+    {
+      name: "defineFunction",
+      from: resolverFn("./runtime/nitro/utils/defineFunction")
+    },
+    // Composables users may need in server code
+    {
+      name: "useEventManager",
+      from: resolverFn("./runtime/nitro/utils/useEventManager")
+    },
+    {
+      name: "usePeerManager",
+      from: resolverFn("./runtime/nitro/utils/wsPeerManager")
+    },
+    {
+      name: "useNventLogger",
+      from: resolverFn("./runtime/nitro/utils/useNventLogger")
+    },
+    {
+      name: "useHookRegistry",
+      from: resolverFn("./runtime/nitro/utils/useHookRegistry")
+    },
+    {
+      name: "useAwait",
+      from: resolverFn("./runtime/nitro/utils/useAwait")
+    },
+    {
+      name: "useRunContext",
+      from: resolverFn("./runtime/nitro/utils/useRunContext")
+    },
+    {
+      name: "defineAwaitRegisterHook",
+      from: resolverFn("./runtime/nitro/utils/defineHooks")
+    },
+    {
+      name: "defineAwaitResolveHook",
+      from: resolverFn("./runtime/nitro/utils/defineHooks")
+    },
+    // Adapter composables
+    {
+      name: "useQueueAdapter",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    {
+      name: "useStoreAdapter",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    {
+      name: "useStreamAdapter",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    {
+      name: "useStateAdapter",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    {
+      name: "getAdapters",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    {
+      name: "setAdapters",
+      from: resolverFn("./runtime/nitro/utils/adapters")
+    },
+    // Runtime utilities
+    {
+      name: "useStreamTopics",
+      from: resolverFn("./runtime/nitro/utils/useStreamTopics")
+    },
+    {
+      name: "useTrigger",
+      from: resolverFn("./runtime/nitro/utils/useTrigger")
+    },
+    {
+      name: "useFlow",
+      from: resolverFn("./runtime/nitro/utils/useFlow")
+    },
+    // Scheduler
+    {
+      name: "useScheduler",
+      from: resolverFn("./runtime/scheduler")
+    },
+    {
+      name: "initializeScheduler",
+      from: resolverFn("./runtime/scheduler")
+    },
+    {
+      name: "shutdownScheduler",
+      from: resolverFn("./runtime/scheduler")
+    },
+    // Adapter registration utilities for external modules
+    {
+      name: "registerQueueAdapter",
+      from: resolverFn("./runtime/nitro/utils/registerAdapter")
+    },
+    {
+      name: "registerStreamAdapter",
+      from: resolverFn("./runtime/nitro/utils/registerAdapter")
+    },
+    {
+      name: "registerStoreAdapter",
+      from: resolverFn("./runtime/nitro/utils/registerAdapter")
+    },
+    // Adapter base utilities for external adapter packages
+    {
+      name: "createStoreValidator",
+      from: resolverFn("./runtime/adapters/base/store-validator")
+    }
+  ];
 }
 
 const meta = {
-  name: "queue",
-  version: "0.1",
-  configKey: "queue"
+  name: "nvent",
+  version: "0.4.1",
+  configKey: "nvent"
 };
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule().with({
   meta,
   defaults: {},
   moduleDependencies: {
@@ -832,30 +1085,9 @@ const module = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const config = normalizeModuleOptions(options);
-    addServerScanDir(resolve("./runtime/server"));
-    addImportsDir(resolve("./runtime/shared/utils"));
-    addImportsDir(resolve("./runtime/app/composables"));
-    if (config.ui) {
-      nuxt.options.css = nuxt.options.css || [];
-      nuxt.options.css.push(resolve("./runtime/app/assets/vueflow.css"));
-      addPlugin({
-        src: resolve("./runtime/app/plugins/vueflow.client"),
-        mode: "client"
-      });
-      addComponentsDir({
-        path: resolve("./runtime/app/components"),
-        prefix: "Queue"
-      });
-      addComponent({
-        name: "QueueApp",
-        filePath: resolve("./runtime/app/pages/index.vue"),
-        global: true
-      });
-    }
-    nuxt.options.vite.optimizeDeps = defu(nuxt.options.vite.optimizeDeps, {
-      include: ["vanilla-jsoneditor"]
-    });
+    const userConfig = nuxt.options[meta.configKey] || {};
+    const mergedOptions = { ...userConfig, ...options };
+    const config = normalizeModuleOptions(mergedOptions);
     nuxt.hook("nitro:config", (nitro) => {
       const redisConfig = getRedisStorageConfig(config);
       nitro.storage = defu(nitro.storage || {}, {
@@ -870,37 +1102,35 @@ const module = defineNuxtModule({
       });
     });
     const runtimeConfig = nuxt.options.runtimeConfig;
-    runtimeConfig.queue = defu(runtimeConfig.queue || {}, toRuntimeConfig(config));
-    if (!runtimeConfig.queue) runtimeConfig.queue = {};
-    runtimeConfig.queue.rootDir = nuxt.options.rootDir;
+    runtimeConfig.nvent = defu(runtimeConfig.nvent || {}, toRuntimeConfig(config));
+    if (!runtimeConfig.nvent) runtimeConfig.nvent = {};
+    runtimeConfig.nvent.rootDir = nuxt.options.rootDir;
     const layerInfos = nuxt.options._layers.map((l) => ({
       rootDir: l.config.rootDir,
       serverDir: l.config?.serverDir || join(l.config.rootDir, "server")
     }));
-    const { worker: _worker, ...queueOptions } = config.queue.defaultConfig || {};
+    const { worker, ...queueOptions } = config.queue;
     const defaultConfigs = {
       queue: queueOptions,
-      worker: config.queue.defaultConfig?.worker
+      worker
     };
-    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "queues", defaultConfigs);
+    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "functions", defaultConfigs);
     const compiledWithMeta = defu(compiledRegistry, {
       version: 1,
       compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
       provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
       logger: { name: "console", level: "info" },
-      state: config.state,
-      eventStore: config.eventStore,
       runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-      workers: [],
       flows: {},
       eventIndex: {}
     });
     const compiledSnapshot = JSON.parse(JSON.stringify(compiledWithMeta));
     let lastCompiledRegistry = compiledSnapshot;
-    const REGISTRY_TEMPLATE = "queue-registry.mjs";
+    const REGISTRY_TEMPLATE = "function-registry.mjs";
     const HANDLERS_TEMPLATE = "worker-handlers.mjs";
     const ANALYZED_FLOWS_TEMPLATE = "analyzed-flows.mjs";
-    for (const templateName of [REGISTRY_TEMPLATE, HANDLERS_TEMPLATE, ANALYZED_FLOWS_TEMPLATE]) {
+    const TRIGGER_REGISTRY_TEMPLATE = "trigger-registry.mjs";
+    for (const templateName of [REGISTRY_TEMPLATE, HANDLERS_TEMPLATE, ANALYZED_FLOWS_TEMPLATE, TRIGGER_REGISTRY_TEMPLATE]) {
       const templatePath = resolve(nuxt.options.buildDir, templateName);
       nuxt.options.build.transpile.push(templatePath);
     }
@@ -919,101 +1149,65 @@ const module = defineNuxtModule({
       write: true,
       getContents: () => generateAnalyzedFlowsTemplate(lastCompiledRegistry)
     });
-    addServerImports([
-      // Generated templates
-      {
-        name: "useQueueRegistry",
-        as: "$useQueueRegistry",
-        from: resolve(nuxt.options.buildDir, "queue-registry")
-      },
-      {
-        name: "useWorkerHandlers",
-        as: "$useWorkerHandlers",
-        from: resolve(nuxt.options.buildDir, "worker-handlers")
-      },
-      {
-        name: "useAnalyzedFlows",
-        as: "$useAnalyzedFlows",
-        from: resolve(nuxt.options.buildDir, "analyzed-flows")
-      },
-      // Core utilities for user code (moved to server-utils to avoid bundling issues)
-      {
-        name: "defineQueueConfig",
-        from: resolve("./runtime/server-utils/utils/defineQueueConfig")
-      },
-      {
-        name: "defineQueueWorker",
-        from: resolve("./runtime/server-utils/utils/defineQueueWorker")
-      },
-      // Composables users may need in server code
-      {
-        name: "useQueue",
-        from: resolve("./runtime/server-utils/utils/useQueue")
-      },
-      {
-        name: "useFlowEngine",
-        from: resolve("./runtime/server-utils/utils/useFlowEngine")
-      },
-      {
-        name: "useEventStore",
-        from: resolve("./runtime/server-utils/utils/useEventStore")
-      },
-      {
-        name: "useLogs",
-        from: resolve("./runtime/server-utils/utils/useLogs")
-      },
-      {
-        name: "useEventManager",
-        from: resolve("./runtime/server-utils/utils/useEventManager")
-      },
-      {
-        name: "usePeerManager",
-        from: resolve("./runtime/server-utils/utils/wsPeerManager")
-      },
-      {
-        name: "useNventLogger",
-        from: resolve("./runtime/server-utils/utils/useNventLogger")
-      }
-    ]);
+    addTemplate({
+      filename: TRIGGER_REGISTRY_TEMPLATE,
+      write: true,
+      getContents: () => generateTriggerRegistryTemplate(lastCompiledRegistry)
+    });
+    addTypeTemplate({
+      filename: "types/nvent-adapters.d.ts",
+      getContents: () => generateAdapterTypesTemplate(resolve)
+    });
+    nuxt.options.alias["#nvent/adapters"] = resolve(nuxt.options.buildDir, "types/nvent-adapters");
+    addServerPlugin(resolve("./runtime/nitro/plugins/00.adapters"));
+    addServerPlugin(resolve("./runtime/nitro/plugins/01.ws-lifecycle"));
+    addServerPlugin(resolve("./runtime/nitro/plugins/02.workers"));
+    addServerPlugin(resolve("./runtime/nitro/plugins/03.triggers"));
+    addServerHandler({
+      route: "/api/_webhook/await/:flowName/:runId/:stepName",
+      handler: resolve("./runtime/nitro/routes/webhook.await")
+    });
+    addServerHandler({
+      route: "/api/_webhook/trigger/:triggerName",
+      handler: resolve("./runtime/nitro/routes/webhook.trigger")
+    });
+    addServerImports(getServerImports(resolve, nuxt.options.buildDir));
     const refreshRegistry = async (reason, changedPath) => {
-      const queuesRel = config.dir || "queues";
-      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, queuesRel, defaultConfigs);
+      const functionsDir = config.dir || "functions";
+      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, functionsDir, defaultConfigs);
       lastCompiledRegistry = JSON.parse(JSON.stringify(defu(updatedRegistry, {
         version: 1,
         compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
         provider: { name: config.queue.adapter === "postgres" ? "pgboss" : "bullmq" },
         logger: { name: "console", level: "info" },
-        state: config.state,
-        eventStore: config.eventStore,
         runner: { ts: { isolate: "inprocess" }, py: { enabled: false, cmd: "python3", importMode: "file" } },
-        workers: [],
         flows: {},
         eventIndex: {}
       })));
-      console.log(`[nuxt-queue] registry refreshed (${reason})`, changedPath || "");
-      console.log(`[nuxt-queue] new registry has ${lastCompiledRegistry.workers?.length || 0} workers`);
-      console.log(`[nuxt-queue] new registry compiled at: ${lastCompiledRegistry.compiledAt}`);
+      console.log(`[nvent] registry refreshed (${reason})`, changedPath || "");
+      console.log(`[nvent] new registry has ${lastCompiledRegistry.workers?.length || 0} workers`);
+      console.log(`[nvent] new registry compiled at: ${lastCompiledRegistry.compiledAt}`);
       await updateTemplates({
         filter: (template) => {
-          const match = template.filename === REGISTRY_TEMPLATE || template.filename === HANDLERS_TEMPLATE || template.filename === ANALYZED_FLOWS_TEMPLATE;
+          const match = template.filename === REGISTRY_TEMPLATE || template.filename === HANDLERS_TEMPLATE || template.filename === ANALYZED_FLOWS_TEMPLATE || template.filename === TRIGGER_REGISTRY_TEMPLATE;
           if (match) {
-            console.log(`[nuxt-queue] updating template: ${template.filename}`);
+            console.log(`[nvent] updating template: ${template.filename}`);
           }
           return match;
         }
       });
-      console.log(`[nuxt-queue] templates updated`);
+      console.log(`[nvent] templates updated`);
     };
     if (nuxt.options.dev) {
-      const queuesRel = config.dir || "queues";
+      const functionsDir = config.dir || "functions";
       watchQueueFiles({
         nuxt,
         layerInfos,
-        queuesDir: queuesRel,
+        queuesDir: functionsDir,
         onRefresh: refreshRegistry
       });
     }
   }
 });
 
-export { module as default };
+export { module$1 as default };