nvent 0.5.15 → 1.0.0-alpha.2

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

@@ -1,422 +0,0 @@
-import { getEventBus } from "../eventBus.js";
-import { useTrigger, useNventLogger, useStoreAdapter, useQueueAdapter, $useAnalyzedFlows, $useFunctionRegistry, useStreamTopics } from "#imports";
-import { getTriggerRuntime } from "../utils/triggerRuntime.js";
-import { scheduleTrigger, unscheduleTrigger } from "../utils/scheduleTrigger.js";
-export function createTriggerWiring() {
-  const unsubs = [];
-  let wired = false;
-  async function start() {
-    if (wired) return;
-    wired = true;
-    const logger = useNventLogger("trigger-wiring");
-    const eventBus = getEventBus();
-    const trigger = useTrigger();
-    const store = useStoreAdapter();
-    const { StoreSubjects } = useStreamTopics();
-    const runtime = getTriggerRuntime(store, logger);
-    await trigger.initialize();
-    logger.info("Setting up trigger event wiring");
-    const handlePersistence = async (e) => {
-      try {
-        if (e.id && e.ts) {
-          return;
-        }
-        const triggerName = e.triggerName || e.data?.triggerName;
-        if (!triggerName) {
-          return;
-        }
-        const streamName = StoreSubjects.triggerStream(triggerName);
-        if (!e.type) {
-          logger.error("Event missing type field", { event: e });
-          return;
-        }
-        const eventData = {
-          type: e.type,
-          triggerName,
-          data: e.data
-        };
-        const persistedEvent = await store.stream.append(streamName, eventData);
-        await eventBus.publish(persistedEvent);
-        logger.debug("Stored trigger event", {
-          type: e.type,
-          triggerName,
-          id: persistedEvent.id
-        });
-      } catch (err) {
-        logger.error("ERROR persisting trigger event", {
-          type: e.type,
-          triggerName: e.triggerName,
-          error: err?.message
-        });
-      }
-    };
-    const handleOrchestration = async (e) => {
-      try {
-        if (e.id && e.ts) {
-          return;
-        }
-        const triggerName = e.triggerName || e.data?.triggerName;
-        if (!triggerName) {
-          logger.debug("Orchestration skipped - no triggerName", { type: e.type });
-          return;
-        }
-        logger.debug("Processing trigger orchestration", { type: e.type, triggerName });
-        const indexKey = StoreSubjects.triggerIndex();
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const nowTimestamp = Date.now();
-        if (e.type === "trigger.registered") {
-          const data = e.data;
-          if (store.index.add) {
-            await store.index.add(indexKey, triggerName, nowTimestamp, {
-              "name": data.name,
-              "type": data.type,
-              "scope": data.scope,
-              "status": "active",
-              "displayName": data.displayName,
-              "description": data.description,
-              "source": data.source || "programmatic",
-              "registeredAt": now,
-              "registeredBy": "runtime",
-              "lastActivityAt": now,
-              "stats.totalFires": 0,
-              "stats.totalFlowsStarted": 0,
-              "stats.activeSubscribers": 0,
-              "webhook": data.webhook,
-              "schedule": data.schedule,
-              "config": data.config,
-              "version": 1
-            });
-          }
-          const entry = {
-            name: data.name,
-            type: data.type,
-            scope: data.scope,
-            status: "active",
-            displayName: data.displayName,
-            description: data.description,
-            source: data.source || "programmatic",
-            registeredAt: now,
-            registeredBy: "runtime",
-            lastActivityAt: now,
-            subscriptions: {},
-            stats: { totalFires: 0, totalFlowsStarted: 0, activeSubscribers: 0 },
-            webhook: data.webhook,
-            schedule: data.schedule,
-            config: data.config,
-            version: 1
-          };
-          runtime.addTrigger(triggerName, entry);
-          logger.info("Registered trigger in index", { triggerName });
-          if (data.type === "schedule" && data.schedule) {
-            await scheduleTrigger(triggerName, data.schedule, data.status || "active");
-          }
-        }
-        if (e.type === "trigger.updated") {
-          const data = e.data;
-          if (store.index.updateWithRetry) {
-            await store.index.updateWithRetry(indexKey, triggerName, {
-              type: data.type,
-              scope: data.scope,
-              status: data.status,
-              displayName: data.displayName,
-              description: data.description,
-              webhook: data.webhook,
-              schedule: data.schedule,
-              config: data.config,
-              lastActivityAt: now
-            });
-          }
-          const existing = runtime.getTrigger(triggerName);
-          if (existing) {
-            const updated = {
-              ...existing,
-              status: data.status !== void 0 ? data.status : existing.status,
-              displayName: data.displayName !== void 0 ? data.displayName : existing.displayName,
-              description: data.description !== void 0 ? data.description : existing.description,
-              webhook: data.webhook !== void 0 ? data.webhook : existing.webhook,
-              schedule: data.schedule !== void 0 ? data.schedule : existing.schedule,
-              config: data.config !== void 0 ? data.config : existing.config,
-              lastActivityAt: now
-            };
-            runtime.addTrigger(triggerName, updated);
-            if (updated.type === "schedule" && updated.schedule) {
-              await scheduleTrigger(triggerName, updated.schedule, updated.status);
-            }
-          }
-          logger.info("Updated trigger in index and runtime", { triggerName, status: data.status });
-        }
-        if (e.type === "subscription.added") {
-          const data = e.data;
-          const { flow, mode } = data;
-          const existingSub = runtime.getSubscription(triggerName, flow);
-          if (store.index.updateWithRetry) {
-            await store.index.updateWithRetry(indexKey, triggerName, {
-              subscriptions: {
-                [flow]: {
-                  mode,
-                  subscribedAt: existingSub ? existingSub.registeredAt || now : now
-                }
-              },
-              lastActivityAt: now
-            });
-            if (!existingSub && store.index.increment) {
-              await store.index.increment(indexKey, triggerName, "stats.activeSubscribers", 1);
-            }
-          }
-          const subscription = {
-            triggerName,
-            flowName: flow,
-            mode,
-            source: "programmatic",
-            registeredAt: existingSub?.registeredAt || now
-          };
-          runtime.addSubscription(triggerName, flow, subscription);
-          logger.info(`Subscription ${existingSub ? "updated" : "added"}`, { triggerName, flow, mode });
-        }
-        if (e.type === "subscription.removed") {
-          const data = e.data;
-          const { flow } = data;
-          if (store.index.updateWithRetry) {
-            await store.index.updateWithRetry(indexKey, triggerName, {
-              subscriptions: {
-                [flow]: null
-                // null removes the field
-              },
-              lastActivityAt: now
-            });
-            if (store.index.increment) {
-              await store.index.increment(indexKey, triggerName, "stats.activeSubscribers", -1);
-            }
-          }
-          runtime.removeSubscription(triggerName, flow);
-          logger.info("Subscription removed", { triggerName, flow });
-        }
-        if (e.type === "trigger.fired") {
-          const flowsStarted = await handleTriggerFired(e);
-          if (flowsStarted.length > 0 && store.index.increment) {
-            await store.index.increment(indexKey, triggerName, "stats.totalFlowsStarted", flowsStarted.length);
-          }
-          logger.debug("Trigger fired and processed", { triggerName, flowsStarted: flowsStarted.length });
-        }
-        if (e.type === "trigger.deleted") {
-          const triggerEntry = runtime.getTrigger(triggerName);
-          const wasScheduleTrigger = triggerEntry?.type === "schedule";
-          if (store.index.delete) {
-            await store.index.delete(indexKey, triggerName);
-          }
-          const triggerStreamKey = StoreSubjects.triggerStream(triggerName);
-          if (store.stream.delete) {
-            await store.stream.delete(triggerStreamKey);
-          }
-          runtime.removeTrigger(triggerName);
-          if (wasScheduleTrigger) {
-            await unscheduleTrigger(triggerName);
-          }
-          logger.info("Trigger deleted completely", { triggerName });
-        }
-      } catch (err) {
-        logger.error("ERROR in trigger orchestration", {
-          type: e.type,
-          triggerName: e.triggerName,
-          error: err?.message,
-          stack: err?.stack
-        });
-      }
-    };
-    const handleTriggerStats = async (e) => {
-      try {
-        if (!e.id || !e.ts) {
-          return;
-        }
-        const triggerName = e.triggerName || e.data?.triggerName;
-        if (!triggerName) return;
-        const indexKey = StoreSubjects.triggerIndex();
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        if (e.type === "trigger.fired") {
-          if (store.index.updateWithRetry) {
-            await store.index.updateWithRetry(indexKey, triggerName, {
-              stats: {
-                lastFiredAt: now
-              },
-              lastActivityAt: now
-            });
-          }
-          if (store.index.increment) {
-            await store.index.increment(indexKey, triggerName, "stats.totalFires", 1);
-          }
-          logger.debug("Updated trigger stats for fire", { triggerName });
-        }
-        try {
-          if (store.index.get) {
-            const indexEntry = await store.index.get(indexKey, triggerName);
-            if (indexEntry) {
-              await eventBus.publish({
-                type: "trigger.stats.updated",
-                triggerName,
-                id: indexEntry.id,
-                metadata: indexEntry.metadata,
-                ts: Date.now()
-              });
-              logger.debug("Published trigger stats update event to bus", { triggerName });
-            }
-          }
-        } catch (err) {
-          logger.warn("Failed to publish trigger stats update event", {
-            triggerName,
-            error: err?.message
-          });
-        }
-      } catch (err) {
-        logger.warn("Failed to update trigger stats", {
-          type: e.type,
-          triggerName: e.triggerName,
-          error: err?.message
-        });
-      }
-    };
-    const eventTypes = [
-      "trigger.registered",
-      "trigger.updated",
-      "trigger.deleted",
-      "trigger.fired",
-      "subscription.added",
-      "subscription.removed"
-    ];
-    const triggerStatsEventTypes = ["trigger.fired"];
-    for (const type of eventTypes) {
-      unsubs.push(eventBus.onType(type, handlePersistence));
-    }
-    for (const type of eventTypes) {
-      unsubs.push(eventBus.onType(type, handleOrchestration));
-    }
-    for (const type of triggerStatsEventTypes) {
-      unsubs.push(eventBus.onType(type, handleTriggerStats));
-    }
-    logger.info("Trigger event wiring setup complete (persistence + orchestration + stats)");
-  }
-  function stop() {
-    const logger = useNventLogger("trigger-wiring");
-    for (const u of unsubs.splice(0)) {
-      try {
-        u();
-      } catch {
-      }
-    }
-    wired = false;
-    logger.debug("Trigger wiring stopped");
-  }
-  return { start, stop };
-}
-export async function handleTriggerFired(event) {
-  const logger = useNventLogger("trigger-wiring");
-  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}`);
-    return [];
-  }
-  const flowsStarted = [];
-  const store = useStoreAdapter();
-  const loggerForRuntime = useNventLogger("trigger-runtime");
-  const runtime = getTriggerRuntime(store, loggerForRuntime);
-  const resolvedData = await runtime.resolvePayload(data);
-  for (const subscription of subscriptions) {
-    try {
-      if (subscription.mode === "manual") {
-        logger.info(
-          `Trigger '${triggerName}' fired for flow '${subscription.flowName}' (manual mode - awaiting manual start)`
-        );
-        continue;
-      }
-      await startFlowFromTrigger(subscription.flowName, triggerName, resolvedData);
-      flowsStarted.push(subscription.flowName);
-    } catch (error) {
-      logger.error("Error starting flow from trigger", {
-        flow: subscription.flowName,
-        trigger: triggerName,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return flowsStarted;
-}
-export async function startFlowFromTrigger(flowName, triggerName, triggerData) {
-  const logger = useNventLogger("trigger-wiring");
-  const eventBus = getEventBus();
-  const queue = useQueueAdapter();
-  const registry = $useFunctionRegistry();
-  const analyzedFlows = $useAnalyzedFlows();
-  const store = useStoreAdapter();
-  const triggerRuntime = getTriggerRuntime(store, logger);
-  const flowDef = analyzedFlows.find((f) => f.id === flowName);
-  if (!flowDef || !flowDef.entry) {
-    logger.error(`Flow '${flowName}' not found or has no entry point`);
-    return;
-  }
-  const flowRegistry = (registry?.flows || {})[flowName];
-  if (!flowRegistry?.entry) {
-    logger.error(`Flow '${flowName}' has no entry in registry`);
-    return;
-  }
-  const triggerDef = triggerRuntime.getTrigger(triggerName);
-  const triggerType = triggerDef?.type || "manual";
-  const runId = `${flowName}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-  logger.info(`Starting flow '${flowName}' from trigger '${triggerName}'`, { runId });
-  const queueName = flowRegistry.entry.queue;
-  const stepName = flowRegistry.entry.step;
-  const payload = {
-    flowId: runId,
-    flowName,
-    trigger: {
-      name: triggerName,
-      type: triggerType,
-      data: triggerData
-    },
-    ...triggerData
-  };
-  const entryWorker = registry?.workers?.find(
-    (w) => w?.flow?.step === stepName && w?.queue?.name === queueName
-  );
-  const defaultOpts = entryWorker?.queue?.defaultJobOptions || {};
-  const analyzedEntry = flowDef.analyzed?.steps?.[stepName];
-  const stepTimeout = analyzedEntry?.stepTimeout;
-  const jobId = `${runId}__${stepName}`;
-  const opts = { ...defaultOpts, jobId, timeout: stepTimeout };
-  try {
-    await queue.enqueue(queueName, {
-      name: stepName,
-      data: payload,
-      opts
-    });
-    logger.info(`Enqueued entry step '${stepName}' to queue '${queueName}'`, { runId });
-    await eventBus.publish({
-      type: "flow.start",
-      flowName,
-      runId,
-      data: {
-        input: triggerData,
-        trigger: {
-          name: triggerName,
-          type: triggerType,
-          data: triggerData
-        }
-      }
-    });
-  } catch (error) {
-    logger.error("Failed to start flow from trigger", {
-      flowName,
-      trigger: triggerName,
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-}

package/dist/runtime/nitro/plugins/00.adapters.d.ts

@@ -1,14 +0,0 @@
-/**
- * Adapter Initialization Plugin (v0.4.1)
- *
- * Initializes the three-adapter architecture with new config format:
- * - QueueAdapter: Job queue operations (from config.queue)
- * - StreamAdapter: Cross-instance pub/sub messaging (from config.stream)
- * - StoreAdapter: Storage - events, documents, KV, indices (from config.store)
- *
- * Uses normalized config with connection fallback from connections.*
- *
- * External adapters can register themselves via the nvent:registerAdapter Nitro hook
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/nitro/plugins/00.adapters.js

@@ -1,73 +0,0 @@
-import { defineNitroPlugin, useRuntimeConfig, useNventLogger, setAdapters, initializeScheduler, shutdownScheduler } from "#imports";
-import { createAdapters, shutdownAdapters } from "../../adapters/factory.js";
-import { useAdapterRegistry } from "../../adapters/registry.js";
-import { createWiringRegistry } from "../../events/wiring/registry.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  const logger = useNventLogger("adapters-plugin");
-  const runtimeConfig = useRuntimeConfig();
-  const config = runtimeConfig.nvent;
-  if (!config) {
-    logger.error("No nvent config found in runtime config");
-    throw new Error("Missing nvent configuration");
-  }
-  logger.info("Initializing adapters", {
-    queue: config.queue?.adapter || "file",
-    stream: config.stream?.adapter || "memory",
-    store: config.store?.adapter || "file"
-  });
-  try {
-    await nitroApp.hooks.callHook("nvent:register-adapters");
-    const registry = useAdapterRegistry();
-    logger.info("Checking registered adapters", {
-      queueAdapters: registry.listQueueAdapters(),
-      streamAdapters: registry.listStreamAdapters(),
-      storeAdapters: registry.listStoreAdapters()
-    });
-    const adapters = await createAdapters({
-      queue: config.queue,
-      stream: config.stream,
-      store: config.store
-    });
-    setAdapters(adapters);
-    logger.info("Adapters initialized successfully", {
-      queueAdapter: config.queue.adapter,
-      streamAdapter: config.stream.adapter,
-      storeAdapter: config.store.adapter
-    });
-    await initializeScheduler(adapters.store);
-    logger.info("Scheduler initialized");
-    const wiring = createWiringRegistry({
-      streamWiring: {
-        enabled: true
-        // Enable for WebSocket support
-      },
-      stateWiring: {
-        // Strategy is read from config by default (queue.store.state.cleanup.strategy)
-        // Can be overridden here if needed
-      }
-    });
-    await wiring.start();
-    logger.info("Flow wiring started");
-    await nitroApp.hooks.callHook("nvent:adapters:ready");
-    return {
-      hooks: {
-        close: async () => {
-          logger.info("Shutting down");
-          try {
-            await wiring.stop();
-            logger.info("Flow wiring stopped");
-            await shutdownScheduler();
-            logger.info("Scheduler shut down");
-            await shutdownAdapters(adapters);
-            logger.info("Adapters shut down successfully");
-          } catch (error) {
-            logger.error("Error during shutdown", { error });
-          }
-        }
-      }
-    };
-  } catch (error) {
-    logger.error("Failed to initialize adapters", { error });
-    throw error;
-  }
-});

package/dist/runtime/nitro/plugins/01.ws-lifecycle.d.ts

@@ -1,5 +0,0 @@
-/**
- * Nitro plugin to handle graceful WebSocket shutdown during HMR
- */
-declare const _default: any;
-export default _default;

package/dist/runtime/nitro/plugins/01.ws-lifecycle.js

@@ -1,69 +0,0 @@
-import {
-  defineNitroPlugin,
-  useNventLogger,
-  usePeerManager
-} from "#imports";
-export default defineNitroPlugin((nitroApp) => {
-  const logger = useNventLogger("plugin-ws-lifecycle");
-  logger.info("[ws-lifecycle] WebSocket lifecycle plugin initialized");
-  const {
-    getActivePeers,
-    isServerShuttingDown,
-    setShuttingDown,
-    clearAllPeers,
-    getActivePeerCount
-  } = usePeerManager();
-  const originalUnhandledRejection = process.listeners("unhandledRejection");
-  nitroApp.hooks.hook("close", async () => {
-    setShuttingDown(true);
-    const peerCount = getActivePeerCount();
-    if (peerCount === 0) {
-      logger.info("[ws-lifecycle] No active WebSocket connections to close");
-      return;
-    }
-    logger.info(`[ws-lifecycle] Closing ${peerCount} active WebSocket connections...`);
-    const closePromises = [];
-    const peers = getActivePeers();
-    for (const peer of peers) {
-      closePromises.push(
-        new Promise((resolve) => {
-          try {
-            peer.send(JSON.stringify({
-              type: "server-restart",
-              message: "Server is restarting (HMR)"
-            }));
-            setTimeout(() => {
-              try {
-                peer.close(1001, "Server restarting");
-              } catch {
-              }
-              resolve();
-            }, 200);
-          } catch {
-            try {
-              peer.close(1001, "Server restarting");
-            } catch {
-            }
-            resolve();
-          }
-        })
-      );
-    }
-    await Promise.all(closePromises);
-    clearAllPeers();
-    logger.info("[ws-lifecycle] All WebSocket connections closed");
-    setTimeout(() => {
-      setShuttingDown(false);
-    }, 500);
-  });
-  process.on("unhandledRejection", (reason) => {
-    if (isServerShuttingDown() && reason?.code === "ECONNRESET") {
-      return;
-    }
-    for (const handler of originalUnhandledRejection) {
-      if (typeof handler === "function") {
-        handler(reason, Promise.reject(reason));
-      }
-    }
-  });
-});

package/dist/runtime/nitro/plugins/02.workers.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/nitro/plugins/02.workers.js

@@ -1,92 +0,0 @@
-import { defineNitroPlugin, $useWorkerHandlers, $useFunctionRegistry, useQueueAdapter, useHookRegistry } from "#imports";
-import { createJobProcessor } from "../../worker/node/runner.js";
-import { registerSystemHandlersOnQueue } from "../../worker/system/index.js";
-export default defineNitroPlugin(async (nitroApp) => {
-  nitroApp.hooks.hook("close", async () => {
-    const queueAdapter = useQueueAdapter();
-    await queueAdapter.close();
-  });
-  nitroApp.hooks.hook("nvent:adapters:ready", async () => {
-    const queueAdapter = useQueueAdapter();
-    try {
-      const handlers = $useWorkerHandlers();
-      const registry = $useFunctionRegistry() || { workers: [] };
-      const registeredQueues = /* @__PURE__ */ new Set();
-      const queuesWithHooks = /* @__PURE__ */ new Set();
-      for (const entry of handlers) {
-        const { queue, id, handler, module } = entry;
-        const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
-        let jobName;
-        if (w?.flow?.step) {
-          jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
-        } else {
-          jobName = id.includes("/") ? id.split("/").pop() : id;
-        }
-        if (module) {
-          const hooks = {};
-          if (typeof module.onAwaitRegister === "function") {
-            hooks.onAwaitRegister = module.onAwaitRegister;
-          }
-          if (typeof module.onAwaitResolve === "function") {
-            hooks.onAwaitResolve = module.onAwaitResolve;
-          }
-          if (typeof module.onAwaitTimeout === "function") {
-            hooks.onAwaitTimeout = module.onAwaitTimeout;
-          }
-          if (Object.keys(hooks).length > 0 && w?.flow) {
-            const hookRegistry = useHookRegistry();
-            const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
-            for (const flowName of flowNames) {
-              if (flowName) {
-                hookRegistry.register(flowName, jobName, hooks);
-              }
-            }
-            queuesWithHooks.add(queue);
-          }
-          if (w?.flow?.awaitBefore || w?.flow?.awaitAfter) {
-            queuesWithHooks.add(queue);
-          }
-          if (w?.flow?.role === "entry") {
-            const flowNames = w.flow.names ? Array.isArray(w.flow.names) ? w.flow.names : [w.flow.names] : w.flow.name ? Array.isArray(w.flow.name) ? w.flow.name : [w.flow.name] : [];
-            for (const flowName of flowNames) {
-              const flowRegistry = (registry?.flows || {})[flowName];
-              if (flowRegistry?.entry?.awaitBefore || flowRegistry?.entry?.awaitAfter) {
-                queuesWithHooks.add(queue);
-                break;
-              }
-            }
-          }
-        }
-        if (typeof handler === "function") {
-          const workerCfg = w && w.worker || {};
-          const queueCfg = w && w.queue || {};
-          const opts = {};
-          if (typeof workerCfg.concurrency === "number") opts.concurrency = workerCfg.concurrency;
-          if (typeof workerCfg.autorun === "boolean") opts.autorun = workerCfg.autorun;
-          if (queueCfg.defaultJobOptions) opts.defaultJobOptions = queueCfg.defaultJobOptions;
-          if (queueCfg.prefix) opts.prefix = queueCfg.prefix;
-          if (queueCfg.limiter) opts.limiter = queueCfg.limiter;
-          const processor = createJobProcessor(handler, queue);
-          queueAdapter.registerWorker(queue, jobName, processor, opts);
-          registeredQueues.add(queue);
-        }
-      }
-      for (const queueName of queuesWithHooks) {
-        try {
-          const queueWorker = registry.workers.find((w) => w?.queue?.name === queueName);
-          const concurrency = queueWorker?.worker?.concurrency;
-          registerSystemHandlersOnQueue(queueName, concurrency);
-          registeredQueues.add(queueName);
-        } catch (err) {
-          console.error(`[nvent] Failed to register system handlers on queue ${queueName}:`, err);
-        }
-      }
-      if (queueAdapter.startProcessingQueue) {
-        for (const queueName of Array.from(registeredQueues)) {
-          queueAdapter.startProcessingQueue(queueName);
-        }
-      }
-    } catch {
-    }
-  });
-});

package/dist/runtime/nitro/plugins/03.triggers.d.ts

@@ -1,12 +0,0 @@
-/**
- * Trigger Registration Plugin
- *
- * Loads pre-analyzed triggers and subscriptions from build-time registry
- * and registers them via event bus (trigger.registered events).
- * The trigger wiring will handle the actual registration logic.
- *
- * This plugin is ONLY for registering dev/build-time discovered triggers.
- * Trigger wiring and event handling is done in the wiring registry.
- */
-declare const _default: any;
-export default _default;