@immense/vue-pom-generator 1.0.52 → 1.0.54

package/dist/index.cjs

@@ -22,19 +22,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const fs = require("node:fs");
 const path = require("node:path");
 const process = require("node:process");
+const node_module = require("node:module");
 const node_url = require("node:url");
-const fs = require("node:fs");
 const compilerDom = require("@vue/compiler-dom");
 const compilerSfc = require("@vue/compiler-sfc");
 const parser = require("@babel/parser");
 const compilerCore = require("@vue/compiler-core");
 const tsMorph = require("ts-morph");
-const jsdom = require("jsdom");
 const types = require("@babel/types");
 const node_perf_hooks = require("node:perf_hooks");
-const virtualImport = require("vite-plugin-virtual");
 const vue = require("@vitejs/plugin-vue");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
@@ -104,6 +103,133 @@ function createLogger(options) {
     }
   };
 }
+const requireFromModule = node_module.createRequire(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
+function toUniqueResolvedPaths(paths) {
+  return Array.from(new Set(paths.map((value) => path.resolve(value))));
+}
+function resolveNuxtAlias(value, context) {
+  const aliases = [
+    ["~~", context.rootDir],
+    ["@@", context.rootDir],
+    ["~/", `${context.srcDir}${path.sep}`],
+    ["@/", `${context.srcDir}${path.sep}`],
+    ["~", context.srcDir],
+    ["@", context.srcDir]
+  ];
+  for (const [alias, replacement] of Object.entries(context.alias ?? {})) {
+    aliases.push([alias, replacement]);
+  }
+  aliases.sort((a, b) => b[0].length - a[0].length);
+  for (const [alias, replacement] of aliases) {
+    if (value === alias)
+      return replacement;
+    if (value.startsWith(`${alias}/`) || value.startsWith(`${alias}${path.sep}`)) {
+      const suffix = value.slice(alias.length + 1);
+      return path.resolve(replacement, suffix);
+    }
+  }
+  return value;
+}
+function resolveNuxtPath(value, baseDir, context) {
+  const resolvedAlias = resolveNuxtAlias(value, context);
+  return path.isAbsolute(resolvedAlias) ? path.resolve(resolvedAlias) : path.resolve(baseDir, resolvedAlias);
+}
+function normalizeNuxtComponentDirs(value, baseDir, context) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => normalizeNuxtComponentDirs(entry, baseDir, context));
+  }
+  if (value === false) {
+    return [];
+  }
+  if (value === true || value === void 0) {
+    return [
+      path.resolve(baseDir, "components/islands"),
+      path.resolve(baseDir, "components/global"),
+      path.resolve(baseDir, "components")
+    ];
+  }
+  if (typeof value === "string") {
+    return [resolveNuxtPath(value, baseDir, context)];
+  }
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  if (typeof value === "object" && value && "path" in value && typeof value.path === "string") {
+    return [resolveNuxtPath(value.path, baseDir, context)];
+  }
+  if (typeof value !== "object" || !value || !("dirs" in value)) {
+    return [];
+  }
+  return normalizeNuxtComponentDirs(value.dirs, baseDir, context);
+}
+function resolveNuxtProjectDiscovery(nuxtOptions, getLayerDirectories, cwd = process.cwd()) {
+  const rootDir = path.resolve(nuxtOptions.rootDir ?? cwd);
+  const srcDir = path.resolve(nuxtOptions.srcDir ?? rootDir);
+  const fallbackLayer = {
+    cwd: rootDir,
+    config: {
+      rootDir,
+      srcDir,
+      dir: nuxtOptions.dir,
+      components: nuxtOptions.components,
+      alias: nuxtOptions.alias
+    }
+  };
+  const layers = nuxtOptions._layers?.length ? nuxtOptions._layers : [fallbackLayer];
+  const normalizedNuxtOptions = {
+    ...nuxtOptions,
+    _layers: layers
+  };
+  const layerDirectories = getLayerDirectories({ options: normalizedNuxtOptions });
+  const pageDirs = layerDirectories.map((layer) => layer.appPages);
+  const layoutDirs = layerDirectories.map((layer) => layer.appLayouts);
+  const componentDirs = [];
+  for (const [index, layer] of layers.entries()) {
+    const layerDirectory = layerDirectories[index];
+    const layerRootDir = path.resolve(layerDirectory?.root ?? layer.config?.rootDir ?? layer.cwd ?? rootDir);
+    const layerSrcDir = path.resolve(layerDirectory?.app ?? layer.config?.srcDir ?? layer.cwd ?? srcDir);
+    const context = {
+      rootDir: layerRootDir,
+      srcDir: layerSrcDir,
+      alias: {
+        ...nuxtOptions.alias ?? {},
+        ...layer.config?.alias ?? {}
+      }
+    };
+    componentDirs.push(...normalizeNuxtComponentDirs(layer.config?.components, layerSrcDir, context));
+  }
+  const uniquePageDirs = toUniqueResolvedPaths(pageDirs);
+  const uniqueLayoutDirs = toUniqueResolvedPaths(layoutDirs);
+  const uniqueComponentDirs = toUniqueResolvedPaths(componentDirs);
+  return {
+    rootDir,
+    srcDir,
+    pageDirs: uniquePageDirs,
+    layoutDirs: uniqueLayoutDirs,
+    componentDirs: uniqueComponentDirs,
+    wrapperSearchRoots: []
+  };
+}
+async function loadNuxtProjectDiscovery(cwd = process.cwd()) {
+  let loadNuxtConfig;
+  let getLayerDirectories;
+  try {
+    const nuxtKitEntry = requireFromModule.resolve("@nuxt/kit");
+    ({ loadNuxtConfig, getLayerDirectories } = await import(node_url.pathToFileURL(nuxtKitEntry).href));
+  } catch (error) {
+    throw new TypeError(
+      `[vue-pom-generator] Nuxt mode requires @nuxt/kit to be available so Nuxt directories can be resolved from nuxt.config. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (typeof loadNuxtConfig !== "function") {
+    throw new TypeError("[vue-pom-generator] Nuxt mode requires @nuxt/kit.loadNuxtConfig().");
+  }
+  if (typeof getLayerDirectories !== "function") {
+    throw new TypeError("[vue-pom-generator] Nuxt mode requires @nuxt/kit.getLayerDirectories().");
+  }
+  const nuxtOptions = await loadNuxtConfig({ cwd });
+  return resolveNuxtProjectDiscovery(nuxtOptions, getLayerDirectories, cwd);
+}
 function createTypeScriptProject() {
   return new tsMorph.Project({
     useInMemoryFileSystem: true,
@@ -2796,27 +2922,24 @@ function safeRealpath(value) {
   const resolvedParent = safeRealpath(parent);
   return resolvedParent === parent ? value : path.join(resolvedParent, path.basename(value));
 }
+function isPathWithinDir(filePathAbs, dirPathAbs) {
+  const fileAbs = path.resolve(filePathAbs);
+  const dirAbs = path.resolve(dirPathAbs);
+  const rel = path.relative(dirAbs, fileAbs);
+  if (!rel)
+    return true;
+  return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
 function resolveComponentNameFromPath(options) {
-  const { projectRoot, viewsDirAbs, scanDirs, extraRoots = [] } = options;
+  const { projectRoot, viewsDirAbs, sourceDirs, extraRoots = [] } = options;
   const cleanFilename = options.filename.includes("?") ? options.filename.substring(0, options.filename.indexOf("?")) : options.filename;
   const absFilename = path.isAbsolute(cleanFilename) ? cleanFilename : path.resolve(projectRoot, cleanFilename);
   const normalizedAbsFilename = path.normalize(safeRealpath(absFilename));
   const rootBases = [projectRoot, ...extraRoots.filter((r) => r !== projectRoot)];
-  const roots = [viewsDirAbs, ...rootBases.flatMap((base) => scanDirs.map((d) => path.resolve(base, d)))];
-  for (const base of rootBases) {
-    for (const dir of scanDirs) {
-      const absDir = path.resolve(base, dir);
-      try {
-        const pagesDir = path.join(absDir, "pages");
-        if (fs.existsSync(pagesDir))
-          roots.push(pagesDir);
-        const componentsDir = path.join(absDir, "components");
-        if (fs.existsSync(componentsDir))
-          roots.push(componentsDir);
-      } catch {
-      }
-    }
-  }
+  const roots = [
+    viewsDirAbs,
+    ...sourceDirs.flatMap((dir) => path.isAbsolute(dir) ? [dir] : rootBases.map((base) => path.resolve(base, dir)))
+  ];
   const potentialRoots = Array.from(new Set(roots.map((r) => path.normalize(safeRealpath(r))))).sort((a, b) => b.length - a.length);
   for (const root of potentialRoots) {
     if (normalizedAbsFilename.startsWith(root + path.sep) || normalizedAbsFilename === root) {
@@ -3180,30 +3303,260 @@ function resolveIntrospectedComponentName(componentInfo, componentNaming) {
       filename: componentInfo.filePath,
       projectRoot: componentNaming.projectRoot,
       viewsDirAbs: componentNaming.viewsDirAbs,
-      scanDirs: componentNaming.scanDirs,
+      sourceDirs: componentNaming.sourceDirs,
       extraRoots: componentNaming.extraRoots
     });
   }
   return componentInfo.componentName;
 }
+function hasChildren(parent) {
+  return "children" in parent;
+}
+function appendNode(parent, child) {
+  parent.childNodes.push(child);
+  if (hasChildren(parent) && child.nodeType === 1)
+    parent.children.push(child);
+  return child;
+}
+function removeNode(parent, child) {
+  const idx = parent.childNodes.indexOf(child);
+  if (idx >= 0)
+    parent.childNodes.splice(idx, 1);
+  if (hasChildren(parent) && child.nodeType === 1) {
+    const childIdx = parent.children.indexOf(child);
+    if (childIdx >= 0)
+      parent.children.splice(childIdx, 1);
+  }
+  return child;
+}
+function createMinimalDocument() {
+  const doc = {
+    nodeType: 9,
+    // DOCUMENT_NODE
+    documentElement: null,
+    head: null,
+    body: null,
+    createElement(tag) {
+      const element = {
+        nodeType: 1,
+        tagName: tag.toUpperCase(),
+        childNodes: [],
+        children: [],
+        style: {},
+        dataset: {},
+        setAttribute() {
+        },
+        getAttribute() {
+          return null;
+        },
+        removeAttribute() {
+        },
+        addEventListener() {
+        },
+        removeEventListener() {
+        },
+        appendChild(child) {
+          return appendNode(this, child);
+        },
+        removeChild(child) {
+          return removeNode(this, child);
+        },
+        insertBefore(child) {
+          return appendNode(this, child);
+        },
+        querySelector() {
+          return null;
+        },
+        querySelectorAll() {
+          return [];
+        },
+        contains() {
+          return false;
+        },
+        matches() {
+          return false;
+        },
+        closest() {
+          return null;
+        },
+        getBoundingClientRect() {
+          return { top: 0, left: 0, right: 0, bottom: 0, width: 0, height: 0, x: 0, y: 0, toJSON() {
+            return {};
+          } };
+        },
+        cloneNode() {
+          return this;
+        }
+      };
+      return element;
+    },
+    createTextNode(text) {
+      return { nodeType: 3, textContent: text };
+    },
+    createComment(text) {
+      return { nodeType: 8, textContent: text };
+    },
+    createDocumentFragment() {
+      return {
+        nodeType: 11,
+        childNodes: [],
+        appendChild(child) {
+          return appendNode(this, child);
+        }
+      };
+    },
+    getElementById() {
+      return null;
+    },
+    querySelector() {
+      return null;
+    },
+    querySelectorAll() {
+      return [];
+    },
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    createEvent() {
+      return {
+        initEvent() {
+        }
+      };
+    },
+    queryCommandSupported() {
+      return false;
+    }
+  };
+  const html = doc.createElement("html");
+  const head = doc.createElement("head");
+  const body = doc.createElement("body");
+  const app = doc.createElement("div");
+  app.id = "app";
+  html.appendChild(head);
+  html.appendChild(body);
+  body.appendChild(app);
+  doc.documentElement = html;
+  doc.head = head;
+  doc.body = body;
+  return Object.assign({}, doc);
+}
+function createMinimalLocation() {
+  const url = new URL("https://example.test/");
+  return {
+    get href() {
+      return url.href;
+    },
+    set href(v) {
+      try {
+        Object.assign(url, new URL(v));
+      } catch {
+      }
+    },
+    get origin() {
+      return url.origin;
+    },
+    get protocol() {
+      return url.protocol;
+    },
+    get host() {
+      return url.host;
+    },
+    get hostname() {
+      return url.hostname;
+    },
+    get port() {
+      return url.port;
+    },
+    get pathname() {
+      return url.pathname;
+    },
+    set pathname(v) {
+      url.pathname = v;
+    },
+    get search() {
+      return url.search;
+    },
+    set search(v) {
+      url.search = v;
+    },
+    get hash() {
+      return url.hash;
+    },
+    set hash(v) {
+      url.hash = v;
+    },
+    assign() {
+    },
+    reload() {
+    },
+    replace() {
+    },
+    toString() {
+      return url.href;
+    },
+    ancestorOrigins: { length: 0, contains: () => false, item: () => null, [Symbol.iterator]: [][Symbol.iterator] }
+  };
+}
 async function ensureDomShim() {
-  const domShimHtml = "<!doctype html><html><head></head><body><div id='app'></div></body></html>";
-  const domShimUrl = "https://example.test/";
   const g = globalThis;
   if (typeof document !== "undefined" && typeof window !== "undefined")
     return;
-  const dom = new jsdom.JSDOM(domShimHtml, { url: domShimUrl });
-  g.window = dom.window;
-  g.document = dom.window.document;
-  g.location = dom.window.location;
+  const minimalDoc = createMinimalDocument();
+  const minimalLocation = createMinimalLocation();
+  const win = {
+    document: minimalDoc,
+    location: minimalLocation,
+    navigator: { userAgent: "node" },
+    history: { pushState() {
+    }, replaceState() {
+    }, go() {
+    }, back() {
+    }, forward() {
+    }, state: null, length: 0, scrollRestoration: "auto" },
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    dispatchEvent() {
+      return true;
+    },
+    getComputedStyle() {
+      return {};
+    },
+    scrollTo() {
+    },
+    scroll() {
+    },
+    scrollBy() {
+    },
+    matchMedia() {
+      return { matches: false, media: "", onchange: null, addListener() {
+      }, removeListener() {
+      }, addEventListener() {
+      }, removeEventListener() {
+      }, dispatchEvent() {
+        return true;
+      } };
+    },
+    requestAnimationFrame: (cb) => setTimeout(() => cb(Date.now()), 16),
+    cancelAnimationFrame: (id) => clearTimeout(id),
+    setTimeout,
+    clearTimeout,
+    setInterval,
+    clearInterval,
+    queueMicrotask,
+    performance: globalThis.performance
+  };
+  g.window = win;
+  g.document = minimalDoc;
+  g.location = minimalLocation;
   if (!g.self)
-    g.self = dom.window;
+    g.self = win;
   if (!g.navigator)
-    g.navigator = dom.window.navigator;
+    g.navigator = win.navigator;
   if (!g.history)
-    g.history = { pushState() {
-    }, replaceState() {
-    } };
+    g.history = win.history;
   if (!g.MutationObserver) {
     g.MutationObserver = class {
       disconnect() {
@@ -3241,10 +3594,6 @@ async function ensureDomShim() {
   if (!g.requestIdleCallback) {
     g.requestIdleCallback = (cb) => setTimeout(() => cb({ didTimeout: false, timeRemaining: () => 0 }), 1);
   }
-  const doc = g.document;
-  if (doc && typeof doc.queryCommandSupported !== "function") {
-    doc.queryCommandSupported = () => false;
-  }
   if (!g.localStorage || !g.sessionStorage) {
     const storageFactory = () => {
       const store = /* @__PURE__ */ new Map();
@@ -3270,91 +3619,100 @@ async function ensureDomShim() {
     if (!g.sessionStorage)
       g.sessionStorage = storageFactory();
   }
-  const names = Object.getOwnPropertyNames(dom.window);
-  const shouldCopyGlobal = (name) => {
-    if (name === "Node" || name === "Element" || name === "Document" || name === "Event" || name === "EventTarget")
-      return true;
-    if (name.endsWith("Event"))
-      return true;
-    if (name.startsWith("HTML") && name.endsWith("Element"))
-      return true;
-    if (name.startsWith("SVG") && name.endsWith("Element"))
-      return true;
-    return false;
-  };
-  for (const name of names) {
-    if (!shouldCopyGlobal(name) || g[name])
-      continue;
-    const value = Reflect.get(dom.window, name);
-    if (value)
-      g[name] = value;
-  }
   if (!g.requestAnimationFrame)
     g.requestAnimationFrame = (cb) => setTimeout(() => cb(Date.now()), 16);
 }
-async function introspectNuxtPages(projectRoot) {
-  const possiblePagesDirs = ["app/pages", "pages"];
-  let pagesDir = "";
-  for (const dir of possiblePagesDirs) {
-    const abs = path.resolve(projectRoot, dir);
-    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
-      pagesDir = abs;
+function unwrapNuxtPageSegment(segment, prefix, suffix) {
+  if (!segment.startsWith(prefix) || !segment.endsWith(suffix))
+    return null;
+  const value = segment.slice(prefix.length, segment.length - suffix.length);
+  return value.length > 0 ? value : null;
+}
+function resolveNuxtPageSegment(segment) {
+  if (segment === "index") {
+    return { pathPart: "", params: [] };
+  }
+  const optionalParamName = unwrapNuxtPageSegment(segment, "[[", "]]");
+  if (optionalParamName) {
+    return {
+      pathPart: `:${optionalParamName}?`,
+      params: [{ name: optionalParamName, optional: true }]
+    };
+  }
+  const catchAllParamName = unwrapNuxtPageSegment(segment, "[...", "]");
+  if (catchAllParamName) {
+    return {
+      pathPart: `:${catchAllParamName}(.*)*`,
+      params: [{ name: catchAllParamName, optional: false }]
+    };
+  }
+  const requiredParamName = unwrapNuxtPageSegment(segment, "[", "]");
+  if (requiredParamName) {
+    return {
+      pathPart: `:${requiredParamName}`,
+      params: [{ name: requiredParamName, optional: false }]
+    };
+  }
+  return { pathPart: segment, params: [] };
+}
+function toPathSegments(value) {
+  const segments = [];
+  let current = path.normalize(value);
+  while (current && current !== "." && current !== path.sep) {
+    const parsed = path.parse(current);
+    if (!parsed.base || parsed.base === ".")
       break;
-    }
+    segments.unshift(parsed.base);
+    if (!parsed.dir || parsed.dir === "." || parsed.dir === current)
+      break;
+    current = parsed.dir;
   }
-  if (!pagesDir) {
+  return segments;
+}
+async function introspectNuxtPages(projectRoot, options = {}) {
+  const possiblePageDirs = options.pageDirs?.length ? options.pageDirs : ["app/pages", "pages"].map((dir) => path.resolve(projectRoot, dir));
+  const pageDirs = possiblePageDirs.map((dir) => path.resolve(projectRoot, dir)).filter((dir) => {
+    try {
+      return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  if (!pageDirs.length) {
     debugLog(`[router-introspection][nuxt] Could not find pages directory in ${projectRoot}`);
     return { routeNameMap: /* @__PURE__ */ new Map(), routePathMap: /* @__PURE__ */ new Map(), routeMetaEntries: [] };
   }
+  const routePathMap = /* @__PURE__ */ new Map();
   const routeMetaEntries = [];
-  const walk = (dir, baseRoute) => {
+  const walk = (pagesDir, dir) => {
     const files = fs.readdirSync(dir);
     for (const file of files) {
       const fullPath = path.join(dir, file);
       const stat = fs.statSync(fullPath);
       if (stat.isDirectory()) {
-        walk(fullPath, `${baseRoute}/${file}`);
+        walk(pagesDir, fullPath);
         continue;
       }
       if (!file.endsWith(".vue"))
         continue;
-      const componentName = file.slice(0, -4);
-      if (componentName === "index" && baseRoute === "") {
-        routeMetaEntries.push({
-          componentName: "index",
-          pathTemplate: "/",
-          params: [],
-          query: []
-        });
-        continue;
-      }
-      let routePath = componentName === "index" ? baseRoute : `${baseRoute}/${componentName}`;
-      if (!routePath.startsWith("/"))
-        routePath = `/${routePath}`;
+      const componentName = resolveComponentNameFromPath({
+        filename: fullPath,
+        projectRoot,
+        viewsDirAbs: pagesDir,
+        sourceDirs: [pagesDir],
+        extraRoots: [process.cwd()]
+      });
+      const relativePath = path.relative(pagesDir, fullPath);
+      const parsed = path.parse(relativePath);
+      const routeSegments = toPathSegments(path.join(parsed.dir, parsed.name));
       const params = [];
-      let pathTemplate = "";
-      for (let i = 0; i < routePath.length; i++) {
-        const ch = routePath[i];
-        if (ch !== "[") {
-          pathTemplate += ch;
-          continue;
-        }
-        let name = "";
-        i++;
-        while (i < routePath.length) {
-          const c = routePath[i];
-          if (c === "]")
-            break;
-          name += c;
-          i++;
-        }
-        if (name) {
-          params.push({ name, optional: false });
-          pathTemplate += `:${name}`;
-        } else {
-          pathTemplate += "[]";
-        }
-      }
+      const pathParts = routeSegments.flatMap((segment) => {
+        const resolution = resolveNuxtPageSegment(segment);
+        params.push(...resolution.params);
+        return resolution.pathPart ? [resolution.pathPart] : [];
+      });
+      const pathTemplate = pathParts.length ? `/${pathParts.join("/")}` : "/";
+      routePathMap.set(pathTemplate, componentName);
       routeMetaEntries.push({
         componentName,
         pathTemplate,
@@ -3363,10 +3721,12 @@ async function introspectNuxtPages(projectRoot) {
       });
     }
   };
-  walk(pagesDir, "");
+  for (const pageDir of pageDirs) {
+    walk(pageDir, pageDir);
+  }
   return {
     routeNameMap: /* @__PURE__ */ new Map(),
-    routePathMap: /* @__PURE__ */ new Map(),
+    routePathMap,
     routeMetaEntries
   };
 }
@@ -3662,15 +4022,20 @@ function resolveVueSourcePath(targetClassName, vueFilesPathMap, projectRoot) {
 }
 async function getRouteMetaByComponent(projectRoot, routerEntry, routerType, options = {}) {
   const root = projectRoot ?? process.cwd();
-  const viewsDir = options.viewsDir ?? "src/views";
-  const viewsDirAbs = path.isAbsolute(viewsDir) ? viewsDir : path.resolve(root, viewsDir);
-  const scanDirs = options.scanDirs?.length ? options.scanDirs : ["src"];
+  const pageDirs = options.pageDirs?.length ? options.pageDirs : ["src/views"];
+  const pageDirsAbs = pageDirs.map((dir) => path.isAbsolute(dir) ? dir : path.resolve(root, dir));
+  const primaryPageDirAbs = pageDirsAbs[0] ?? path.resolve(root, "src/views");
+  const sourceDirs = [
+    ...pageDirs,
+    ...options.componentDirs?.length ? options.componentDirs : ["src/components"],
+    ...options.layoutDirs?.length ? options.layoutDirs : ["src/layouts"]
+  ];
   const extraRoots = process.cwd() !== root ? [process.cwd()] : [];
-  const { routeMetaEntries } = routerType === "nuxt" ? await introspectNuxtPages(root) : await parseRouterFileFromCwd(resolveRouterEntry(root, routerEntry), {
+  const { routeMetaEntries } = routerType === "nuxt" ? await introspectNuxtPages(root, { pageDirs: pageDirsAbs }) : await parseRouterFileFromCwd(resolveRouterEntry(root, routerEntry), {
     componentNaming: {
       projectRoot: root,
-      viewsDirAbs,
-      scanDirs,
+      viewsDirAbs: primaryPageDirAbs,
+      sourceDirs,
       extraRoots
     }
   });
@@ -3870,15 +4235,17 @@ async function generateFiles(componentHierarchyMap, vueFilesPathMap, basePageCla
     vueRouterFluentChaining,
     routerEntry,
     routerType,
-    viewsDir,
-    scanDirs,
+    pageDirs,
+    componentDirs,
+    layoutDirs,
     routeMetaByComponent: routeMetaByComponentOverride
   } = options;
   const emitLanguages = emitLanguagesOverride?.length ? emitLanguagesOverride : ["ts"];
   const outDir = outDirOverride ?? "./pom";
   const routeMetaByComponent = routeMetaByComponentOverride ?? (vueRouterFluentChaining ? await getRouteMetaByComponent(projectRoot, routerEntry, routerType, {
-    viewsDir,
-    scanDirs
+    pageDirs,
+    componentDirs,
+    layoutDirs
   }) : void 0);
   const generatedFilePaths = [];
   const writeGeneratedFile = (file) => {
@@ -4223,7 +4590,7 @@ function generateAggregatedCSharpFiles(componentHierarchyMap, outDir, options =
     "    }",
     "",
     "    // Minimal vue-select helper mirroring the TS BasePage.selectVSelectByTestId behavior.",
-    "    // Note: annotationText is currently a no-op in C# output (we don't render a cursor overlay).",
+    "    // Note: annotationText is currently a no-op in C# output (we don't render a pointer overlay).",
     "    protected async Task SelectVSelectByTestIdAsync(string testId, string value, int timeOut = 500)",
     "    {",
     "        var root = LocatorByTestId(testId);",
@@ -6183,7 +6550,7 @@ function createTestIdTransform(componentName, componentHierarchyMap, nativeWrapp
   const existingIdBehavior = options.existingIdBehavior ?? "preserve";
   const testIdAttribute = (options.testIdAttribute || "data-testid").trim() || "data-testid";
   const nameCollisionBehavior = options.nameCollisionBehavior ?? "suffix";
-  const missingSemanticNameBehavior = options.missingSemanticNameBehavior ?? "ignore";
+  const missingSemanticNameBehavior = options.missingSemanticNameBehavior ?? "error";
   const warn = options.warn;
   const vueFilesPathMap = options.vueFilesPathMap;
   const wrapperSearchRoots = options.wrapperSearchRoots ?? [];
@@ -6667,8 +7034,11 @@ function createBuildProcessorPlugin(options) {
   const {
     componentHierarchyMap,
     vueFilesPathMap,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     basePageClassPath,
     normalizedBasePagePath,
     outDir,
@@ -6683,13 +7053,13 @@ function createBuildProcessorPlugin(options) {
     customPomImportNameCollisionBehavior,
     testIdAttribute,
     nameCollisionBehavior,
-    missingSemanticNameBehavior,
+    missingSemanticNameBehavior = "error",
     existingIdBehavior,
     nativeWrappers,
     excludedComponents,
     getWrapperSearchRoots,
     routerAwarePoms,
-    resolvedRouterEntry,
+    getResolvedRouterEntry,
     routerType,
     routerModuleShims,
     loggerRef
@@ -6699,7 +7069,8 @@ function createBuildProcessorPlugin(options) {
     interactiveComponentCount: 0,
     dataTestIdCount: 0
   };
-  const getViewsDirAbs = () => path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir);
+  const getViewsDirAbs = () => path.isAbsolute(getViewsDir()) ? getViewsDir() : path.resolve(projectRootRef.current, getViewsDir());
+  const getPageDirsAbs = () => getPageDirs().map((dir) => path.isAbsolute(dir) ? dir : path.resolve(projectRootRef.current, dir));
   const getScriptInfo = (source, filename) => {
     try {
       const { descriptor } = compilerSfc.parse(source, { filename });
@@ -6739,7 +7110,7 @@ function createBuildProcessorPlugin(options) {
       return out;
     };
     let supplemented = 0;
-    for (const dir of scanDirs) {
+    for (const dir of getSourceDirs()) {
       const absDir = path.resolve(projectRootRef.current, dir);
       if (!fs.existsSync(absDir))
         continue;
@@ -6749,7 +7120,7 @@ function createBuildProcessorPlugin(options) {
           filename: absolutePath,
           projectRoot: projectRootRef.current,
           viewsDirAbs: getViewsDirAbs(),
-          scanDirs,
+          sourceDirs: getSourceDirs(),
           extraRoots: [process.cwd()]
         });
         if (componentHierarchyMap.has(componentName))
@@ -6824,16 +7195,17 @@ function createBuildProcessorPlugin(options) {
       }
       let result;
       if (routerType === "nuxt") {
-        result = await introspectNuxtPages(projectRootRef.current);
+        result = await introspectNuxtPages(projectRootRef.current, { pageDirs: getPageDirsAbs() });
       } else {
+        const resolvedRouterEntry = getResolvedRouterEntry();
         if (!resolvedRouterEntry)
           throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
         result = await parseRouterFileFromCwd(resolvedRouterEntry, {
           moduleShims: routerModuleShims,
           componentNaming: {
             projectRoot: projectRootRef.current,
-            viewsDirAbs: path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir),
-            scanDirs
+            viewsDirAbs: getViewsDirAbs(),
+            sourceDirs: getSourceDirs()
           }
         });
       }
@@ -6867,6 +7239,10 @@ function createBuildProcessorPlugin(options) {
         this.error(`callout.ts not found at ${calloutPath}. Ensure it is included in the build.`);
       }
       this.addWatchFile(calloutPath);
+      const floatingUiCalloutPath = path.resolve(path.dirname(basePageClassPath), "floating-ui-callout.ts");
+      if (fs.existsSync(floatingUiCalloutPath)) {
+        this.addWatchFile(floatingUiCalloutPath);
+      }
     },
     async buildEnd(error) {
       if (error) {
@@ -6893,10 +7269,11 @@ function createBuildProcessorPlugin(options) {
         customPomImportNameCollisionBehavior,
         testIdAttribute,
         vueRouterFluentChaining: routerAwarePoms,
-        routerEntry: resolvedRouterEntry,
+        routerEntry: getResolvedRouterEntry(),
         routerType,
-        viewsDir,
-        scanDirs
+        pageDirs: getPageDirs(),
+        componentDirs: getComponentDirs(),
+        layoutDirs: getLayoutDirs()
       });
       lastGeneratedMetrics = metrics;
       loggerRef.current.info(`generated POMs (${metrics.entryCount} entries, ${metrics.interactiveComponentCount} interactive components, ${metrics.dataTestIdCount} selectors)`);
@@ -6910,8 +7287,11 @@ function createDevProcessorPlugin(options) {
   const {
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     projectRootRef,
     normalizedBasePagePath,
@@ -6926,16 +7306,33 @@ function createDevProcessorPlugin(options) {
     customPomImportAliases,
     customPomImportNameCollisionBehavior,
     nameCollisionBehavior = "suffix",
-    missingSemanticNameBehavior,
+    missingSemanticNameBehavior = "error",
     existingIdBehavior,
     testIdAttribute,
     routerAwarePoms,
-    resolvedRouterEntry,
+    getResolvedRouterEntry,
     routerType,
     routerModuleShims,
     loggerRef
   } = options;
   let scheduleVueFileRegen = null;
+  const getProjectRootCandidates = () => Array.from(/* @__PURE__ */ new Set([
+    path.resolve(projectRootRef.current),
+    path.resolve(process.cwd())
+  ]));
+  const resolveProjectPath = (maybePath) => {
+    if (path.isAbsolute(maybePath))
+      return maybePath;
+    const candidates = getProjectRootCandidates().map((root) => path.resolve(root, maybePath));
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+  };
+  const getSourceDirRoots = () => Array.from(new Set(
+    getProjectRootCandidates().flatMap((root) => getSourceDirs().map((dir) => path.resolve(root, dir)))
+  ));
+  const isContainedInScanDirs = (filePath) => {
+    const absolutePath = path.resolve(filePath);
+    return getSourceDirRoots().some((scanDirAbs) => isPathWithinDir(absolutePath, scanDirAbs));
+  };
   return {
     name: "vue-pom-generator-dev",
     apply: "serve",
@@ -6946,16 +7343,13 @@ function createDevProcessorPlugin(options) {
         return;
       if (!ctx.file.endsWith(".vue"))
         return;
-      const isContainedInScanDirs = scanDirs.some((dir) => {
-        const absDir = path.resolve(projectRootRef.current, dir);
-        return ctx.file.startsWith(absDir + path.sep);
-      });
-      if (!isContainedInScanDirs)
+      if (!isContainedInScanDirs(ctx.file))
         return;
       scheduleVueFileRegen(ctx.file, "hmr");
     },
     async configureServer(server) {
-      const getViewsDirAbs = () => path.isAbsolute(viewsDir) ? viewsDir : path.resolve(projectRootRef.current, viewsDir);
+      const getViewsDirAbs = () => resolveProjectPath(getViewsDir());
+      const getPageDirsAbs = () => getPageDirs().map((dir) => resolveProjectPath(dir));
       const routerInitPromise = (async () => {
         if (!routerAwarePoms) {
           setRouteNameToComponentNameMap(/* @__PURE__ */ new Map());
@@ -6964,8 +7358,9 @@ function createDevProcessorPlugin(options) {
         }
         let result;
         if (routerType === "nuxt") {
-          result = await introspectNuxtPages(projectRootRef.current);
+          result = await introspectNuxtPages(projectRootRef.current, { pageDirs: getPageDirsAbs() });
         } else {
+          const resolvedRouterEntry = getResolvedRouterEntry();
           if (!resolvedRouterEntry)
             throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
           result = await parseRouterFileFromCwd(resolvedRouterEntry, {
@@ -6973,7 +7368,7 @@ function createDevProcessorPlugin(options) {
             componentNaming: {
               projectRoot: projectRootRef.current,
               viewsDirAbs: getViewsDirAbs(),
-              scanDirs,
+              sourceDirs: getSourceDirs(),
               extraRoots: [process.cwd()]
             }
           });
@@ -7045,6 +7440,19 @@ function createDevProcessorPlugin(options) {
       let snapshotHierarchy = /* @__PURE__ */ new Map();
       let snapshotVuePathMap = /* @__PURE__ */ new Map();
       const filePathToComponentName = /* @__PURE__ */ new Map();
+      const createEmptyComponentDependencies = (absolutePath) => {
+        const viewsDirAbs = path.resolve(getViewsDirAbs());
+        const relToViewsDir = path.relative(viewsDirAbs, absolutePath);
+        const isView = !relToViewsDir.startsWith("..") && !path.isAbsolute(relToViewsDir);
+        return {
+          filePath: absolutePath,
+          childrenComponentSet: /* @__PURE__ */ new Set(),
+          usedComponentSet: /* @__PURE__ */ new Set(),
+          dataTestIdSet: /* @__PURE__ */ new Set(),
+          isView,
+          methodsContent: ""
+        };
+      };
       const getComponentNameForFile = (filePath) => {
         const normalized = path.resolve(filePath);
         const existing = filePathToComponentName.get(normalized);
@@ -7054,7 +7462,7 @@ function createDevProcessorPlugin(options) {
           filename: normalized,
           projectRoot: projectRootRef.current,
           viewsDirAbs: getViewsDirAbs(),
-          scanDirs,
+          sourceDirs: getSourceDirs(),
           extraRoots: [process.cwd()]
         });
         filePathToComponentName.set(normalized, name);
@@ -7064,8 +7472,6 @@ function createDevProcessorPlugin(options) {
         const started = node_perf_hooks.performance.now();
         const absolutePath = path.resolve(filePath);
         const componentName = getComponentNameForFile(absolutePath);
-        targetVuePathMap.set(componentName, absolutePath);
-        targetHierarchy.delete(componentName);
         let sfc = "";
         try {
           sfc = fs.readFileSync(absolutePath, "utf8");
@@ -7073,9 +7479,15 @@ function createDevProcessorPlugin(options) {
           return { componentName, ms: node_perf_hooks.performance.now() - started, compiled: false };
         }
         const template = extractTemplateFromSfc(sfc, absolutePath);
-        if (!template.trim())
+        if (!template.trim()) {
+          targetVuePathMap.set(componentName, absolutePath);
+          targetHierarchy.set(componentName, createEmptyComponentDependencies(absolutePath));
           return { componentName, ms: node_perf_hooks.performance.now() - started, compiled: true };
+        }
         const { bindings: bindingMetadata, isScriptSetup } = getScriptInfo(sfc, absolutePath);
+        const provisionalHierarchy = /* @__PURE__ */ new Map();
+        const provisionalVuePathMap = new Map(targetVuePathMap);
+        provisionalVuePathMap.set(componentName, absolutePath);
         compilerDom__namespace.compile(template, {
           filename: absolutePath,
           prefixIdentifiers: true,
@@ -7084,7 +7496,7 @@ function createDevProcessorPlugin(options) {
           nodeTransforms: [
             createTestIdTransform(
               componentName,
-              targetHierarchy,
+              provisionalHierarchy,
               nativeWrappers,
               excludedComponents,
               getViewsDirAbs(),
@@ -7094,23 +7506,27 @@ function createDevProcessorPlugin(options) {
                 missingSemanticNameBehavior,
                 testIdAttribute,
                 warn: (message) => loggerRef.current.warn(message),
-                vueFilesPathMap: targetVuePathMap,
+                vueFilesPathMap: provisionalVuePathMap,
                 wrapperSearchRoots: getWrapperSearchRoots()
               }
             )
           ]
         });
+        targetVuePathMap.set(componentName, absolutePath);
+        targetHierarchy.set(
+          componentName,
+          provisionalHierarchy.get(componentName) ?? createEmptyComponentDependencies(absolutePath)
+        );
         return { componentName, ms: node_perf_hooks.performance.now() - started, compiled: true };
       };
-      const fullRebuildSnapshotFromFilesystem = () => {
+      const fullRebuildSnapshotFromFilesystem = (logLabel) => {
         const t0 = node_perf_hooks.performance.now();
         const nextHierarchy = /* @__PURE__ */ new Map();
         const nextVuePathMap = /* @__PURE__ */ new Map();
         filePathToComponentName.clear();
         let totalVueFiles = 0;
         let compiledCount = 0;
-        for (const dir of scanDirs) {
-          const absDir = path.resolve(projectRootRef.current, dir);
+        for (const absDir of getSourceDirRoots()) {
           if (!fs.existsSync(absDir))
             continue;
           const vueFiles = walkFilesRecursive(absDir);
@@ -7124,12 +7540,12 @@ function createDevProcessorPlugin(options) {
         snapshotHierarchy = nextHierarchy;
         snapshotVuePathMap = nextVuePathMap;
         const t1 = node_perf_hooks.performance.now();
-        logInfo(`initial scan: found ${totalVueFiles} .vue files in ${scanDirs.join(", ")}`);
-        logInfo(`initial compile: ${compiledCount}/${totalVueFiles} files in ${formatMs(t1 - t0)} (components=${snapshotHierarchy.size})`);
+        logInfo(`scan(${logLabel}): found ${totalVueFiles} .vue files in ${getSourceDirs().join(", ")}`);
+        logInfo(`compile(${logLabel}): ${compiledCount}/${totalVueFiles} files in ${formatMs(t1 - t0)} (components=${snapshotHierarchy.size})`);
       };
-      const generateAggregatedFromSnapshot = (reason) => {
+      const generateAggregatedFromSnapshot = async (logLabel) => {
         const t0 = node_perf_hooks.performance.now();
-        generateFiles(snapshotHierarchy, snapshotVuePathMap, normalizedBasePagePath, {
+        await generateFiles(snapshotHierarchy, snapshotVuePathMap, normalizedBasePagePath, {
           outDir,
           emitLanguages,
           typescriptOutputStructure,
@@ -7140,25 +7556,27 @@ function createDevProcessorPlugin(options) {
           customPomDir,
           customPomImportAliases,
           customPomImportNameCollisionBehavior,
-          viewsDir,
-          scanDirs,
+          pageDirs: getPageDirs(),
+          componentDirs: getComponentDirs(),
+          layoutDirs: getLayoutDirs(),
           testIdAttribute,
           vueRouterFluentChaining: routerAwarePoms,
-          routerEntry: resolvedRouterEntry,
+          routerEntry: getResolvedRouterEntry(),
           routerType
         });
         const t1 = node_perf_hooks.performance.now();
-        logInfo(`generate(${reason}): components=${snapshotHierarchy.size} in ${formatMs(t1 - t0)}`);
+        logInfo(`generate(${logLabel}): components=${snapshotHierarchy.size} in ${formatMs(t1 - t0)}`);
       };
       let timer = null;
       let maxWaitTimer = null;
       const pendingChangedVueFiles = /* @__PURE__ */ new Set();
       const pendingDeletedComponents = /* @__PURE__ */ new Set();
+      let regenerationSequence = Promise.resolve();
       const initialBuildPromise = (async () => {
         const t0 = node_perf_hooks.performance.now();
         await routerInitPromise;
-        fullRebuildSnapshotFromFilesystem();
-        generateAggregatedFromSnapshot("startup");
+        fullRebuildSnapshotFromFilesystem("startup");
+        await generateAggregatedFromSnapshot("startup");
         const t1 = node_perf_hooks.performance.now();
         logInfo(`startup total: ${formatMs(t1 - t0)}`);
       })();
@@ -7186,7 +7604,7 @@ function createDevProcessorPlugin(options) {
         snapshotHierarchy = nextHierarchy;
         snapshotVuePathMap = nextVuePathMap;
         const t1 = node_perf_hooks.performance.now();
-        generateAggregatedFromSnapshot(reason);
+        await generateAggregatedFromSnapshot(reason);
         const t2 = node_perf_hooks.performance.now();
         return {
           files,
@@ -7197,7 +7615,12 @@ function createDevProcessorPlugin(options) {
           totalMs: t2 - t0
         };
       };
-      const watchedVueGlobs = scanDirs.map((dir) => path.resolve(projectRootRef.current, dir, "**", "*.vue"));
+      const enqueueRegeneration = (reason) => {
+        const currentRun = regenerationSequence.catch(() => void 0).then(() => regenerateFromPending(reason));
+        regenerationSequence = currentRun.then(() => void 0, () => void 0);
+        return currentRun;
+      };
+      const watchedVueGlobs = getSourceDirRoots().map((scanDirAbs) => path.resolve(scanDirAbs, "**", "*.vue"));
       const watchedPluginGlob = path.resolve(projectRootRef.current, "vite-plugins", "vue-pom-generator", "**", "*.ts");
       const runtimeDir = path.dirname(basePageClassPath);
       server.watcher.add([
@@ -7205,7 +7628,8 @@ function createDevProcessorPlugin(options) {
         watchedPluginGlob,
         basePageClassPath,
         path.resolve(runtimeDir, "pointer.ts"),
-        path.resolve(runtimeDir, "callout.ts")
+        path.resolve(runtimeDir, "callout.ts"),
+        path.resolve(runtimeDir, "floating-ui-callout.ts")
       ]);
       scheduleVueFileRegenLocal = (filePath, source) => {
         pendingChangedVueFiles.add(filePath);
@@ -7223,7 +7647,7 @@ function createDevProcessorPlugin(options) {
               timer = null;
             }
             maxWaitTimer = null;
-            void regenerateFromPending("max-wait").then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
+            void enqueueRegeneration("max-wait").then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
               logInfo(
                 `max-wait: files=${files.length} deleted=${deletedCount} compile=${formatMs(compileMs)} wall=${formatMs(preGenerateMs)} gen=${formatMs(generateMs)} total=${formatMs(totalMs)}`
               );
@@ -7247,7 +7671,7 @@ function createDevProcessorPlugin(options) {
             maxWaitTimer = null;
           }
           const reason = pendingChangedVueFiles.size || pendingDeletedComponents.size ? "batched" : "noop";
-          void regenerateFromPending(reason).then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
+          void enqueueRegeneration(reason).then(({ files, deletedCount, compileMs, preGenerateMs, generateMs, totalMs }) => {
             if (files.length || deletedCount) {
               logInfo(
                 `batched: files=${files.length} deleted=${deletedCount} compile=${formatMs(compileMs)} wall=${formatMs(preGenerateMs)} gen=${formatMs(generateMs)} total=${formatMs(totalMs)}`
@@ -7274,11 +7698,7 @@ function createDevProcessorPlugin(options) {
           return;
         if (!p.endsWith(".vue"))
           return;
-        const isContainedInScanDirs = scanDirs.some((dir) => {
-          const absDir = path.resolve(projectRootRef.current, dir);
-          return p.startsWith(absDir + path.sep);
-        });
-        if (!isContainedInScanDirs)
+        if (!isContainedInScanDirs(p))
           return;
         void (async () => {
           await initialBuildPromise;
@@ -7291,11 +7711,7 @@ function createDevProcessorPlugin(options) {
           return;
         if (!p.endsWith(".vue"))
           return;
-        const isContainedInScanDirs = scanDirs.some((dir) => {
-          const absDir = path.resolve(projectRootRef.current, dir);
-          return p.startsWith(absDir + path.sep);
-        });
-        if (!isContainedInScanDirs)
+        if (!isContainedInScanDirs(p))
           return;
         void (async () => {
           await initialBuildPromise;
@@ -7345,12 +7761,20 @@ function generateTestIdsModule(componentTestIds) {
     });
   });
 }
+const VIRTUAL_ID = "virtual:testids";
+const RESOLVED_ID = `\0${VIRTUAL_ID}`;
 function createTestIdsVirtualModulesPlugin(componentTestIds) {
-  const maybeModule = virtualImport;
-  const virtual = maybeModule.default ?? virtualImport;
-  return virtual({
-    "virtual:testids": () => generateTestIdsModule(componentTestIds)
-  });
+  return {
+    name: "vue-pom-generator:virtual-testids",
+    resolveId(id) {
+      if (id === VIRTUAL_ID)
+        return RESOLVED_ID;
+    },
+    load(id) {
+      if (id === RESOLVED_ID)
+        return generateTestIdsModule(componentTestIds);
+    }
+  };
 }
 function createSupportPlugins(options) {
   const {
@@ -7359,11 +7783,14 @@ function createSupportPlugins(options) {
     vueFilesPathMap,
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     nameCollisionBehavior = "suffix",
-    missingSemanticNameBehavior,
+    missingSemanticNameBehavior = "error",
     existingIdBehavior,
     outDir,
     emitLanguages,
@@ -7392,7 +7819,6 @@ function createSupportPlugins(options) {
       throw new Error("[vue-pom-generator] router.entry is required when router introspection is enabled.");
     return path.isAbsolute(routerEntry) ? routerEntry : path.resolve(projectRootRef.current, routerEntry);
   };
-  const resolvedRouterEntry = resolveRouterEntry2();
   const getDefaultBasePageClassPath = () => {
     try {
       return node_url.fileURLToPath(new URL("../class-generation/base-page.ts", typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href));
@@ -7405,8 +7831,11 @@ function createSupportPlugins(options) {
   const tsProcessor = createBuildProcessorPlugin({
     componentHierarchyMap,
     vueFilesPathMap,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     basePageClassPath,
     normalizedBasePagePath,
     outDir,
@@ -7428,15 +7857,18 @@ function createSupportPlugins(options) {
     getWrapperSearchRoots,
     routerAwarePoms,
     routerType,
-    resolvedRouterEntry,
+    getResolvedRouterEntry: resolveRouterEntry2,
     routerModuleShims,
     loggerRef
   });
   const devProcessor = createDevProcessorPlugin({
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots,
     projectRootRef,
     normalizedBasePagePath,
@@ -7456,7 +7888,7 @@ function createSupportPlugins(options) {
     testIdAttribute,
     routerAwarePoms,
     routerType,
-    resolvedRouterEntry,
+    getResolvedRouterEntry: resolveRouterEntry2,
     routerModuleShims,
     loggerRef
   });
@@ -7614,7 +8046,7 @@ function createVuePluginWithTestIds(options) {
     getViewsDirAbs,
     testIdAttribute,
     loggerRef,
-    scanDirs = ["src"],
+    getSourceDirs,
     getWrapperSearchRoots,
     getProjectRoot
   } = options;
@@ -7623,7 +8055,7 @@ function createVuePluginWithTestIds(options) {
       filename,
       projectRoot: getProjectRoot(),
       viewsDirAbs: getViewsDirAbs(),
-      scanDirs,
+      sourceDirs: getSourceDirs(),
       extraRoots: [process.cwd()]
     });
   };
@@ -7639,7 +8071,7 @@ function createVuePluginWithTestIds(options) {
     if (absFilename.startsWith(viewsDirAbs + path.sep) || absFilename === viewsDirAbs)
       return true;
     const rootsToTry = [projectRoot, process.cwd()];
-    const matched = scanDirs.some((dir) => {
+    const matched = getSourceDirs().some((dir) => {
       return rootsToTry.some((root) => {
         const absDir = path.resolve(root, dir);
         if (absFilename.startsWith(absDir + path.sep) || absFilename === absDir)
@@ -7814,6 +8246,25 @@ function createVuePluginWithTestIds(options) {
   };
   return { metadataCollectorPlugin, internalVuePlugin, nuxtVueBridgePlugin, templateCompilerOptions };
 }
+const nuxtConfigMarker$1 = /* @__PURE__ */ Symbol.for("@immense/vue-pom-generator.nuxt");
+const nuxtConfigFileNames = [
+  "nuxt.config.ts",
+  "nuxt.config.js",
+  "nuxt.config.mjs",
+  "nuxt.config.cjs",
+  "nuxt.config.mts",
+  "nuxt.config.cts",
+  ".nuxtrc"
+];
+const nuxtSourceMarkers = [
+  "app.vue",
+  "app",
+  "pages",
+  "layouts",
+  "components",
+  "layers",
+  ".nuxt"
+];
 function assertNonEmptyString(value, name) {
   if (!value || !value.trim()) {
     throw new Error(`${name} must be a non-empty string.`);
@@ -7854,12 +8305,63 @@ function assertErrorBehavior(value, name) {
 }
 function resolveMissingSemanticNameBehavior(value) {
   if (!value) {
-    return "ignore";
+    return "error";
   }
   if (value === "ignore" || value === "error") {
     return value;
   }
-  return value.missingSemanticNameBehavior ?? "ignore";
+  return value.missingSemanticNameBehavior ?? "error";
+}
+function readPackageJson(projectRoot) {
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function recordHasOwnStringKey(value, key) {
+  return value !== null && value !== void 0 && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, key) && typeof value[key] === "string";
+}
+function projectPackageLooksNuxt(projectRoot) {
+  const packageJson = readPackageJson(projectRoot);
+  if (!packageJson) {
+    return false;
+  }
+  const dependencyGroups = [
+    packageJson.dependencies,
+    packageJson.devDependencies,
+    packageJson.peerDependencies,
+    packageJson.optionalDependencies
+  ];
+  if (dependencyGroups.some((group) => {
+    const dependencyGroup = typeof group === "object" && group !== null ? group : void 0;
+    return recordHasOwnStringKey(dependencyGroup, "nuxt") || recordHasOwnStringKey(dependencyGroup, "nuxt-nightly");
+  })) {
+    return true;
+  }
+  if (typeof packageJson.scripts !== "object" || packageJson.scripts === null || Array.isArray(packageJson.scripts)) {
+    return false;
+  }
+  return Object.values(packageJson.scripts).some((script) => {
+    if (typeof script !== "string") {
+      return false;
+    }
+    const normalizedScript = script.trim();
+    return normalizedScript === "nuxt" || normalizedScript.startsWith("nuxt ") || normalizedScript === "nuxi" || normalizedScript.startsWith("nuxi ");
+  });
+}
+function detectNuxtProject(options, projectRoot) {
+  if (options[nuxtConfigMarker$1] === true) {
+    return true;
+  }
+  if (nuxtConfigFileNames.some((fileName) => fs.existsSync(path.join(projectRoot, fileName)))) {
+    return true;
+  }
+  return projectPackageLooksNuxt(projectRoot) && nuxtSourceMarkers.some((entry) => fs.existsSync(path.join(projectRoot, entry)));
 }
 function assertRouterModuleShims(value, name) {
   if (!value)
@@ -7968,14 +8470,18 @@ function assertNotVitePluginInstance(options) {
 function createVuePomGeneratorPlugins(options = {}) {
   assertNotVitePluginInstance(options);
   const injection = options.injection ?? {};
+  const isNuxt = detectNuxtProject(options, process.cwd());
   const generationSetting = options.generation;
   const generationOptions = generationSetting === false ? null : generationSetting ?? {};
   const generationEnabled = generationOptions !== null;
+  const vueGenerationOptions = generationOptions;
   const verbosity = options.logging?.verbosity ?? "warn";
   const vueOptions = options.vueOptions;
-  const viewsDir = injection.viewsDir ?? "src/views";
-  const scanDirs = injection.scanDirs ?? ["src"];
-  const wrapperSearchRoots = injection.wrapperSearchRoots ?? [];
+  const legacyVueOptions = options;
+  const pageDirsRef = { current: !isNuxt ? [legacyVueOptions.injection?.viewsDir ?? "src/views"] : ["app/pages"] };
+  const componentDirsRef = { current: !isNuxt ? legacyVueOptions.injection?.componentDirs ?? ["src/components"] : ["app/components"] };
+  const layoutDirsRef = { current: !isNuxt ? legacyVueOptions.injection?.layoutDirs ?? ["src/layouts"] : ["app/layouts"] };
+  const wrapperSearchRootsRef = { current: !isNuxt ? legacyVueOptions.injection?.wrapperSearchRoots ?? [] : [] };
   const nativeWrappers = injection.nativeWrappers ?? {};
   const excludedComponents = injection.excludeComponents ?? [];
   const testIdAttribute = (injection.attribute ?? "data-testid").trim() || "data-testid";
@@ -7983,10 +8489,9 @@ function createVuePomGeneratorPlugins(options = {}) {
   const outDir = (generationOptions?.outDir ?? "tests/playwright/__generated__").trim();
   const emitLanguages = generationOptions?.emit && generationOptions.emit.length ? generationOptions.emit : ["ts"];
   const nameCollisionBehavior = generationOptions?.nameCollisionBehavior ?? "suffix";
-  const routerEntry = generationOptions?.router?.entry;
-  const routerType = generationOptions?.router?.type ?? "vue-router";
-  const routerModuleShims = generationOptions?.router?.moduleShims;
-  const isNuxt = routerType === "nuxt";
+  const routerEntry = !isNuxt ? vueGenerationOptions?.router?.entry : void 0;
+  const routerType = isNuxt ? "nuxt" : vueGenerationOptions?.router?.type ?? "vue-router";
+  const routerModuleShims = !isNuxt ? vueGenerationOptions?.router?.moduleShims : void 0;
   if (isNuxt && options.vuePluginOwnership === "internal") {
     throw new Error('[vue-pom-generator] Nuxt projects must use the resolved app-owned vite:vue plugin. Omit vuePluginOwnership or set it to "external".');
   }
@@ -8003,66 +8508,100 @@ function createVuePomGeneratorPlugins(options = {}) {
   const resolvedCustomPomImportAliases = customPoms?.importAliases;
   const resolvedCustomPomImportCollisionBehavior = customPoms?.importNameCollisionBehavior ?? "error";
   const basePageClassPathOverride = generationOptions?.basePageClassPath;
+  const getPageDirs = () => pageDirsRef.current;
+  const getViewsDir = () => getPageDirs()[0] ?? "src/views";
+  const getComponentDirs = () => componentDirsRef.current;
+  const getLayoutDirs = () => layoutDirsRef.current;
+  const getSourceDirs = () => Array.from(/* @__PURE__ */ new Set([
+    ...getPageDirs(),
+    ...getComponentDirs(),
+    ...getLayoutDirs()
+  ]));
+  const getWrapperSearchRoots = () => wrapperSearchRootsRef.current;
   const sharedStateKey = JSON.stringify({
     cwd: process.cwd(),
-    viewsDir,
-    scanDirs,
-    wrapperSearchRoots,
+    mode: isNuxt ? "nuxt" : "vue",
+    pageDirs: isNuxt ? null : getPageDirs(),
+    componentDirs: isNuxt ? null : getComponentDirs(),
+    layoutDirs: isNuxt ? null : getLayoutDirs(),
+    wrapperSearchRoots: isNuxt ? null : getWrapperSearchRoots(),
     outDir,
     testIdAttribute,
     routerType,
     vuePluginOwnership
   });
   const sharedState = getSharedGeneratorState(sharedStateKey);
+  let templateCompilerOptionsForResolvedPlugin;
   const projectRootRef = { current: process.cwd() };
   const loggerRef = {
     current: createLogger({ verbosity })
   };
-  const getViewsDirAbs = () => resolveFromProjectRoot(projectRootRef.current, viewsDir);
-  const getWrapperSearchRootsAbs = () => wrapperSearchRoots.map((root) => resolveFromProjectRoot(projectRootRef.current, root));
-  const { componentTestIds, elementMetadata, semanticNameMap, componentHierarchyMap, vueFilesPathMap } = sharedState;
-  const { metadataCollectorPlugin, internalVuePlugin, templateCompilerOptions } = createVuePluginWithTestIds({
-    vueOptions,
-    existingIdBehavior,
-    nameCollisionBehavior,
-    nativeWrappers,
-    elementMetadata,
-    semanticNameMap,
-    componentHierarchyMap,
-    vueFilesPathMap,
-    excludedComponents,
-    getViewsDirAbs,
-    testIdAttribute,
-    loggerRef,
-    scanDirs,
-    getWrapperSearchRoots: getWrapperSearchRootsAbs,
-    getProjectRoot: () => projectRootRef.current
-  });
   const configPlugin = {
     name: "vue-pom-generator-config",
     enforce: "pre",
-    configResolved(config) {
+    async configResolved(config) {
       projectRootRef.current = config.root;
       loggerRef.current = createLogger({ verbosity, viteLogger: config.logger });
+      if (vueGenerationOptions?.router?.type === "nuxt") {
+        throw new Error('[vue-pom-generator] Remove generation.router.type="nuxt". Nuxt projects are auto-detected.');
+      }
+      if (isNuxt) {
+        const nuxtDiscovery = await loadNuxtProjectDiscovery(process.cwd());
+        projectRootRef.current = nuxtDiscovery.rootDir;
+        pageDirsRef.current = nuxtDiscovery.pageDirs.length ? nuxtDiscovery.pageDirs : [path.resolve(nuxtDiscovery.srcDir, "pages")];
+        componentDirsRef.current = nuxtDiscovery.componentDirs;
+        layoutDirsRef.current = nuxtDiscovery.layoutDirs;
+        wrapperSearchRootsRef.current = nuxtDiscovery.wrapperSearchRoots;
+      }
       assertNonEmptyString(testIdAttribute, "[vue-pom-generator] injection.attribute");
-      assertNonEmptyString(viewsDir, "[vue-pom-generator] injection.viewsDir");
-      assertNonEmptyStringArray(wrapperSearchRoots, "[vue-pom-generator] injection.wrapperSearchRoots");
+      assertNonEmptyString(getViewsDir(), "[vue-pom-generator] injection.viewsDir");
+      assertNonEmptyStringArray(getComponentDirs(), "[vue-pom-generator] injection.componentDirs");
+      assertNonEmptyStringArray(getLayoutDirs(), "[vue-pom-generator] injection.layoutDirs");
+      assertNonEmptyStringArray(getWrapperSearchRoots(), "[vue-pom-generator] injection.wrapperSearchRoots");
       assertErrorBehavior(errorBehavior, "[vue-pom-generator] errorBehavior");
       if (generationEnabled) {
         assertNonEmptyString(outDir, "[vue-pom-generator] generation.outDir");
         assertOneOf(typescriptOutputStructure, ["aggregated", "split"], "[vue-pom-generator] generation.playwright.outputStructure");
         assertRouterModuleShims(routerModuleShims, "[vue-pom-generator] generation.router.moduleShims");
-        if (generationOptions?.router && routerType === "vue-router") {
+        if (!isNuxt && vueGenerationOptions?.router && routerType === "vue-router") {
           assertNonEmptyString(routerEntry, "[vue-pom-generator] generation.router.entry");
         }
       }
       if (usesExternalVuePlugin) {
-        applyTemplateCompilerOptionsToResolvedVuePlugin(config, templateCompilerOptions, isNuxt ? "nuxt" : vuePluginOwnership);
+        applyTemplateCompilerOptionsToResolvedVuePlugin(
+          config,
+          templateCompilerOptionsForResolvedPlugin,
+          isNuxt ? "nuxt" : vuePluginOwnership
+        );
       }
       loggerRef.current.info(`projectRoot=${projectRootRef.current}`);
+      loggerRef.current.info(`viewsDir=${getViewsDir()}`);
+      loggerRef.current.info(`componentDirs=${getComponentDirs().join(", ")}`);
+      loggerRef.current.info(`layoutDirs=${getLayoutDirs().join(", ")}`);
       loggerRef.current.info(`Active plugins: ${(config.plugins ?? []).map((p) => p.name).filter((n) => n.includes("vue-pom")).join(", ")}`);
     }
   };
+  const getViewsDirAbs = () => resolveFromProjectRoot(projectRootRef.current, getViewsDir());
+  const getWrapperSearchRootsAbs = () => getWrapperSearchRoots().map((root) => resolveFromProjectRoot(projectRootRef.current, root));
+  const { componentTestIds, elementMetadata, semanticNameMap, componentHierarchyMap, vueFilesPathMap } = sharedState;
+  const { metadataCollectorPlugin, internalVuePlugin, templateCompilerOptions } = createVuePluginWithTestIds({
+    vueOptions,
+    existingIdBehavior,
+    nameCollisionBehavior,
+    nativeWrappers,
+    elementMetadata,
+    semanticNameMap,
+    componentHierarchyMap,
+    vueFilesPathMap,
+    excludedComponents,
+    getViewsDirAbs,
+    testIdAttribute,
+    loggerRef,
+    getSourceDirs,
+    getWrapperSearchRoots: getWrapperSearchRootsAbs,
+    getProjectRoot: () => projectRootRef.current
+  });
+  templateCompilerOptionsForResolvedPlugin = templateCompilerOptions;
   const routerAwarePoms = typeof routerEntry === "string" && routerEntry.trim().length > 0 || routerType === "nuxt";
   const supportPlugins = createSupportPlugins({
     componentTestIds,
@@ -8070,8 +8609,11 @@ function createVuePomGeneratorPlugins(options = {}) {
     vueFilesPathMap,
     nativeWrappers,
     excludedComponents,
-    viewsDir,
-    scanDirs,
+    getPageDirs,
+    getComponentDirs,
+    getLayoutDirs,
+    getViewsDir,
+    getSourceDirs,
     getWrapperSearchRoots: getWrapperSearchRootsAbs,
     nameCollisionBehavior,
     missingSemanticNameBehavior,
@@ -8116,11 +8658,21 @@ function createVuePomGeneratorPlugins(options = {}) {
   }
   return resultPlugins;
 }
+const nuxtConfigMarker = /* @__PURE__ */ Symbol.for("@immense/vue-pom-generator.nuxt");
 function defineVuePomGeneratorConfig(options) {
   return options;
 }
+function defineNuxtPomGeneratorConfig(options) {
+  const markedOptions = { ...options };
+  Object.defineProperty(markedOptions, nuxtConfigMarker, {
+    value: true,
+    enumerable: false
+  });
+  return markedOptions;
+}
 exports.createVuePomGeneratorPlugins = createVuePomGeneratorPlugins;
 exports.default = createVuePomGeneratorPlugins;
+exports.defineNuxtPomGeneratorConfig = defineNuxtPomGeneratorConfig;
 exports.defineVuePomGeneratorConfig = defineVuePomGeneratorConfig;
 exports.vuePomGenerator = createVuePomGeneratorPlugins;
 //# sourceMappingURL=index.cjs.map