nvent 0.4.0 → 0.4.2

package/dist/module.mjs

@@ -837,8 +837,10 @@ const module = defineNuxtModule({
     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.ts"),
+        src: resolve("./runtime/app/plugins/vueflow.client"),
         mode: "client"
       });
       addComponentsDir({
@@ -917,19 +919,62 @@ const module = defineNuxtModule({
       write: true,
       getContents: () => generateAnalyzedFlowsTemplate(lastCompiledRegistry)
     });
-    addServerImports([{
-      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")
-    }]);
+    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")
+      }
+    ]);
     const refreshRegistry = async (reason, changedPath) => {
       const queuesRel = config.dir || "queues";
       const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, queuesRel, defaultConfigs);

package/dist/runtime/app/assets/vueflow.css

@@ -0,0 +1 @@
+@import "@vue-flow/core/dist/style.css";@import "@vue-flow/core/dist/theme-default.css";@import "@vue-flow/controls/dist/style.css";@import "@vue-flow/minimap/dist/style.css";

package/dist/runtime/app/plugins/vueflow.client.d.ts

@@ -1,6 +1,2 @@
-import '@vue-flow/core/dist/style.css';
-import '@vue-flow/core/dist/theme-default.css';
-import '@vue-flow/controls/dist/style.css';
-import '@vue-flow/minimap/dist/style.css';
 declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/app/plugins/vueflow.client.js

@@ -3,10 +3,6 @@ import { VueFlow } from "@vue-flow/core";
 import { Controls } from "@vue-flow/controls";
 import { MiniMap } from "@vue-flow/minimap";
 import { Background } from "@vue-flow/background";
-import "@vue-flow/core/dist/style.css";
-import "@vue-flow/core/dist/theme-default.css";
-import "@vue-flow/controls/dist/style.css";
-import "@vue-flow/minimap/dist/style.css";
 export default defineNuxtPlugin((nuxtApp) => {
   nuxtApp.vueApp.component("VueFlow", VueFlow);
   nuxtApp.vueApp.component("Controls", Controls);

package/dist/runtime/server/api/_flows/[name]/runs.get.js

@@ -1,6 +1,6 @@
-import { defineEventHandler, getRouterParam, getQuery, useEventStore, useServerLogger } from "#imports";
-const logger = useServerLogger("api-flows-runs");
+import { defineEventHandler, getRouterParam, getQuery, useEventStore, useNventLogger } from "#imports";
 export default defineEventHandler(async (event) => {
+  const logger = useNventLogger("api-flows-runs");
   const flowName = getRouterParam(event, "name");
   const query = getQuery(event);
   const limit = Math.min(Number.parseInt(query.limit) || 50, 100);

package/dist/runtime/server/api/_flows/ws.js

@@ -1,11 +1,9 @@
 import {
   defineWebSocketHandler,
   useEventStore,
-  registerWsPeer,
-  unregisterWsPeer,
-  useServerLogger
+  usePeerManager,
+  useNventLogger
 } from "#imports";
-const logger = useServerLogger("api-flows-ws");
 const peerContexts = /* @__PURE__ */ new WeakMap();
 function safeSend(peer, data) {
   try {
@@ -17,7 +15,9 @@ function safeSend(peer, data) {
 }
 export default defineWebSocketHandler({
   open(peer) {
+    const logger = useNventLogger("api-flows-ws");
     logger.info("[ws] client connected:", { peerId: peer.id });
+    const { registerWsPeer } = usePeerManager();
     registerWsPeer(peer);
     peerContexts.set(peer, {
       subscriptions: /* @__PURE__ */ new Map()
@@ -28,6 +28,7 @@ export default defineWebSocketHandler({
     });
   },
   async message(peer, message) {
+    const logger = useNventLogger("api-flows-ws");
     const context = peerContexts.get(peer);
     if (!context) {
       logger.error("[ws] no context for peer:", { peerId: peer.id });
@@ -144,10 +145,12 @@ export default defineWebSocketHandler({
     }
   },
   close(peer, event) {
+    const logger = useNventLogger("api-flows-ws");
     const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
     if (!isNormalClosure) {
       logger.info("[ws] client disconnected:", { peerId: peer.id, code: event?.code, reason: event?.reason });
     }
+    const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
@@ -165,7 +168,9 @@ export default defineWebSocketHandler({
     }
   },
   error(peer, error) {
+    const logger = useNventLogger("api-flows-ws");
     logger.error("[ws] error for peer:", { peerId: peer.id, error });
+    const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {

package/dist/runtime/server/api/_queues/index.get.js

@@ -1,7 +1,7 @@
-import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
-const logger = useServerLogger("api-queues-index");
+import { defineEventHandler, useRuntimeConfig, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export default defineEventHandler(async () => {
   const rc = useRuntimeConfig();
+  const logger = useNventLogger("api-queues-index");
   const cfgQueues = rc?.queue?.queues || {};
   const registry = $useQueueRegistry();
   const queue = useQueue();

package/dist/runtime/server/api/_queues/ws.js

@@ -1,12 +1,10 @@
 import {
   defineWebSocketHandler,
   useQueue,
-  registerWsPeer,
-  unregisterWsPeer,
-  useServerLogger
+  usePeerManager,
+  useNventLogger
 } from "#imports";
 const peerContexts = /* @__PURE__ */ new WeakMap();
-const logger = useServerLogger("api-queues-ws");
 function safeSend(peer, data) {
   try {
     peer.send(JSON.stringify(data));
@@ -17,7 +15,9 @@ function safeSend(peer, data) {
 }
 export default defineWebSocketHandler({
   open(peer) {
+    const logger = useNventLogger("api-queues-ws");
     logger.info("[ws:queues] client connected:", peer.id);
+    const { registerWsPeer } = usePeerManager();
     registerWsPeer(peer);
     peerContexts.set(peer, {
       subscriptions: /* @__PURE__ */ new Map()
@@ -28,6 +28,7 @@ export default defineWebSocketHandler({
     });
   },
   async message(peer, message) {
+    const logger = useNventLogger("api-queues-ws");
     const context = peerContexts.get(peer);
     if (!context) {
       logger.error("[ws:queues] no context for peer:", peer.id);
@@ -154,6 +155,7 @@ export default defineWebSocketHandler({
     }
   },
   close(peer, event) {
+    const logger = useNventLogger("api-queues-ws");
     const isNormalClosure = event?.code === 1e3 || event?.code === 1001;
     if (!isNormalClosure) {
       logger.info("[ws:queues] client disconnected:", {
@@ -162,6 +164,7 @@ export default defineWebSocketHandler({
         reason: event?.reason
       });
     }
+    const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {
@@ -179,10 +182,12 @@ export default defineWebSocketHandler({
     }
   },
   error(peer, error) {
+    const logger = useNventLogger("api-queues-ws");
     logger.error("[ws:queues] error for peer:", {
       peerId: peer.id,
       error
     });
+    const { unregisterWsPeer } = usePeerManager();
     unregisterWsPeer(peer);
     const context = peerContexts.get(peer);
     if (context) {

package/dist/runtime/server/plugins/00.event-store.js

@@ -1,5 +1,5 @@
 import { defineNitroPlugin } from "#imports";
-import { getEventStoreFactory } from "../events/eventStoreFactory.js";
+import { getEventStoreFactory } from "../../server-utils/events/eventStoreFactory.js";
 export default defineNitroPlugin(() => {
   const factory = getEventStoreFactory();
   factory.start();

package/dist/runtime/server/plugins/00.ws-lifecycle.js

@@ -1,15 +1,18 @@
 import {
   defineNitroPlugin,
-  getActivePeerCount,
-  getActivePeers,
-  setShuttingDown,
-  clearAllPeers,
-  isServerShuttingDown,
-  useServerLogger
+  useNventLogger,
+  usePeerManager
 } from "#imports";
-const logger = useServerLogger("plugin-ws-lifecycle");
 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);

package/dist/runtime/server/plugins/flow-management.js

@@ -1,6 +1,6 @@
-import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
-const logger = useServerLogger("plugin-flow-management");
+import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export default defineNitroPlugin((nitro) => {
+  const logger = useNventLogger("plugin-flow-management");
   const { onType, publishBus } = useEventManager();
   const registry = $useQueueRegistry();
   const flowIdToName = /* @__PURE__ */ new Map();

package/dist/runtime/server/plugins/queue-management.js

@@ -1,8 +1,8 @@
-import { defineNitroPlugin, useServerLogger } from "#imports";
-import { BullMQProvider } from "../queue/adapters/bullmq.js";
-import { setQueueProvider, getQueueProvider } from "../queue/queueFactory.js";
-const logger = useServerLogger("plugin-queue-management");
+import { defineNitroPlugin, useNventLogger } from "#imports";
+import { BullMQProvider } from "../../server-utils/queue/adapters/bullmq.js";
+import { setQueueProvider, getQueueProvider } from "../../server-utils/queue/queueFactory.js";
 export default defineNitroPlugin(async (nitroApp) => {
+  const logger = useNventLogger("plugin-queue-management");
   try {
     const existingProvider = getQueueProvider();
     if (existingProvider) {

package/dist/runtime/server/plugins/state-cleanup.js

@@ -1,7 +1,7 @@
-import { useServerLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
-import { getStateProvider } from "../state/stateFactory.js";
-const logger = useServerLogger("plugin-state-cleanup");
+import { useNventLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
+import { getStateProvider } from "../../server-utils/state/stateFactory.js";
 export default defineNitroPlugin(() => {
+  const logger = useNventLogger("plugin-state-cleanup");
   const rc = useRuntimeConfig();
   const cleanup = rc?.queue?.state?.cleanup || { strategy: "never" };
   if (cleanup.strategy === "never" || cleanup.strategy === "ttl") {

package/dist/runtime/server/plugins/worker-management.js

@@ -1,5 +1,5 @@
 import { defineNitroPlugin, $useWorkerHandlers, $useQueueRegistry } from "#imports";
-import { registerTsWorker, closeAllWorkers } from "../worker/adapter.js";
+import { registerTsWorker, closeAllWorkers } from "../../server-utils/worker/adapter.js";
 export default defineNitroPlugin(async (nitroApp) => {
   nitroApp.hooks.hook("close", async () => {
     await closeAllWorkers();

package/dist/runtime/{server → server-utils}/events/adapters/redis/redisAdapter.js

@@ -1,12 +1,12 @@
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 import IORedis from "ioredis";
 import { RedisPubSubGateway } from "./redisPubSubGateway.js";
-const logger = useServerLogger("redis-adapter");
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 export function createRedisAdapter() {
   const rc = useRuntimeConfig();
+  const logger = useNventLogger("redis-adapter");
   const conn = rc?.queue?.eventStore?.redis || {};
   const rsOpts = rc?.queue?.eventStore?.options?.redisStreams || {};
   const redis = new IORedis({

package/dist/runtime/{server → server-utils}/events/adapters/redis/redisPubSubGateway.d.ts

@@ -7,6 +7,7 @@ export declare class RedisPubSubGateway {
     private subscriber;
     private channelSubscribers;
     private initialized;
+    private logger;
     constructor(subscriber: IORedis);
     private initialize;
     /**

package/dist/runtime/{server → server-utils}/events/adapters/redis/redisPubSubGateway.js

@@ -1,11 +1,11 @@
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("redis-adapter");
+import { useNventLogger } from "#imports";
 export class RedisPubSubGateway {
   constructor(subscriber) {
     this.subscriber = subscriber;
   }
   channelSubscribers = /* @__PURE__ */ new Map();
   initialized = false;
+  logger = useNventLogger("redis-pubsub-gateway");
   initialize() {
     if (this.initialized) return;
     this.initialized = true;
@@ -17,7 +17,7 @@ export class RedisPubSubGateway {
           handler(messageId);
         } catch (err) {
           if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.error("[redis-pubsub-gateway] Handler error:", err);
+            this.logger.error("[redis-pubsub-gateway] Handler error:", err);
           }
         }
       }
@@ -33,7 +33,7 @@ export class RedisPubSubGateway {
       this.channelSubscribers.set(channel, /* @__PURE__ */ new Set());
       await this.subscriber.subscribe(channel);
       if (process.env.NQ_DEBUG_EVENTS === "1") {
-        logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
+        this.logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
       }
     }
     this.channelSubscribers.get(channel).add(handler);
@@ -46,7 +46,7 @@ export class RedisPubSubGateway {
           this.subscriber.unsubscribe(channel).catch(() => {
           });
           if (process.env.NQ_DEBUG_EVENTS === "1") {
-            logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
+            this.logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
           }
         }
       }

package/dist/runtime/{server → server-utils}/events/eventBus.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events';
-import type { EventRecord } from '../../types.js';
+import type { EventRecord } from '../types.js';
 type Handler = (e: EventRecord) => void;
 declare global {
     var __nq_bus_emitter: EventEmitter | undefined;

package/dist/runtime/{server → server-utils}/events/eventStoreFactory.js

@@ -1,13 +1,13 @@
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 import { getStreamNames } from "./streamNames.js";
 import { createRedisAdapter } from "./adapters/redis/redisAdapter.js";
 import { createMemoryAdapter } from "./adapters/memoryAdapter.js";
 import { createFileAdapter } from "./adapters/fileAdapter.js";
 import { createWiringRegistry } from "./wiring/registry.js";
-const logger = useServerLogger("event-store-factory");
 let cachedFactory = null;
 export function getEventStoreFactory() {
   if (cachedFactory) return cachedFactory;
+  const logger = useNventLogger("event-store-factory");
   const rc = useRuntimeConfig();
   const adapter = rc?.queue?.eventStore?.adapter || "memory";
   let adapterInstance;

package/dist/runtime/{server → server-utils}/events/types.d.ts

@@ -1,4 +1,4 @@
-import type { EventRecord } from '../../types.js';
+import type { EventRecord } from '../types.js';
 export interface PublishContext {
     queue?: string;
     jobId?: string;

package/dist/runtime/{server → server-utils}/events/wiring/flowWiring.d.ts

@@ -1,5 +1,5 @@
 import type { EventStoreAdapter } from '../types.js';
-import type { EventRecord } from '../../../types.js';
+import type { EventRecord } from '../../types.js';
 export interface FlowWiringDeps {
     adapter: EventStoreAdapter;
 }

package/dist/runtime/{server → server-utils}/events/wiring/flowWiring.js

@@ -1,6 +1,5 @@
 import { getEventBus } from "../eventBus.js";
-import { useServerLogger, useEventStore, $useAnalyzedFlows, $useQueueRegistry, useQueue } from "#imports";
-const logger = useServerLogger("flow-wiring");
+import { useEventStore, $useAnalyzedFlows, $useQueueRegistry, useQueue, useNventLogger } from "#imports";
 export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   if (!step.subscribes || step.subscribes.length === 0) {
     return true;
@@ -15,6 +14,7 @@ export function checkPendingStepTriggers(step, emittedEvents, completedSteps) {
   });
 }
 async function checkAndTriggerPendingSteps(flowName, runId, store) {
+  const logger = useNventLogger("flow-wiring");
   try {
     const analyzedFlows = $useAnalyzedFlows();
     const registry = $useQueueRegistry();
@@ -177,6 +177,7 @@ export function createFlowWiring(deps) {
   const unsubs = [];
   let wired = false;
   const indexFlowRun = async (flowName, flowId, timestamp, metadata) => {
+    const logger = useNventLogger("flow-wiring");
     try {
       const store = useEventStore();
       const names = store.names();
@@ -190,6 +191,7 @@ export function createFlowWiring(deps) {
   function start() {
     if (wired) return;
     wired = true;
+    const logger = useNventLogger("flow-wiring");
     const store = useEventStore();
     const names = store.names();
     const handlePersistence = async (e) => {
@@ -393,6 +395,7 @@ export function createFlowWiring(deps) {
     }
   }
   function stop() {
+    const logger = useNventLogger("flow-wiring");
     for (const u of unsubs.splice(0)) {
       try {
         u();

package/dist/runtime/{server → server-utils}/queue/adapters/bullmq.d.ts

@@ -1,6 +1,7 @@
 import type { QueueProvider, JobInput, Job, JobsQuery, ScheduleOptions, QueueEvent, JobCounts } from '../types.js';
 export declare class BullMQProvider implements QueueProvider {
     private queues;
+    private logger;
     init(): Promise<void>;
     private ensureQueue;
     enqueue(queueName: string, job: JobInput): Promise<string>;

package/dist/runtime/{server → server-utils}/queue/adapters/bullmq.js

@@ -1,9 +1,9 @@
 import { Queue, QueueEvents } from "bullmq";
 import defu from "defu";
-import { useServerLogger, useRuntimeConfig, $useQueueRegistry, useEventManager } from "#imports";
-const logger = useServerLogger("bullmq-adapter");
+import { useRuntimeConfig, $useQueueRegistry, useEventManager, useNventLogger } from "#imports";
 export class BullMQProvider {
   queues = /* @__PURE__ */ new Map();
+  logger = useNventLogger("bullmq-adapter");
   async init() {
   }
   ensureQueue(name) {
@@ -132,14 +132,14 @@ export class BullMQProvider {
       closePromises.push(
         queue.close().catch((err) => {
           if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-            logger.warn("Error closing queue", { queueName, error: err });
+            this.logger.warn("Error closing queue", { queueName, error: err });
           }
         })
       );
       closePromises.push(
         events.close().catch((err) => {
           if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
-            logger.warn("Error closing events for queue", { queueName, error: err });
+            this.logger.warn("Error closing events for queue", { queueName, error: err });
           }
         })
       );

package/dist/runtime/{server → server-utils}/utils/useEventManager.d.ts

@@ -1,5 +1,5 @@
 import { getEventBus } from '../events/eventBus.js';
-import type { EventRecord } from '../../types.js';
+import type { EventRecord } from '../types.js';
 export interface EventManager {
     /**
      * Publish an event directly to the in-proc bus.

package/dist/runtime/{server → server-utils}/utils/useEventManager.js

@@ -1,8 +1,8 @@
 import { getEventBus } from "../events/eventBus.js";
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("event-manager");
+import { useNventLogger } from "#imports";
 export function useEventManager() {
   if (globalThis.__nq_event_manager) return globalThis.__nq_event_manager;
+  const logger = useNventLogger("event-manager");
   const bus = getEventBus();
   const publishBus = async (evt) => {
     const rec = {

package/dist/runtime/{server → server-utils}/utils/useEventStore.d.ts

@@ -1,5 +1,5 @@
 import type { EventReadOptions } from '../events/types.js';
-import type { EventRecord } from '../../types.js';
+import type { EventRecord } from '../types.js';
 export declare function useEventStore(): {
     names: () => import("../events/streamNames.js").StreamNames;
     read: (stream: string, opts?: EventReadOptions) => Promise<EventRecord[]>;

package/dist/runtime/{server → server-utils}/utils/useEventStore.js

@@ -1,7 +1,7 @@
 import { getEventStoreFactory } from "../events/eventStoreFactory.js";
-import { useServerLogger } from "#imports";
-const logger = useServerLogger("event-store");
+import { useNventLogger } from "#imports";
 export function useEventStore() {
+  const logger = useNventLogger("event-store");
   const factory = getEventStoreFactory();
   async function read(stream, opts) {
     return await factory.adapter.read(stream, opts);

package/dist/runtime/{server → server-utils}/utils/useFlowEngine.js

@@ -1,10 +1,10 @@
-import { $useQueueRegistry, useQueue, useEventManager, useServerLogger } from "#imports";
+import { $useQueueRegistry, useQueue, useEventManager, useNventLogger } from "#imports";
 import { randomUUID } from "node:crypto";
-const logger = useServerLogger("flow-engine");
 export const useFlowEngine = () => {
   const registry = $useQueueRegistry();
   const queueAdapter = useQueue();
   const eventsManager = useEventManager();
+  const logger = useNventLogger("flow-engine");
   const startFlow = async (flowName, payload = {}) => {
     const flow = registry?.flows?.[flowName];
     if (!flow || !flow.entry) throw new Error("Flow not found");

package/dist/runtime/{server/utils/useServerLogger.d.ts → server-utils/utils/useNventLogger.d.ts}

@@ -1,6 +1,6 @@
 import { type ConsolaInstance } from 'consola';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface ServerLogger {
+export interface NventLogger {
     debug: (message: string, context?: any) => void;
     info: (message: string, context?: any) => void;
     warn: (message: string, context?: any) => void;
@@ -20,11 +20,11 @@ export interface ServerLogger {
  * - NQ_DEBUG_<SCOPE>: environment variable for scope (e.g., NQ_DEBUG_FLOW_WIRING=1)
  *
  * @param scope - Logger scope/namespace (e.g., 'flow-wiring', 'event-manager')
- * @returns ServerLogger instance with scoped logging methods
+ * @returns NventLogger instance with scoped logging methods
  *
  * @example
  * ```ts
- * const logger = useServerLogger('flow-wiring')
+ * const logger = useNventLogger('flow-wiring')
  * logger.debug('Step triggered', { stepName: 'process', runId: '123' })
  * logger.info('Flow completed', { flowName: 'example' })
  * logger.warn('Retry attempt', { attempt: 3 })
@@ -35,7 +35,7 @@ export interface ServerLogger {
  * logger.consola.box('🚀 Flow Started')
  * ```
  */
-export declare function useServerLogger(scope: string): ServerLogger;
+export declare function useNventLogger(scope: string): NventLogger;
 /**
  * Type guard to check if debug logging is enabled for any scope
  */

package/dist/runtime/{server/utils/useServerLogger.js → server-utils/utils/useNventLogger.js}

@@ -7,7 +7,7 @@ const LOG_LEVELS = {
   error: 3
 };
 const loggerCache = /* @__PURE__ */ new Map();
-export function useServerLogger(scope) {
+export function useNventLogger(scope) {
   const rc = useRuntimeConfig();
   const debugConfig = rc?.queue?.debug;
   const configLevel = debugConfig?.level || process.env.NQ_DEBUG_LEVEL || "info";

package/dist/runtime/server-utils/utils/wsPeerManager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * WebSocket Peer Manager
+ *
+ * Tracks active WebSocket connections for graceful shutdown during HMR.
+ * Auto-imported in Nitro server context.
+ */
+/**
+ * Register a peer to be tracked for graceful shutdown
+ */
+declare function registerWsPeer(peer: any): void;
+/**
+ * Unregister a peer (called when connection closes normally)
+ */
+declare function unregisterWsPeer(peer: any): void;
+/**
+ * Get all currently active WebSocket peers
+ */
+declare function getActivePeers(): any[];
+/**
+ * Check if server is currently shutting down
+ */
+declare function isServerShuttingDown(): boolean;
+/**
+ * Set the shutdown state
+ */
+declare function setShuttingDown(state: boolean): void;
+/**
+ * Clear all tracked peers
+ */
+declare function clearAllPeers(): void;
+/**
+ * Get the count of active peers
+ */
+declare function getActivePeerCount(): number;
+export declare const usePeerManager: () => {
+    registerWsPeer: typeof registerWsPeer;
+    unregisterWsPeer: typeof unregisterWsPeer;
+    getActivePeers: typeof getActivePeers;
+    isServerShuttingDown: typeof isServerShuttingDown;
+    setShuttingDown: typeof setShuttingDown;
+    clearAllPeers: typeof clearAllPeers;
+    getActivePeerCount: typeof getActivePeerCount;
+};
+export {};

package/dist/runtime/server-utils/utils/wsPeerManager.js

@@ -0,0 +1,32 @@
+const activePeers = /* @__PURE__ */ new Set();
+let isShuttingDown = false;
+function registerWsPeer(peer) {
+  activePeers.add(peer);
+}
+function unregisterWsPeer(peer) {
+  activePeers.delete(peer);
+}
+function getActivePeers() {
+  return Array.from(activePeers);
+}
+function isServerShuttingDown() {
+  return isShuttingDown;
+}
+function setShuttingDown(state) {
+  isShuttingDown = state;
+}
+function clearAllPeers() {
+  activePeers.clear();
+}
+function getActivePeerCount() {
+  return activePeers.size;
+}
+export const usePeerManager = () => ({
+  registerWsPeer,
+  unregisterWsPeer,
+  getActivePeers,
+  isServerShuttingDown,
+  setShuttingDown,
+  clearAllPeers,
+  getActivePeerCount
+});

package/dist/runtime/{server → server-utils}/worker/adapter.js

@@ -1,9 +1,9 @@
 import { Worker } from "bullmq";
 import { createBullMQProcessor } from "./runner/node.js";
-import { useRuntimeConfig, useServerLogger } from "#imports";
+import { useRuntimeConfig, useNventLogger } from "#imports";
 const registeredWorkers = /* @__PURE__ */ new Map();
-const logger = useServerLogger("worker-adapter");
 export async function closeAllWorkers() {
+  const logger = useNventLogger("worker-adapter");
   const closePromises = [];
   for (const [queueName, info] of registeredWorkers.entries()) {
     closePromises.push(
@@ -20,6 +20,7 @@ export async function closeAllWorkers() {
 }
 export async function registerTsWorker(queueName, jobName, handler, opts) {
   let info = registeredWorkers.get(queueName);
+  const logger = useNventLogger("worker-adapter");
   if (info) {
     logger.info(`[registerTsWorker] Adding handler for job "${jobName}" to existing worker for queue "${queueName}"`);
     info.handlers.set(jobName, handler);

package/dist/runtime/{server → server-utils}/worker/runner/node.js

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { getStateProvider } from "../../state/stateFactory.js";
-import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useServerLogger } from "#imports";
-const logger = useServerLogger("node-runner");
+import { useRuntimeConfig, useLogs, useFlowEngine, useEventManager, useNventLogger } from "#imports";
 const defaultState = {
   async get() {
     return null;
@@ -37,7 +36,7 @@ export function buildContext(partial) {
       return defaultState;
     }
   })();
-  const logger2 = partial?.logger || (() => {
+  const logger = partial?.logger || (() => {
     const logs = useLogs();
     return {
       log: (level, msg, meta) => {
@@ -66,12 +65,13 @@ export function buildContext(partial) {
     stepName: partial?.stepName,
     stepId: partial?.stepId,
     attempt: partial?.attempt,
-    logger: logger2,
+    logger,
     state,
     flow
   };
 }
 export function createBullMQProcessor(handler, queueName) {
+  const logger = useNventLogger("node-runner");
   return async function processor(job) {
     if (job.data?.__scheduledFlowStart) {
       const { __flowName, __flowInput } = job.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvent",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Nuxt queue service based on Bullmq",
   "repository": "DevJoghurt/nuxt-queue",
   "license": "MIT",

package/dist/runtime/server/utils/wsPeerManager.d.ts

@@ -1,34 +0,0 @@
-/**
- * WebSocket Peer Manager
- *
- * Tracks active WebSocket connections for graceful shutdown during HMR.
- * Auto-imported in Nitro server context.
- */
-/**
- * Register a peer to be tracked for graceful shutdown
- */
-export declare function registerWsPeer(peer: any): void;
-/**
- * Unregister a peer (called when connection closes normally)
- */
-export declare function unregisterWsPeer(peer: any): void;
-/**
- * Get all currently active WebSocket peers
- */
-export declare function getActivePeers(): any[];
-/**
- * Check if server is currently shutting down
- */
-export declare function isServerShuttingDown(): boolean;
-/**
- * Set the shutdown state
- */
-export declare function setShuttingDown(state: boolean): void;
-/**
- * Clear all tracked peers
- */
-export declare function clearAllPeers(): void;
-/**
- * Get the count of active peers
- */
-export declare function getActivePeerCount(): number;

package/dist/runtime/server/utils/wsPeerManager.js

@@ -1,23 +0,0 @@
-const activePeers = /* @__PURE__ */ new Set();
-let isShuttingDown = false;
-export function registerWsPeer(peer) {
-  activePeers.add(peer);
-}
-export function unregisterWsPeer(peer) {
-  activePeers.delete(peer);
-}
-export function getActivePeers() {
-  return Array.from(activePeers);
-}
-export function isServerShuttingDown() {
-  return isShuttingDown;
-}
-export function setShuttingDown(state) {
-  isShuttingDown = state;
-}
-export function clearAllPeers() {
-  activePeers.clear();
-}
-export function getActivePeerCount() {
-  return activePeers.size;
-}