@dudousxd/nestjs-codegen 0.10.0 → 0.12.0

package/dist/cli/main.js

@@ -183,8 +183,8 @@ Run \`nestjs-codegen init\` to create a starter config.`
 }
 
 // src/generate.ts
-import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname2, join as join12 } from "path";
+import { mkdir as mkdir9, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname2, join as join13 } from "path";
 
 // src/discovery/pages.ts
 import { readFile } from "fs/promises";
@@ -798,7 +798,11 @@ function buildRequestModel(c) {
     urlExpr,
     optsExpr,
     responseType: `${TA}['response']`,
-    queryKeyExpr: `[${flat}, input] as const`
+    // When no input is supplied the key omits the trailing element entirely
+    // (`[name]` rather than `[name, undefined]`) so the bare `.queryKey()` is a
+    // clean prefix that partial-matches every parametrized variant — making it
+    // directly usable for `invalidateQueries`.
+    queryKeyExpr: `(input === undefined ? [${flat}] as const : [${flat}, input] as const)`
   };
 }
 function renderFetcherRequest(req) {
@@ -2075,6 +2079,99 @@ function buildEmpty() {
   ].join("\n");
 }
 
+// src/generate-manifest.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, readdir, writeFile as writeFile9 } from "fs/promises";
+import { join as join12, relative as relative6 } from "path";
+import fg2 from "fast-glob";
+var MANIFEST_FILE = ".codegen-manifest.json";
+var LOCK_FILE = ".watcher.lock";
+function isManifestShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (typeof candidate.version !== "string") return false;
+  if (typeof candidate.hash !== "string") return false;
+  if (!Array.isArray(candidate.files)) return false;
+  return candidate.files.every((entry) => typeof entry === "string");
+}
+function serializeConfig(config) {
+  try {
+    return JSON.stringify(config, (_key, value) => {
+      if (typeof value === "function") return `[fn:${value.name}]${value.toString()}`;
+      return value;
+    });
+  } catch {
+    return `unserializable:${config.codegen.outDir}:${config.contracts.glob}`;
+  }
+}
+async function discoverInputFiles(config) {
+  const globs = [config.contracts.glob, config.forms.watch];
+  if (config.pages) globs.push(config.pages.glob);
+  const cwd = config.codegen.cwd;
+  const matched = await fg2(globs, { cwd, absolute: true, onlyFiles: true });
+  return [...new Set(matched)].sort();
+}
+async function computeInputsHash(config) {
+  const hash = createHash("sha256");
+  hash.update(`version:${VERSION}
+`);
+  hash.update(`config:${serializeConfig(config)}
+`);
+  const inputFiles = await discoverInputFiles(config);
+  const cwd = config.codegen.cwd;
+  for (const file of inputFiles) {
+    const contents = await readFile2(file, "utf8");
+    hash.update(`file:${relative6(cwd, file)}
+`);
+    hash.update(contents);
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+async function readManifest(outDir) {
+  try {
+    const raw = await readFile2(join12(outDir, MANIFEST_FILE), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isManifestShape(parsed)) return null;
+    return { version: parsed.version, hash: parsed.hash, files: parsed.files };
+  } catch {
+    return null;
+  }
+}
+async function writeManifest(outDir, manifest) {
+  await writeFile9(join12(outDir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+async function listOutputFiles(outDir) {
+  const found = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      const abs = join12(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+      } else if (entry.isFile()) {
+        const rel = relative6(outDir, abs);
+        if (rel === MANIFEST_FILE || rel === LOCK_FILE) continue;
+        found.push(rel);
+      }
+    }
+  }
+  await walk(outDir);
+  return found.sort();
+}
+async function allOutputsExist(outDir, files) {
+  const present = new Set(await listOutputFiles(outDir));
+  return files.every((file) => present.has(file));
+}
+async function isManifestFresh(outDir, manifest, inputsHash) {
+  if (manifest === null) return false;
+  if (manifest.version !== VERSION) return false;
+  if (manifest.hash !== inputsHash) return false;
+  if (manifest.files.length === 0) return false;
+  return allOutputsExist(outDir, manifest.files);
+}
+
 // src/util/debug-log.ts
 var debugEnabled = false;
 function setCodegenDebug(enabled) {
@@ -2087,6 +2184,12 @@ function debugWarn(message) {
 // src/generate.ts
 async function generate(config, inputRoutes = []) {
   setCodegenDebug(config.debug);
+  const inputsHash = await computeInputsHash(config);
+  const manifest = await readManifest(config.codegen.outDir);
+  if (await isManifestFresh(config.codegen.outDir, manifest, inputsHash)) {
+    console.log(`[nestjs-codegen] ${config.codegen.outDir} up to date, skipped`);
+    return;
+  }
   const extensions = config.extensions ?? [];
   let routes = inputRoutes;
   const ctx = createExtensionContext(config, () => routes);
@@ -2143,21 +2246,27 @@ async function generate(config, inputRoutes = []) {
   if (extensions.length > 0) {
     const extraFiles = await collectEmittedFiles(extensions, ctx);
     for (const file of extraFiles) {
-      const dest = join12(config.codegen.outDir, file.path);
+      const dest = join13(config.codegen.outDir, file.path);
       await mkdir9(dirname2(dest), { recursive: true });
-      await writeFile9(dest, file.contents, "utf8");
+      await writeFile10(dest, file.contents, "utf8");
     }
   }
+  const outputFiles = await listOutputFiles(config.codegen.outDir);
+  await writeManifest(config.codegen.outDir, {
+    version: VERSION,
+    hash: inputsHash,
+    files: outputFiles
+  });
 }
 
 // src/watch/watcher.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join16 } from "path";
 import chokidar from "chokidar";
 
 // src/discovery/contracts-fast.ts
-import { join as join13, resolve as resolve3 } from "path";
-import fg2 from "fast-glob";
+import { join as join14, resolve as resolve3 } from "path";
+import fg3 from "fast-glob";
 import {
   Node as Node8,
   Project as Project3
@@ -3934,7 +4043,7 @@ async function discoverContractsFast(opts) {
   const { cwd, glob, tsconfig } = opts;
   const tsconfigPath = resolveTsconfigPath(cwd, tsconfig);
   const project = createDiscoveryProject(tsconfigPath);
-  const files = await fg2(glob, { cwd, absolute: true, onlyFiles: true });
+  const files = await fg3(glob, { cwd, absolute: true, onlyFiles: true });
   for (const f of files) {
     project.addSourceFileAtPath(f);
   }
@@ -3942,7 +4051,7 @@ async function discoverContractsFast(opts) {
   return extractAllRoutes(project);
 }
 function resolveTsconfigPath(cwd, tsconfig) {
-  return tsconfig ? resolve3(tsconfig) : join13(cwd, "tsconfig.json");
+  return tsconfig ? resolve3(tsconfig) : join14(cwd, "tsconfig.json");
 }
 function createDiscoveryProject(tsconfigPath) {
   try {
@@ -4007,7 +4116,7 @@ var PersistentDiscovery = class _PersistentDiscovery {
     const project = createDiscoveryProject(tsconfigPath);
     bindDiscoveryContext(project, cwd, tsconfigPath);
     const instance = new _PersistentDiscovery(project, cwd, glob);
-    const files = await fg2(glob, { cwd, absolute: true, onlyFiles: true });
+    const files = await fg3(glob, { cwd, absolute: true, onlyFiles: true });
     for (const f of files) {
       project.addSourceFileAtPath(f);
       instance.controllerPaths.add(f);
@@ -4036,7 +4145,7 @@ var PersistentDiscovery = class _PersistentDiscovery {
       }
     }
     const globbed = new Set(
-      await fg2(this.glob, { cwd: this.cwd, absolute: true, onlyFiles: true })
+      await fg3(this.glob, { cwd: this.cwd, absolute: true, onlyFiles: true })
     );
     for (const f of globbed) {
       if (!this.controllerPaths.has(f)) {
@@ -4317,9 +4426,9 @@ function extractFromSourceFile(sourceFile, project) {
 
 // src/watch/lock-file.ts
 import { open } from "fs/promises";
-import { mkdir as mkdir10, readFile as readFile2, unlink } from "fs/promises";
-import { join as join14 } from "path";
-var LOCK_FILE = ".watcher.lock";
+import { mkdir as mkdir10, readFile as readFile3, unlink } from "fs/promises";
+import { join as join15 } from "path";
+var LOCK_FILE2 = ".watcher.lock";
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -4330,7 +4439,7 @@ function isProcessAlive(pid) {
 }
 async function acquireLock(outDir) {
   await mkdir10(outDir, { recursive: true });
-  const lockPath = join14(outDir, LOCK_FILE);
+  const lockPath = join15(outDir, LOCK_FILE2);
   const lockData = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   try {
     const fd = await open(lockPath, "wx");
@@ -4340,7 +4449,7 @@ async function acquireLock(outDir) {
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const raw = await readFile2(lockPath, "utf8");
+        const raw = await readFile3(lockPath, "utf8");
         const existing = JSON.parse(raw);
         if (isProcessAlive(existing.pid)) return null;
         await unlink(lockPath);
@@ -4365,12 +4474,12 @@ async function acquireLock(outDir) {
 var PAGES_DEBOUNCE_MS = 150;
 var NO_OP_WATCHER = { close: async () => {
 } };
-async function watch(config, onChange) {
+async function watch(config, onChange, options = {}) {
   const lock = await acquireLock(config.codegen.outDir);
   if (lock === null) {
     let holderPid = "unknown";
     try {
-      const raw = await readFile3(join15(config.codegen.outDir, ".watcher.lock"), "utf8");
+      const raw = await readFile4(join16(config.codegen.outDir, ".watcher.lock"), "utf8");
       const data = JSON.parse(raw);
       if (data.pid !== void 0) holderPid = String(data.pid);
     } catch {
@@ -4393,22 +4502,33 @@ async function watch(config, onChange) {
     }
     return discovery;
   }
-  try {
-    const initialRoutes = (await getDiscovery()).discover();
-    lastRoutes = initialRoutes;
-    await generate(config, initialRoutes);
-  } catch (err) {
-    console.warn(
-      `[nestjs-codegen] Initial route discovery failed, falling back to pages-only: ${err instanceof Error ? err.message : String(err)}`
-    );
+  async function runInitialPass() {
     try {
-      await generate(config, lastRoutes);
-    } catch {
+      const initialRoutes = (await getDiscovery()).discover();
+      lastRoutes = initialRoutes;
+      await generate(config, initialRoutes);
+    } catch (err) {
+      console.warn(
+        `[nestjs-codegen] Initial route discovery failed, falling back to pages-only: ${err instanceof Error ? err.message : String(err)}`
+      );
+      try {
+        await generate(config, lastRoutes);
+      } catch {
+      }
     }
   }
+  if (options.deferInitialGenerate) {
+    void runInitialPass().catch((err) => {
+      console.warn(
+        `[nestjs-codegen] Background initial generate failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  } else {
+    await runInitialPass();
+  }
   let pagesDebounceTimer;
   const pagesGlob = config.pages?.glob ?? ".nestjs-codegen-no-pages";
-  const pagesWatcher = chokidar.watch(join15(config.codegen.cwd, pagesGlob), {
+  const pagesWatcher = chokidar.watch(join16(config.codegen.cwd, pagesGlob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4435,7 +4555,7 @@ async function watch(config, onChange) {
   pagesWatcher.on("unlink", schedulePagesRegenerate);
   let contractsDebounceTimer;
   const pendingChangedPaths = /* @__PURE__ */ new Set();
-  const contractsWatcher = chokidar.watch(join15(config.codegen.cwd, config.contracts.glob), {
+  const contractsWatcher = chokidar.watch(join16(config.codegen.cwd, config.contracts.glob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4465,7 +4585,7 @@ async function watch(config, onChange) {
   contractsWatcher.on("add", (p) => scheduleContractsRegenerate(p));
   contractsWatcher.on("change", (p) => scheduleContractsRegenerate(p));
   contractsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p));
-  const formsWatcher = chokidar.watch(join15(config.codegen.cwd, config.forms.watch), {
+  const formsWatcher = chokidar.watch(join16(config.codegen.cwd, config.forms.watch), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -4492,7 +4612,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.10.0";
+var VERSION = "0.12.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -4521,13 +4641,13 @@ async function runCodegen(opts = {}) {
 // src/cli/doctor.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { appendFileSync, existsSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/cli/init.ts
 import { execFileSync } from "child_process";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { access as access2, mkdir as mkdir11, readFile as readFile4, writeFile as writeFile10 } from "fs/promises";
-import { join as join16 } from "path";
+import { access as access2, mkdir as mkdir11, readFile as readFile5, writeFile as writeFile11 } from "fs/promises";
+import { join as join17 } from "path";
 import { createInterface } from "readline";
 
 // src/cli/patch-utils.ts
@@ -4589,7 +4709,7 @@ ${bold(title)}`);
 }
 async function readPackageJson(cwd) {
   try {
-    const raw = await readFile4(join16(cwd, "package.json"), "utf8");
+    const raw = await readFile5(join17(cwd, "package.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -4620,7 +4740,7 @@ async function detectTemplateEngine(cwd) {
 async function detectPackageManager(cwd) {
   async function exists(file) {
     try {
-      await access2(join16(cwd, file));
+      await access2(join17(cwd, file));
       return true;
     } catch {
       return false;
@@ -4663,13 +4783,13 @@ async function writeIfNotExists(filePath, content, label) {
   if (dir) {
     await mkdir11(dir, { recursive: true });
   }
-  await writeFile10(filePath, content, "utf8");
+  await writeFile11(filePath, content, "utf8");
   logCreated(label);
 }
 async function handleViteConfig(cwd, framework) {
-  const filePath = join16(cwd, "vite.config.ts");
+  const filePath = join17(cwd, "vite.config.ts");
   if (await fileExists2(filePath)) {
-    const existing = await readFile4(filePath, "utf8");
+    const existing = await readFile5(filePath, "utf8");
     const hasPlugin = existing.includes("nestInertia") || existing.includes("nestjs-inertia-vite/plugin");
     if (!hasPlugin) {
       logSkipped("vite.config.ts");
@@ -4687,13 +4807,13 @@ async function handleViteConfig(cwd, framework) {
   if (dir) {
     await mkdir11(dir, { recursive: true });
   }
-  await writeFile10(filePath, viteConfigTemplate(framework), "utf8");
+  await writeFile11(filePath, viteConfigTemplate(framework), "utf8");
   logCreated("vite.config.ts");
 }
 async function patchGitignore(gitignorePath) {
   let existing = "";
   if (await fileExists2(gitignorePath)) {
-    existing = await readFile4(gitignorePath, "utf8");
+    existing = await readFile5(gitignorePath, "utf8");
   }
   if (existing.split("\n").some((line) => line.trim() === GITIGNORE_ENTRY)) {
     console.log(`  ${cyan("\u2192")} .gitignore ${dim("(already contains .nestjs-inertia/, skipped)")}`);
@@ -4703,7 +4823,7 @@ async function patchGitignore(gitignorePath) {
 ` : `${existing}
 ${GITIGNORE_ENTRY}
 `;
-  await writeFile10(gitignorePath, newContent, "utf8");
+  await writeFile11(gitignorePath, newContent, "utf8");
   logPatched(".gitignore", "added .nestjs-inertia/");
 }
 function installDeps(pkgManager, deps, dev) {
@@ -4725,10 +4845,10 @@ function installDeps(pkgManager, deps, dev) {
   }
 }
 async function patchPackageJsonScripts(cwd, scripts) {
-  const pkgPath = join16(cwd, "package.json");
+  const pkgPath = join17(cwd, "package.json");
   let pkg = {};
   try {
-    pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+    pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
   } catch {
     return;
   }
@@ -4747,7 +4867,7 @@ async function patchPackageJsonScripts(cwd, scripts) {
     return;
   }
   pkg.scripts = existing;
-  await writeFile10(pkgPath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile11(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
 }
 function patchAppModule(filePath, rootView) {
@@ -5042,7 +5162,7 @@ export class HomeController {
 }
 `;
 function patchTsconfigExclude(cwd, dir, filename = "tsconfig.json") {
-  const filePath = join16(cwd, filename);
+  const filePath = join17(cwd, filename);
   return patchJsonFile(
     filePath,
     (json) => {
@@ -5057,7 +5177,7 @@ function patchTsconfigExclude(cwd, dir, filename = "tsconfig.json") {
   );
 }
 function patchNestCliJson(cwd, shellDir) {
-  const filePath = join16(cwd, "nest-cli.json");
+  const filePath = join17(cwd, "nest-cli.json");
   return patchJsonFile(filePath, (json) => {
     const compiler = json.compilerOptions ?? {};
     const assets = compiler.assets ?? [];
@@ -5080,46 +5200,46 @@ async function scaffoldFiles(ctx) {
   const { cwd, framework, engine, shellFileName, entryExt, pageExt } = ctx;
   logSection("Scaffold files");
   await writeIfNotExists(
-    join16(cwd, "nestjs-inertia.config.ts"),
+    join17(cwd, "nestjs-inertia.config.ts"),
     configTemplate(framework),
     "nestjs-inertia.config.ts"
   );
-  await writeIfNotExists(join16(cwd, "nestjs-inertia.d.ts"), DTS_TEMPLATE, "nestjs-inertia.d.ts");
+  await writeIfNotExists(join17(cwd, "nestjs-inertia.d.ts"), DTS_TEMPLATE, "nestjs-inertia.d.ts");
   await writeIfNotExists(
-    join16(cwd, "tsconfig.inertia.json"),
+    join17(cwd, "tsconfig.inertia.json"),
     TSCONFIG_INERTIA_TEMPLATE,
     "tsconfig.inertia.json"
   );
   await writeIfNotExists(
-    join16(cwd, "inertia", "tsconfig.json"),
+    join17(cwd, "inertia", "tsconfig.json"),
     INERTIA_TSCONFIG_TEMPLATE,
     "inertia/tsconfig.json"
   );
   await writeIfNotExists(
-    join16(cwd, "inertia", shellFileName),
+    join17(cwd, "inertia", shellFileName),
     htmlShellTemplate(framework, engine),
     `inertia/${shellFileName}`
   );
   await handleViteConfig(cwd, framework);
   await writeIfNotExists(
-    join16(cwd, "inertia", "app", `client.${entryExt}`),
+    join17(cwd, "inertia", "app", `client.${entryExt}`),
     entryPointTemplate(framework),
     `inertia/app/client.${entryExt}`
   );
   await writeIfNotExists(
-    join16(cwd, "inertia", "pages", `Home.${pageExt}`),
+    join17(cwd, "inertia", "pages", `Home.${pageExt}`),
     samplePageTemplate(framework),
     `inertia/pages/Home.${pageExt}`
   );
   await writeIfNotExists(
-    join16(cwd, "src", "home.controller.ts"),
+    join17(cwd, "src", "home.controller.ts"),
     SAMPLE_CONTROLLER,
     "src/home.controller.ts"
   );
 }
 function patchServerAppModule(ctx) {
   const { cwd, rootView } = ctx;
-  const appModulePath = join16(cwd, "src", "app.module.ts");
+  const appModulePath = join17(cwd, "src", "app.module.ts");
   const appModuleResult = patchAppModule(appModulePath, rootView);
   if (appModuleResult === "patched") {
     logPatched("src/app.module.ts", "added InertiaModule.forRoot");
@@ -5133,7 +5253,7 @@ function patchServerAppModule(ctx) {
   }
 }
 function patchServerMainTs(ctx) {
-  const mainTsPath = join16(ctx.cwd, "src", "main.ts");
+  const mainTsPath = join17(ctx.cwd, "src", "main.ts");
   const mainTsResult = patchMainTs(mainTsPath);
   if (mainTsResult === "patched") {
     logPatched("src/main.ts", "added setupInertiaVite after NestFactory.create");
@@ -5168,7 +5288,7 @@ function patchBuildConfigs(ctx) {
 }
 async function patchGitignoreAndDist(ctx) {
   const { cwd } = ctx;
-  await patchGitignore(join16(cwd, ".gitignore"));
+  await patchGitignore(join17(cwd, ".gitignore"));
   const tsconfigDistResult = patchTsconfigExclude(cwd, "dist", "tsconfig.json");
   if (tsconfigDistResult === "patched") {
     logPatched("tsconfig.json", "excluded dist/ from server compilation");
@@ -5274,7 +5394,7 @@ ${green("\u2713")} Setup complete! Run: ${bold("nest start --watch")}
 
 // src/cli/doctor.ts
 function checkFileExists(cwd, file) {
-  return existsSync(join17(cwd, file));
+  return existsSync(join18(cwd, file));
 }
 function readJson(path) {
   try {
@@ -5310,15 +5430,15 @@ function writeJsonField(filePath, dotPath, value) {
 }
 function getPackageVersion(cwd, pkg) {
   try {
-    const pkgJson = readJson(join17(cwd, "node_modules", pkg, "package.json"));
+    const pkgJson = readJson(join18(cwd, "node_modules", pkg, "package.json"));
     return pkgJson?.version ?? null;
   } catch {
     return null;
   }
 }
 function detectPkgManager(cwd) {
-  if (existsSync(join17(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join17(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join18(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join18(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function runDoctor(opts) {
@@ -5356,7 +5476,7 @@ async function runDoctor(opts) {
     autoFix: () => runInit({ cwd })
   });
   if (foundShellDir) {
-    const nestCliPath = join17(cwd, "nest-cli.json");
+    const nestCliPath = join18(cwd, "nest-cli.json");
     const nestCli = readJson(nestCliPath);
     const compiler = nestCli?.compilerOptions ?? {};
     const assets = compiler.assets ?? [];
@@ -5395,7 +5515,7 @@ async function runDoctor(opts) {
     fix: "Run: nestjs-codegen codegen",
     autoFix: () => runCodegen({ cwd })
   });
-  const tsconfigPath = join17(cwd, "tsconfig.json");
+  const tsconfigPath = join18(cwd, "tsconfig.json");
   const tsconfig = readJson(tsconfigPath);
   const paths = tsconfig?.compilerOptions?.paths;
   checks.push({
@@ -5406,7 +5526,7 @@ async function runDoctor(opts) {
   });
   const inertiaDir = foundShellDir ?? "inertia";
   for (const tsconfigFile of ["tsconfig.json", "tsconfig.build.json"]) {
-    const tsc = readJson(join17(cwd, tsconfigFile));
+    const tsc = readJson(join18(cwd, tsconfigFile));
     if (!tsc) continue;
     const excl = tsc.exclude ?? [];
     const excludesIt = excl.includes(inertiaDir);
@@ -5432,7 +5552,7 @@ async function runDoctor(opts) {
       }
     });
   }
-  const inertiaTsconfigPath = join17(cwd, "tsconfig.inertia.json");
+  const inertiaTsconfigPath = join18(cwd, "tsconfig.inertia.json");
   const inertiaTsconfig = readJson(inertiaTsconfigPath);
   checks.push({
     name: "tsconfig.inertia.json exists",
@@ -5484,7 +5604,7 @@ async function runDoctor(opts) {
       fix: 'Add "nestjs-inertia.d.ts" to include array (resolves InertiaRegistry augmentation)'
     });
   }
-  const innerTsconfigPath = join17(cwd, "inertia", "tsconfig.json");
+  const innerTsconfigPath = join18(cwd, "inertia", "tsconfig.json");
   checks.push({
     name: "inertia/tsconfig.json exists (VSCode picks up ~codegen alias)",
     pass: existsSync(innerTsconfigPath),
@@ -5494,7 +5614,7 @@ async function runDoctor(opts) {
     }
   });
   if (checkFileExists(cwd, "vite.config.ts")) {
-    const viteContent = readFileSync4(join17(cwd, "vite.config.ts"), "utf8");
+    const viteContent = readFileSync4(join18(cwd, "vite.config.ts"), "utf8");
     checks.push({
       name: "vite.config.ts has resolve.alias",
       pass: viteContent.includes("resolve") && viteContent.includes("alias"),
@@ -5559,7 +5679,7 @@ async function runDoctor(opts) {
     });
   }
   if (checkFileExists(cwd, ".gitignore")) {
-    const gitignorePath = join17(cwd, ".gitignore");
+    const gitignorePath = join18(cwd, ".gitignore");
     const gitignore = readFileSync4(gitignorePath, "utf8");
     checks.push({
       name: ".gitignore includes .nestjs-inertia/",
@@ -5568,7 +5688,7 @@ async function runDoctor(opts) {
       autoFix: () => appendFileSync(gitignorePath, "\n.nestjs-inertia/\n")
     });
   }
-  const pkgJsonPath = join17(cwd, "package.json");
+  const pkgJsonPath = join18(cwd, "package.json");
   const pkgJson = readJson(pkgJsonPath);
   const scripts = pkgJson?.scripts ?? {};
   checks.push({