nvent 0.4.5 → 0.5.0

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { dirname, join, extname, relative } from 'node:path';
-import { useLogger, defineNuxtModule, createResolver, addServerScanDir, addTemplate, addTypeTemplate, 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';
@@ -30,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
       };
     }
   }
@@ -42,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) {
@@ -69,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
         };
       }
     }
@@ -80,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}`);
   }
@@ -175,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
         };
       }
     }
@@ -183,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) {
@@ -217,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,
@@ -240,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,
@@ -263,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,
@@ -315,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) {
@@ -485,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 || {};
@@ -492,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));
@@ -508,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
   };
 }
 
@@ -529,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) => {
@@ -591,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) {
@@ -606,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 = [
@@ -673,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;
@@ -685,13 +842,240 @@ export const useAnalyzedFlows = () => analyzedFlows;
 export default useAnalyzedFlows;
 `;
 }
+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);
+  }
+  const flowToTriggers = {};
+  for (const [flow, triggers2] of index.flowToTriggers.entries()) {
+    flowToTriggers[flow] = Array.from(triggers2);
+  }
+  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 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: "nvent",
   version: "0.4.1",
   configKey: "nvent"
 };
-const module$1 = defineNuxtModule({
+const module$1 = defineNuxtModule().with({
   meta,
   defaults: {},
   moduleDependencies: {
@@ -704,7 +1088,6 @@ const module$1 = defineNuxtModule({
     const userConfig = nuxt.options[meta.configKey] || {};
     const mergedOptions = { ...userConfig, ...options };
     const config = normalizeModuleOptions(mergedOptions);
-    addServerScanDir(resolve("./runtime/server"));
     nuxt.hook("nitro:config", (nitro) => {
       const redisConfig = getRedisStorageConfig(config);
       nitro.storage = defu(nitro.storage || {}, {
@@ -743,10 +1126,11 @@ const module$1 = defineNuxtModule({
     });
     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);
     }
@@ -765,155 +1149,29 @@ const module$1 = defineNuxtModule({
       write: true,
       getContents: () => generateAnalyzedFlowsTemplate(lastCompiledRegistry)
     });
+    addTemplate({
+      filename: TRIGGER_REGISTRY_TEMPLATE,
+      write: true,
+      getContents: () => generateTriggerRegistryTemplate(lastCompiledRegistry)
+    });
     addTypeTemplate({
       filename: "types/nvent-adapters.d.ts",
-      getContents: () => `
-// 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(resolve("./runtime/adapters/interfaces/queue"))}
-
-// Stream Adapter
-export type {
-  StreamAdapter,
-  StreamEvent,
-  SubscribeOptions,
-  SubscriptionHandle,
-} from ${JSON.stringify(resolve("./runtime/adapters/interfaces/stream"))}
-
-// Store Adapter
-export type {
-  StoreAdapter,
-  EventRecord,
-  EventReadOptions,
-  EventSubscription,
-  ListOptions,
-} from ${JSON.stringify(resolve("./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(resolve("./runtime/events/types"))}
-
-// Adapter Registry
-export type { AdapterRegistry } from ${JSON.stringify(resolve("./runtime/adapters/registry"))}
-      `.trim()
+      getContents: () => generateAdapterTypesTemplate(resolve)
     });
     nuxt.options.alias["#nvent/adapters"] = resolve(nuxt.options.buildDir, "types/nvent-adapters");
-    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
-      {
-        name: "defineFunctionConfig",
-        from: resolve("./runtime/utils/defineFunctionConfig")
-      },
-      {
-        name: "defineFunction",
-        from: resolve("./runtime/utils/defineFunction")
-      },
-      // Composables users may need in server code
-      {
-        name: "useFlowEngine",
-        from: resolve("./runtime/utils/useFlowEngine")
-      },
-      {
-        name: "useEventManager",
-        from: resolve("./runtime/utils/useEventManager")
-      },
-      {
-        name: "usePeerManager",
-        from: resolve("./runtime/utils/wsPeerManager")
-      },
-      {
-        name: "useNventLogger",
-        from: resolve("./runtime/utils/useNventLogger")
-      },
-      {
-        name: "useQueueAdapter",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "useStoreAdapter",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "useStreamAdapter",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "useStateAdapter",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "getAdapters",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "setAdapters",
-        from: resolve("./runtime/utils/adapters")
-      },
-      {
-        name: "useStreamTopics",
-        from: resolve("./runtime/utils/useStreamTopics")
-      },
-      // Adapter registration utilities for external modules
-      {
-        name: "registerQueueAdapter",
-        from: resolve("./runtime/utils/registerAdapter")
-      },
-      {
-        name: "registerStreamAdapter",
-        from: resolve("./runtime/utils/registerAdapter")
-      },
-      {
-        name: "registerStoreAdapter",
-        from: resolve("./runtime/utils/registerAdapter")
-      }
-    ]);
+    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 functionsDir = config.dir || "functions";
       const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, functionsDir, defaultConfigs);
@@ -926,19 +1184,19 @@ export type { AdapterRegistry } from ${JSON.stringify(resolve("./runtime/adapter
         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 functionsDir = config.dir || "functions";