nvent 0.4.0

package/dist/module.mjs

@@ -0,0 +1,974 @@
+import { dirname, join, extname, relative } from 'node:path';
+import { useLogger, defineNuxtModule, createResolver, addServerScanDir, addImportsDir, addPlugin, addComponentsDir, addComponent, addTemplate, addServerImports, updateTemplates } from '@nuxt/kit';
+import defu from 'defu';
+import { existsSync, realpathSync } from 'node:fs';
+import { globby } from 'globby';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { readFile } from 'node:fs/promises';
+import { parseModule } from 'magicast';
+import { spawn } from 'node:child_process';
+import chokidar from 'chokidar';
+import { join as join$1 } from 'pathe';
+import { debounce } from 'perfect-debounce';
+
+async function loadJsConfig(absPath) {
+  const cacheBust = `?t=${Date.now()}`;
+  const mod = await import(pathToFileURL(absPath).href + cacheBust);
+  const cfg = mod?.config;
+  const queueName = cfg && typeof cfg.queue === "object" && cfg.queue ? cfg.queue?.name : void 0;
+  const isolate = cfg?.runner?.ts?.isolate || cfg?.runner?.isolate || cfg?.isolate;
+  const runtype = isolate === "task" ? "task" : isolate === "inprocess" ? "inprocess" : void 0;
+  const flowCfg = cfg?.flow;
+  let flow;
+  if (flowCfg) {
+    const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
+    const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
+    if (names.length) {
+      flow = {
+        names,
+        role: flowCfg.role,
+        step: flowCfg.step,
+        emits: flowCfg.emits,
+        subscribes
+      };
+    }
+  }
+  const queueCfg = cfg?.queue && typeof cfg.queue === "object" ? {
+    name: cfg.queue.name,
+    defaultJobOptions: cfg.queue.defaultJobOptions,
+    prefix: cfg.queue.prefix,
+    limiter: cfg.queue.limiter
+  } : 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 };
+}
+
+async function loadTsConfig(absPath) {
+  try {
+    const source = await readFile(absPath, "utf-8");
+    const mod = parseModule(source);
+    const hasDefaultExport = !!mod.exports.default;
+    const configExport = mod.exports.config;
+    if (!configExport) {
+      return { hasDefaultExport };
+    }
+    const cfg = extractConfigValue(configExport);
+    const queueName = cfg && typeof cfg.queue === "object" && cfg.queue ? cfg.queue?.name : void 0;
+    const isolate = cfg?.runner?.ts?.isolate || cfg?.runner?.isolate || cfg?.isolate;
+    const runtype = isolate === "task" ? "task" : isolate === "inprocess" ? "inprocess" : void 0;
+    const flowCfg = cfg?.flow;
+    let flow;
+    if (flowCfg) {
+      const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
+      const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
+      if (names.length) {
+        flow = {
+          names,
+          role: flowCfg.role,
+          step: flowCfg.step,
+          emits: flowCfg.emits,
+          subscribes
+        };
+      }
+    }
+    const queueCfg = cfg?.queue && typeof cfg.queue === "object" ? {
+      name: cfg.queue.name,
+      defaultJobOptions: cfg.queue.defaultJobOptions,
+      prefix: cfg.queue.prefix,
+      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 };
+  } catch (error) {
+    throw new Error(`Failed to parse config from ${absPath}: ${error}`);
+  }
+}
+function extractConfigValue(value) {
+  if (value && typeof value === "object" && "$ast" in value) {
+    return astToValue(value.$ast);
+  }
+  return value;
+}
+function astToValue(node) {
+  if (!node) return void 0;
+  switch (node.type) {
+    case "CallExpression":
+      if (node.arguments?.length > 0) {
+        return astToValue(node.arguments[0]);
+      }
+      return void 0;
+    case "ObjectExpression":
+      return node.properties?.reduce((obj, prop) => {
+        if (prop.type === "ObjectProperty" || prop.type === "Property") {
+          const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+          obj[key] = astToValue(prop.value);
+        }
+        return obj;
+      }, {}) || {};
+    case "ArrayExpression":
+      return node.elements?.map((el) => astToValue(el)) || [];
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value;
+    case "Identifier":
+      return void 0;
+    case "TemplateLiteral":
+      if (node.expressions?.length === 0 && node.quasis?.length === 1) {
+        return node.quasis[0].value.cooked;
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+
+async function loadPyConfig(absPath, logger) {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const helper = join(moduleDir, "..", "..", "runtime", "python", "get_config.py");
+  let pyConfig;
+  if (existsSync(helper)) {
+    pyConfig = await new Promise((resolve) => {
+      try {
+        const child = spawn("python3", [helper, absPath], {
+          stdio: ["ignore", "pipe", "pipe", "pipe"],
+          env: { ...process.env, NODE_CHANNEL_FD: "3" }
+        });
+        let dataBuf = "";
+        const fd = child.stdio[3];
+        const stream = fd || child.stdout;
+        stream.setEncoding("utf-8");
+        stream.on("data", (chunk) => {
+          dataBuf += chunk;
+        });
+        child.on("error", () => resolve(void 0));
+        child.on("close", () => {
+          const line = dataBuf.split("\n").find((l) => l.trim().length > 0);
+          if (!line) return resolve(void 0);
+          try {
+            resolve(JSON.parse(line));
+          } catch {
+            resolve(void 0);
+          }
+        });
+      } catch {
+        resolve(void 0);
+      }
+    });
+  } else {
+    logger?.warn?.("Python helper not found, skipping config extraction:", helper);
+  }
+  let queueName;
+  let flow;
+  if (pyConfig) {
+    queueName = pyConfig?.queue && typeof pyConfig.queue === "object" ? pyConfig.queue?.name : void 0;
+    const flowCfg = pyConfig?.flow;
+    if (flowCfg && typeof flowCfg === "object") {
+      const subscribes = Array.isArray(flowCfg.subscribes) ? flowCfg.subscribes : typeof flowCfg.subscribes === "string" ? [flowCfg.subscribes] : void 0;
+      const names = Array.isArray(flowCfg.name) ? flowCfg.name.filter((s) => typeof s === "string" && s.length > 0) : typeof flowCfg.name === "string" && flowCfg.name.length > 0 ? [flowCfg.name] : [];
+      if (names.length) {
+        flow = {
+          names,
+          role: flowCfg.role,
+          step: flowCfg.step,
+          emits: flowCfg.emits,
+          subscribes
+        };
+      }
+    }
+  }
+  return { queueName, flow, hasDefaultExport: true };
+}
+
+async function scanWorkers(layers, queuesDir = "queues") {
+  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);
+    if (!existsSync(base)) continue;
+    const files = await globby("**/*.{ts,js,mjs,cjs,mts,cts,py}", { cwd: base, dot: false });
+    for (const rel of files) {
+      const abs = join(base, rel);
+      try {
+        let key = abs;
+        try {
+          key = realpathSync(abs);
+        } catch {
+        }
+        key = key.replace(/\\/g, "/");
+        if (seenFiles.has(key)) continue;
+        seenFiles.add(key);
+        const ext = extname(abs).toLowerCase();
+        const id = rel.replace(/\.[^.]+$/, "");
+        let queueName;
+        let flow;
+        if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+          const meta = await loadJsConfig(abs);
+          flow = meta.flow;
+          const hasDefaultExport = !!meta.hasDefaultExport;
+          if (hasDefaultExport) {
+            const kind = "ts";
+            const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
+            queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
+            workerByVirtualPath.set(virtualPath, {
+              id,
+              kind,
+              filePath: virtualPath,
+              absPath: abs,
+              exportName: "default",
+              queue: {
+                name: queueName,
+                defaultJobOptions: meta.queue?.defaultJobOptions,
+                prefix: meta.queue?.prefix,
+                limiter: meta.queue?.limiter
+              },
+              worker: meta.worker,
+              flow,
+              runtype: meta.runtype
+            });
+          }
+        } else if (ext === ".py") {
+          const meta = await loadPyConfig(abs, logger);
+          flow = meta.flow;
+          const kind = "py";
+          const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
+          queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
+          workerByVirtualPath.set(virtualPath, {
+            id,
+            kind,
+            filePath: virtualPath,
+            absPath: abs,
+            exportName: "default",
+            queue: {
+              name: queueName,
+              defaultJobOptions: meta.queue?.defaultJobOptions,
+              prefix: meta.queue?.prefix,
+              limiter: meta.queue?.limiter
+            },
+            flow
+          });
+        } else {
+          try {
+            const meta = await loadTsConfig(abs);
+            flow = meta.flow;
+            const hasDefaultExport = !!meta.hasDefaultExport;
+            if (hasDefaultExport) {
+              const kind = "ts";
+              const virtualPath = relative(layer.serverDir, abs).replace(/\\/g, "/");
+              queueName = String(meta.queue?.name || meta.queueName || (id.split("/").pop() || id));
+              workerByVirtualPath.set(virtualPath, {
+                id,
+                kind,
+                filePath: virtualPath,
+                absPath: abs,
+                exportName: "default",
+                queue: {
+                  name: queueName,
+                  defaultJobOptions: meta.queue?.defaultJobOptions,
+                  prefix: meta.queue?.prefix,
+                  limiter: meta.queue?.limiter
+                },
+                worker: meta.worker,
+                flow,
+                runtype: meta.runtype
+              });
+            }
+          } catch (err) {
+            logger.warn("Failed to load TS worker (jiti):", rel, err);
+          }
+        }
+        if (!queueName) {
+          queueName = id.split("/").pop() || id;
+        }
+        if (flow) {
+          flowSources.push({ flow, queue: String(queueName), id });
+        }
+      } catch (e) {
+        logger.warn("Failed to load worker file:", rel, e);
+      }
+    }
+  }
+  const workers = Array.from(workerByVirtualPath.values());
+  return { workers, flowSources };
+}
+
+function buildFlows(flowSources) {
+  const flows = {};
+  const eventIndex = {};
+  const seenFlowKeys = /* @__PURE__ */ new Set();
+  for (const src of flowSources) {
+    const { flow: f, queue, id } = src;
+    if (!f?.names?.length || !f.step) continue;
+    const rawSteps = Array.isArray(f.step) ? f.step : [f.step];
+    const steps = rawSteps.filter((s) => typeof s === "string" && s.length > 0);
+    if (steps.length === 0) continue;
+    for (const flowId of f.names) {
+      if (!flows[flowId]) flows[flowId] = { steps: {} };
+      const bucket = flows[flowId] = flows[flowId] || { steps: {} };
+      if (f.role === "entry") {
+        const mainStep = steps[0];
+        const key = `${flowId}:${f.role}:${mainStep}`;
+        if (!seenFlowKeys.has(key)) {
+          seenFlowKeys.add(key);
+          bucket.entry = { step: mainStep, queue, workerId: id };
+        }
+        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 };
+        }
+      } 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 };
+        }
+      }
+      if (f.subscribes) {
+        for (const kind of f.subscribes) {
+          if (!eventIndex[kind]) eventIndex[kind] = [];
+          for (const s of steps) {
+            eventIndex[kind].push({ flowId, step: s, queue, workerId: id });
+          }
+        }
+      }
+    }
+  }
+  return { flows, eventIndex };
+}
+
+function mergeWorkerConfig(worker, defaults) {
+  const merged = { ...worker };
+  if (defaults.queue || worker.queue) {
+    merged.queue = defu(
+      worker.queue || {},
+      defaults.queue || {}
+    );
+  }
+  if (defaults.worker || worker.worker) {
+    merged.worker = defu(
+      worker.worker || {},
+      defaults.worker || {}
+    );
+  }
+  return merged;
+}
+function mergeAllWorkerConfigs(workers, defaults) {
+  return workers.map((worker) => mergeWorkerConfig(worker, defaults));
+}
+
+function parseSubscription(token) {
+  const [prefix, ...rest] = token.split(":");
+  if (rest.length > 0) {
+    const type = prefix;
+    return { type, value: rest.join(":") };
+  }
+  return { type: "implicit", value: token };
+}
+function findEmitter(token, entryStep, steps) {
+  const { type, value } = parseSubscription(token);
+  if (entryStep) {
+    const entryEmits = steps[entryStep]?.emits || [];
+    if (entryEmits.includes(token) || entryEmits.includes(value)) {
+      return entryStep;
+    }
+  }
+  for (const [stepName, step] of Object.entries(steps)) {
+    const emits = step.emits || [];
+    if (emits.includes(token)) {
+      return stepName;
+    }
+    switch (type) {
+      case "step":
+        if (stepName === value) return stepName;
+        break;
+      case "queue":
+        if (step.queue === value) return stepName;
+        break;
+      case "worker":
+        if (step.workerId === value) return stepName;
+        break;
+      case "implicit":
+        if (stepName === value || step.queue === value || emits.includes(value)) {
+          return stepName;
+        }
+        break;
+    }
+  }
+  return null;
+}
+function buildDependencyGraph(entryStep, steps) {
+  const dependencies = {};
+  for (const [stepName, step] of Object.entries(steps)) {
+    const deps = /* @__PURE__ */ new Set();
+    const subscribes = step.subscribes || [];
+    for (const token of subscribes) {
+      const emitter = findEmitter(token, entryStep, steps);
+      if (emitter && emitter !== stepName) {
+        deps.add(emitter);
+      }
+    }
+    dependencies[stepName] = Array.from(deps);
+  }
+  return dependencies;
+}
+function calculateLevels(entryStep, dependencies) {
+  const levels = {};
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(stepName) {
+    if (visited.has(stepName)) {
+      return levels[stepName] ?? 0;
+    }
+    if (visiting.has(stepName)) {
+      console.warn(`Circular dependency detected involving step: ${stepName}`);
+      return 0;
+    }
+    visiting.add(stepName);
+    const deps = dependencies[stepName] || [];
+    let maxDepLevel = -1;
+    if (stepName === entryStep) {
+      maxDepLevel = -1;
+    } else if (deps.length === 0 && entryStep) {
+      maxDepLevel = 0;
+    } else {
+      for (const dep of deps) {
+        const depLevel = visit(dep);
+        maxDepLevel = Math.max(maxDepLevel, depLevel);
+      }
+    }
+    levels[stepName] = maxDepLevel + 1;
+    visiting.delete(stepName);
+    visited.add(stepName);
+    return levels[stepName];
+  }
+  const allSteps = Object.keys(dependencies);
+  for (const step of allSteps) {
+    visit(step);
+  }
+  return levels;
+}
+function findTriggeredSteps(stepName, step, allSteps) {
+  const emits = step.emits || [];
+  const triggered = /* @__PURE__ */ new Set();
+  for (const [targetName, targetStep] of Object.entries(allSteps)) {
+    if (targetName === stepName) continue;
+    const subscribes = targetStep.subscribes || [];
+    for (const token of subscribes) {
+      const { type, value } = parseSubscription(token);
+      let matches = false;
+      switch (type) {
+        case "step":
+          matches = stepName === value;
+          break;
+        case "queue":
+          matches = step.queue === value;
+          break;
+        case "worker":
+          matches = step.workerId === value;
+          break;
+        case "implicit":
+          matches = stepName === value || step.queue === value || emits.includes(value);
+          break;
+      }
+      if (matches || emits.includes(token)) {
+        triggered.add(targetName);
+      }
+    }
+  }
+  return Array.from(triggered);
+}
+function analyzeFlow(flow) {
+  const entryStepName = flow.entry?.step;
+  const steps = flow.steps || {};
+  const dependencies = buildDependencyGraph(entryStepName, steps);
+  const levels = calculateLevels(entryStepName, dependencies);
+  const analyzedSteps = {};
+  for (const [stepName, step] of Object.entries(steps)) {
+    analyzedSteps[stepName] = {
+      ...step,
+      name: stepName,
+      dependsOn: dependencies[stepName] || [],
+      triggers: findTriggeredSteps(stepName, step, steps),
+      level: levels[stepName] ?? 1
+    };
+  }
+  const maxLevel = Math.max(0, ...Object.values(levels));
+  const levelGroups = Array.from({ length: maxLevel + 1 }, () => []);
+  for (const [stepName, level] of Object.entries(levels)) {
+    const levelArray = levelGroups[level];
+    if (levelArray) {
+      levelArray.push(stepName);
+    }
+  }
+  return {
+    id: flow.id,
+    entry: flow.entry,
+    steps: analyzedSteps,
+    levels: levelGroups,
+    maxLevel
+  };
+}
+
+async function compileRegistryFromServerWorkers(layers, queuesDir = "queues", defaults) {
+  const { workers, flowSources } = await scanWorkers(layers, queuesDir);
+  const mergedWorkers = defaults ? mergeAllWorkerConfigs(workers, defaults) : workers;
+  const { flows, eventIndex } = buildFlows(flowSources);
+  const compiled = {
+    workers: mergedWorkers,
+    flows,
+    eventIndex
+  };
+  return compiled;
+}
+
+const logger = useLogger("nuxt-queue");
+function watchQueueFiles(options) {
+  const { nuxt, layerInfos, queuesDir, onRefresh } = options;
+  const dirsToWatch = layerInfos.map((layer) => {
+    const serverDir = layer.serverDir || join$1(layer.rootDir, "server");
+    return join$1(serverDir, queuesDir);
+  }).filter(Boolean);
+  if (dirsToWatch.length === 0) {
+    logger.warn("No queue directories found to watch");
+    return;
+  }
+  logger.info("Watching queue directories:", dirsToWatch);
+  const watcher = chokidar.watch(dirsToWatch, {
+    ignoreInitial: true,
+    persistent: true,
+    ignorePermissionErrors: true,
+    ignored: [
+      "**/node_modules/**",
+      "**/__pycache__/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/.nuxt/**"
+    ],
+    // Watch only specific file types
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 100
+    }
+  });
+  logger.info("Chokidar watcher initialized");
+  logger.info("Watched patterns:", dirsToWatch.map((dir) => `${dir}/**/*.{ts,js,py}`));
+  watcher.on("ready", () => {
+    const watched = watcher.getWatched();
+    const fileCount = Object.values(watched).reduce((sum, files) => sum + files.length, 0);
+    logger.success(`Queue file watcher ready - watching ${fileCount} files`);
+  });
+  const debouncedRefresh = debounce(onRefresh, 150);
+  watcher.on("all", (event, path) => {
+    logger.info(`Watcher event: ${event} - ${path}`);
+  });
+  watcher.on("add", async (path) => {
+    logger.info(`Queue file added: ${path}`);
+    await debouncedRefresh("add", path);
+  });
+  watcher.on("change", async (path) => {
+    logger.info(`Queue file changed: ${path}`);
+    await debouncedRefresh("change", path);
+  });
+  watcher.on("unlink", async (path) => {
+    logger.info(`Queue file removed: ${path}`);
+    await debouncedRefresh("unlink", path);
+  });
+  watcher.on("error", (error) => {
+    logger.error("Watcher error:", error);
+  });
+  nuxt.hook("close", () => {
+    logger.info("Closing queue file watcher");
+    watcher.close();
+  });
+  return watcher;
+}
+
+function generateRegistryTemplate(registry) {
+  return `// auto-generated by nuxt-queue
+export const registry = ${JSON.stringify(registry, null, 2)};
+
+export const useQueueRegistry = () => registry;
+
+export default useQueueRegistry;
+`;
+}
+function generateHandlersTemplate(registry) {
+  const regWorkers = registry?.workers || [];
+  const lines = [];
+  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 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}'`);
+    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} }`);
+  });
+  return `// auto-generated by nuxt-queue
+${lines.join("\n")}
+
+export const handlers = [
+  ${entries.join(",\n  ")}
+]
+
+export const useWorkerHandlers = () => handlers;
+
+export default useWorkerHandlers;
+`;
+}
+function generateAnalyzedFlowsTemplate(registry) {
+  const flows = registry?.flows || {};
+  const workers = registry?.workers || [];
+  const workerMetaMap = /* @__PURE__ */ new Map();
+  for (const worker of workers) {
+    workerMetaMap.set(worker.id, {
+      runtime: worker.kind === "py" ? "python" : "nodejs",
+      runtype: worker.runtype,
+      queue: worker.queue,
+      worker: worker.worker,
+      emits: worker.flow?.emits
+    });
+  }
+  const analyzedFlows = Object.entries(flows).map(([id, meta]) => {
+    const workerMeta = meta?.entry ? workerMetaMap.get(meta.entry.workerId) : void 0;
+    const entry = meta?.entry ? {
+      ...meta.entry,
+      runtime: workerMeta?.runtime,
+      runtype: workerMeta?.runtype,
+      emits: workerMeta?.emits
+    } : void 0;
+    const steps = meta?.steps ? Object.fromEntries(
+      Object.entries(meta.steps).map(([stepName, stepData]) => {
+        const stepWorkerMeta = workerMetaMap.get(stepData.workerId);
+        return [
+          stepName,
+          {
+            ...stepData,
+            runtime: stepWorkerMeta?.runtime,
+            runtype: stepWorkerMeta?.runtype,
+            emits: stepWorkerMeta?.emits
+          }
+        ];
+      })
+    ) : {};
+    const flowMeta = {
+      id,
+      entry,
+      steps
+    };
+    const analyzed = analyzeFlow(flowMeta);
+    return {
+      ...flowMeta,
+      analyzed: {
+        levels: analyzed.levels,
+        maxLevel: analyzed.maxLevel,
+        steps: analyzed.steps
+      }
+    };
+  });
+  return `// auto-generated by nuxt-queue
+export const analyzedFlows = ${JSON.stringify(analyzedFlows, null, 2)};
+
+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
+      }
+    };
+  }
+  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
+      }
+    };
+  }
+  return {};
+}
+function toRuntimeConfig(normalizedOptions) {
+  return {
+    debug: normalizedOptions.debug,
+    workers: [],
+    queue: normalizedOptions.queue,
+    state: normalizedOptions.state,
+    eventStore: normalizedOptions.eventStore
+  };
+}
+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
+  };
+}
+
+const meta = {
+  name: "queue",
+  version: "0.1",
+  configKey: "queue"
+};
+const module = defineNuxtModule({
+  meta,
+  defaults: {},
+  moduleDependencies: {
+    "json-editor-vue/nuxt": {
+      version: "0.18.1"
+    }
+  },
+  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) {
+      addPlugin({
+        src: resolve("./runtime/app/plugins/vueflow.client.ts"),
+        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"]
+    });
+    nuxt.hook("nitro:config", (nitro) => {
+      const redisConfig = getRedisStorageConfig(config);
+      nitro.storage = defu(nitro.storage || {}, {
+        redis: {
+          driver: "redis",
+          ...redisConfig
+          // base namespace handled in provider; keep storage base default
+        }
+      });
+      nitro.experimental = defu(nitro.experimental || {}, {
+        websocket: true
+      });
+    });
+    const runtimeConfig = nuxt.options.runtimeConfig;
+    runtimeConfig.queue = defu(runtimeConfig.queue || {}, toRuntimeConfig(config));
+    if (!runtimeConfig.queue) runtimeConfig.queue = {};
+    runtimeConfig.queue.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 defaultConfigs = {
+      queue: queueOptions,
+      worker: config.queue.defaultConfig?.worker
+    };
+    const compiledRegistry = await compileRegistryFromServerWorkers(layerInfos, config.dir || "queues", 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 HANDLERS_TEMPLATE = "worker-handlers.mjs";
+    const ANALYZED_FLOWS_TEMPLATE = "analyzed-flows.mjs";
+    for (const templateName of [REGISTRY_TEMPLATE, HANDLERS_TEMPLATE, ANALYZED_FLOWS_TEMPLATE]) {
+      const templatePath = resolve(nuxt.options.buildDir, templateName);
+      nuxt.options.build.transpile.push(templatePath);
+    }
+    addTemplate({
+      filename: REGISTRY_TEMPLATE,
+      write: true,
+      getContents: () => generateRegistryTemplate(lastCompiledRegistry)
+    });
+    addTemplate({
+      filename: HANDLERS_TEMPLATE,
+      write: true,
+      getContents: () => generateHandlersTemplate(lastCompiledRegistry)
+    });
+    addTemplate({
+      filename: ANALYZED_FLOWS_TEMPLATE,
+      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")
+    }]);
+    const refreshRegistry = async (reason, changedPath) => {
+      const queuesRel = config.dir || "queues";
+      const updatedRegistry = await compileRegistryFromServerWorkers(layerInfos, queuesRel, 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}`);
+      await updateTemplates({
+        filter: (template) => {
+          const match = template.filename === REGISTRY_TEMPLATE || template.filename === HANDLERS_TEMPLATE || template.filename === ANALYZED_FLOWS_TEMPLATE;
+          if (match) {
+            console.log(`[nuxt-queue] updating template: ${template.filename}`);
+          }
+          return match;
+        }
+      });
+      console.log(`[nuxt-queue] templates updated`);
+    };
+    if (nuxt.options.dev) {
+      const queuesRel = config.dir || "queues";
+      watchQueueFiles({
+        nuxt,
+        layerInfos,
+        queuesDir: queuesRel,
+        onRefresh: refreshRegistry
+      });
+    }
+  }
+});
+
+export { module as default };