@dudousxd/nestjs-inertia-codegen 1.0.0

package/dist/cli/main.cjs

@@ -0,0 +1,1950 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/main.ts
+var main_exports = {};
+__export(main_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(main_exports);
+var import_cac = require("cac");
+
+// src/config/load-config.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_url = require("url");
+
+// src/exceptions.ts
+var ConfigError = class extends Error {
+  static {
+    __name(this, "ConfigError");
+  }
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigError";
+  }
+};
+
+// src/config/load-config.ts
+var CONFIG_FILE = "nestjs-inertia.config.ts";
+async function fileExists(filePath) {
+  try {
+    await (0, import_promises.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(fileExists, "fileExists");
+async function importTs(filePath) {
+  let tsImport;
+  try {
+    const tsxEsm = await import("tsx/esm/api");
+    tsImport = tsxEsm.tsImport;
+  } catch {
+    throw new ConfigError("Failed to load config: `tsx` is required for loading TypeScript config files. Install it as a dev dependency: pnpm add -D tsx");
+  }
+  const parentURL = (0, import_node_url.pathToFileURL)(`${filePath}__parent__`).href;
+  const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+  return tsImport(fileUrl, {
+    parentURL
+  });
+}
+__name(importTs, "importTs");
+function resolveAbsolute(cwd, p) {
+  if ((0, import_node_path.isAbsolute)(p)) return p;
+  return (0, import_node_path.resolve)(cwd, p);
+}
+__name(resolveAbsolute, "resolveAbsolute");
+function assertInsideCwd(cwd, resolvedPath, fieldName) {
+  const rel = (0, import_node_path.relative)(cwd, resolvedPath);
+  if (rel.startsWith(`..${import_node_path.sep}`) || rel === ".." || (0, import_node_path.isAbsolute)(rel)) {
+    throw new ConfigError(`\`${fieldName}\` must be inside the project cwd.
+  Resolved to: ${resolvedPath}
+  Project cwd: ${cwd}
+If this is intentional, move the file inside your project directory.`);
+  }
+}
+__name(assertInsideCwd, "assertInsideCwd");
+function applyDefaults(userConfig, cwd) {
+  const outDir = userConfig.codegen?.outDir ? resolveAbsolute(cwd, userConfig.codegen.outDir) : (0, import_node_path.join)(cwd, ".nestjs-inertia");
+  const resolvedCwd = userConfig.codegen?.cwd ? resolveAbsolute(cwd, userConfig.codegen.cwd) : cwd;
+  let app = null;
+  if (userConfig.app) {
+    const resolvedEntry = resolveAbsolute(cwd, userConfig.app.moduleEntry);
+    assertInsideCwd(cwd, resolvedEntry, "app.moduleEntry");
+    let resolvedTsconfig = null;
+    if (userConfig.app.tsconfig) {
+      resolvedTsconfig = resolveAbsolute(cwd, userConfig.app.tsconfig);
+      assertInsideCwd(cwd, resolvedTsconfig, "app.tsconfig");
+    }
+    app = {
+      moduleEntry: resolvedEntry,
+      tsconfig: resolvedTsconfig
+    };
+  }
+  return {
+    pages: {
+      glob: userConfig.pages.glob,
+      propsExport: userConfig.pages.propsExport ?? "ComponentProps",
+      componentNameStrategy: userConfig.pages.componentNameStrategy ?? "relative-no-ext"
+    },
+    contracts: {
+      glob: userConfig.contracts?.glob ?? "src/**/*.controller.ts",
+      debounceMs: userConfig.contracts?.debounceMs ?? 500
+    },
+    scopes: userConfig.scopes ?? {},
+    codegen: {
+      outDir,
+      cwd: resolvedCwd
+    },
+    app
+  };
+}
+__name(applyDefaults, "applyDefaults");
+async function loadConfig(cwd) {
+  const resolvedCwd = cwd ?? process.cwd();
+  const configPath = (0, import_node_path.join)(resolvedCwd, CONFIG_FILE);
+  if (!await fileExists(configPath)) {
+    throw new ConfigError(`Config file not found: ${configPath}
+Run \`nestjs-inertia init\` to create a starter config.`);
+  }
+  let mod;
+  try {
+    mod = await importTs(configPath);
+  } catch (err) {
+    if (err instanceof ConfigError) throw err;
+    throw new ConfigError(`Failed to load config from ${configPath}`, {
+      cause: err
+    });
+  }
+  const modNs = mod.default;
+  const userConfig = modNs != null && typeof modNs === "object" && "default" in modNs ? modNs.default : modNs;
+  if (!userConfig || typeof userConfig !== "object") {
+    throw new ConfigError(`Config file must have a default export. Did you forget \`export default defineConfig({...})\`? (${configPath})`);
+  }
+  if (!userConfig.pages || typeof userConfig.pages.glob !== "string") {
+    throw new ConfigError(`Config validation failed: \`pages.glob\` is required (${configPath})`);
+  }
+  return applyDefaults(userConfig, resolvedCwd);
+}
+__name(loadConfig, "loadConfig");
+
+// src/discovery/pages.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+async function discoverPages(opts) {
+  const files = await (0, import_fast_glob.default)(opts.glob, {
+    cwd: opts.cwd,
+    absolute: true
+  });
+  files.sort();
+  const out = [];
+  for (const file of files) {
+    const rel = (0, import_node_path2.relative)(opts.cwd, file);
+    const name = computeName(rel, opts.componentNameStrategy);
+    const source = await (0, import_promises2.readFile)(file, "utf8");
+    const propsSource = extractPropsSource(source, opts.propsExport);
+    out.push({
+      name,
+      absolutePath: file,
+      relativePath: rel,
+      propsSource
+    });
+  }
+  return out;
+}
+__name(discoverPages, "discoverPages");
+function computeName(rel, strat) {
+  if (typeof strat === "function") return strat(rel);
+  const noExt = rel.replace(/\.(tsx?|vue|svelte)$/, "");
+  if (strat === "kebab") return noExt.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  return noExt;
+}
+__name(computeName, "computeName");
+function extractPropsSource(source, exportName) {
+  const re = new RegExp(`export\\s+type\\s+${exportName}\\s*=\\s*`, "m");
+  const m = source.match(re);
+  if (!m) return null;
+  const start = m.index + m[0].length;
+  let i = start;
+  let depth = 0;
+  let started = false;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "{") {
+      depth++;
+      started = true;
+    } else if (c === "}") {
+      depth--;
+      if (started && depth === 0) {
+        return source.slice(start, i + 1);
+      }
+    } else if (c === ";" && !started) return source.slice(start, i);
+    i++;
+  }
+  return source.slice(start);
+}
+__name(extractPropsSource, "extractPropsSource");
+
+// src/emit/emit-api.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+async function emitApi(routes, outDir) {
+  await (0, import_promises3.mkdir)(outDir, {
+    recursive: true
+  });
+  const content = buildApiFile(routes);
+  await (0, import_promises3.writeFile)((0, import_node_path3.join)(outDir, "api.ts"), content, "utf8");
+}
+__name(emitApi, "emitApi");
+function splitName(name) {
+  return name.split(".");
+}
+__name(splitName, "splitName");
+function toObjectKey(segment) {
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
+    return segment;
+  }
+  return JSON.stringify(segment);
+}
+__name(toObjectKey, "toObjectKey");
+function toCamelCase(s) {
+  return s.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word, i) => i === 0 ? word.charAt(0).toLowerCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+__name(toCamelCase, "toCamelCase");
+function validateNameSegment(seg, fullName) {
+  if (!/^[a-z][a-zA-Z0-9]*$/.test(seg)) {
+    const suggested = toCamelCase(seg);
+    throw new Error(`Contract name "${fullName}" has invalid segment "${seg}". Use camelCase identifiers only (lowercase letter then alphanumeric). Suggested: "${suggested}"`);
+  }
+}
+__name(validateNameSegment, "validateNameSegment");
+function detectCollisions(tree, name) {
+  for (const [key, node] of tree) {
+    if (node.kind === "leaf") {
+    } else {
+      void key;
+    }
+  }
+  void name;
+}
+__name(detectCollisions, "detectCollisions");
+function insertIntoTree(tree, segments, leaf, fullName) {
+  const head = segments[0];
+  const rest = segments.slice(1);
+  if (rest.length === 0) {
+    const existing = tree.get(head);
+    if (existing !== void 0 && existing.kind === "branch") {
+      throw new Error(`Contract name conflict: "${fullName}" cannot have both a direct entry and child entries`);
+    }
+    tree.set(head, leaf);
+  } else {
+    const existing = tree.get(head);
+    if (existing !== void 0 && existing.kind === "leaf") {
+      const prefixName = fullName.split(".").slice(0, segments.length - rest.length).join(".");
+      throw new Error(`Contract name conflict: "${prefixName}" cannot have both a direct entry and child entries`);
+    }
+    let branch;
+    if (existing === void 0) {
+      branch = {
+        kind: "branch",
+        children: /* @__PURE__ */ new Map()
+      };
+      tree.set(head, branch);
+    } else {
+      branch = existing;
+    }
+    insertIntoTree(branch.children, rest, leaf, fullName);
+  }
+}
+__name(insertIntoTree, "insertIntoTree");
+function emitRouterTypeBlock(tree, indent) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, node] of tree) {
+    const objKey = toObjectKey(key);
+    if (node.kind === "leaf") {
+      const c = node;
+      const method = c.method.toUpperCase();
+      const query = c.contractSource.query ?? "never";
+      const body = method === "GET" ? "never" : c.contractSource.body ?? "never";
+      const response = c.contractSource.response;
+      const safeMethod = JSON.stringify(method);
+      const safeUrl = JSON.stringify(c.path);
+      lines.push(`${pad}${objKey}: { method: ${safeMethod}; url: ${safeUrl}; query: ${query}; body: ${body}; response: ${response} };`);
+    } else {
+      lines.push(`${pad}${objKey}: {`);
+      lines.push(...emitRouterTypeBlock(node.children, indent + 2));
+      lines.push(`${pad}};`);
+    }
+  }
+  return lines;
+}
+__name(emitRouterTypeBlock, "emitRouterTypeBlock");
+function emitApiObjectBlock(tree, indent) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, node] of tree) {
+    const objKey = toObjectKey(key);
+    if (node.kind === "leaf") {
+      const c = node;
+      const method = c.method.toUpperCase();
+      const flatName = JSON.stringify(c.name);
+      const safePath = JSON.stringify(c.path);
+      const fetcherMethod = method.toLowerCase();
+      if (method === "GET") {
+        const typeAccess = buildRouterTypeAccess(c.name);
+        lines.push(`${pad}${objKey}: {`);
+        lines.push(`${pad}  queryOptions: (query?: ${typeAccess}['query']) =>`);
+        lines.push(`${pad}    queryOptions({`);
+        lines.push(`${pad}      queryKey: [${flatName}, query],`);
+        lines.push(`${pad}      queryFn: () => fetcher.get<${typeAccess}['response']>(route(${flatName} as never) || ${safePath}, { query }),`);
+        lines.push(`${pad}    }),`);
+        lines.push(`${pad}},`);
+      } else {
+        const typeAccess = buildRouterTypeAccess(c.name);
+        lines.push(`${pad}${objKey}: {`);
+        lines.push(`${pad}  mutationOptions: () => ({`);
+        lines.push(`${pad}    mutationFn: (body: ${typeAccess}['body']) => fetcher.${fetcherMethod}<${typeAccess}['response']>(route(${flatName} as never) || ${safePath}, { body }),`);
+        lines.push(`${pad}  }),`);
+        lines.push(`${pad}},`);
+      }
+    } else {
+      lines.push(`${pad}${objKey}: {`);
+      lines.push(...emitApiObjectBlock(node.children, indent + 2));
+      lines.push(`${pad}},`);
+    }
+  }
+  return lines;
+}
+__name(emitApiObjectBlock, "emitApiObjectBlock");
+function buildRouterTypeAccess(name) {
+  const segments = splitName(name);
+  return `ApiRouter${segments.map((s) => `[${JSON.stringify(s)}]`).join("")}`;
+}
+__name(buildRouterTypeAccess, "buildRouterTypeAccess");
+function buildApiFile(routes) {
+  const contracted = routes.filter((r) => r.contract);
+  const lines = [
+    "// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.",
+    "",
+    "import { queryOptions } from '@tanstack/query-core';",
+    "import { route } from './routes.js';",
+    "import { createFetcher } from '@dudousxd/nestjs-inertia-client';",
+    "",
+    "export const fetcher = createFetcher();",
+    ""
+  ];
+  if (contracted.length === 0) {
+    lines.push("export type ApiRouter = Record<string, never>;");
+    lines.push("");
+    lines.push("export const api: Record<string, never> = {} as Record<string, never>;");
+    lines.push("");
+    lines.push("export namespace Route {");
+    lines.push("  export type Response<K extends string> = never;");
+    lines.push("  export type Body<K extends string> = never;");
+    lines.push("  export type Query<K extends string> = never;");
+    lines.push("  export type Params<K extends string> = never;");
+    lines.push("  export type Error<K extends string> = never;");
+    lines.push("  export type Request<K extends string> = { body: never; query: never; params: never };");
+    lines.push("}");
+    lines.push("");
+    lines.push("export namespace Path {");
+    lines.push("  export type Response<M extends string, U extends string> = never;");
+    lines.push("  export type Body<M extends string, U extends string> = never;");
+    lines.push("  export type Query<M extends string, U extends string> = never;");
+    lines.push("  export type Params<M extends string, U extends string> = never;");
+    lines.push("  export type Error<M extends string, U extends string> = never;");
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  const tree = /* @__PURE__ */ new Map();
+  for (const r of contracted) {
+    const c = r.contract;
+    const name = r.name;
+    const segments = splitName(name);
+    for (const seg of segments) {
+      validateNameSegment(seg, name);
+    }
+    const leaf = {
+      kind: "leaf",
+      method: r.method,
+      name,
+      path: r.path,
+      contractSource: c.contractSource
+    };
+    insertIntoTree(tree, segments, leaf, name);
+  }
+  void detectCollisions;
+  lines.push("export type ApiRouter = {");
+  lines.push(...emitRouterTypeBlock(tree, 2));
+  lines.push("};");
+  lines.push("");
+  lines.push("export const api = {");
+  lines.push(...emitApiObjectBlock(tree, 2));
+  lines.push("};");
+  lines.push("");
+  lines.push("type _RouterAt<R, P extends string> = P extends `${infer Head}.${infer Tail}`");
+  lines.push("  ? Head extends keyof R ? _RouterAt<R[Head], Tail> : never");
+  lines.push("  : P extends keyof R ? R[P] : never;");
+  lines.push("");
+  lines.push("type ResolveByName<K extends string, Field extends string> = _RouterAt<ApiRouter, K> extends infer R ? Field extends keyof R ? R[Field] : never : never;");
+  lines.push("");
+  lines.push("type _LeafValues<T> = T extends { method: string; url: string }");
+  lines.push("  ? T");
+  lines.push("  : T extends object ? _LeafValues<T[keyof T]> : never;");
+  lines.push("");
+  lines.push("type ResolveByPath<M extends string, U extends string, Field extends string> = _LeafValues<ApiRouter> extends infer L");
+  lines.push("  ? L extends { method: M; url: U }");
+  lines.push("    ? Field extends keyof L ? L[Field] : never");
+  lines.push("    : never");
+  lines.push("  : never;");
+  lines.push("");
+  lines.push("export namespace Route {");
+  lines.push('  export type Response<K extends string> = ResolveByName<K, "response">;');
+  lines.push('  export type Body<K extends string> = ResolveByName<K, "body">;');
+  lines.push('  export type Query<K extends string> = ResolveByName<K, "query">;');
+  lines.push('  export type Params<K extends string> = ResolveByName<K, "params">;');
+  lines.push('  export type Error<K extends string> = ResolveByName<K, "error">;');
+  lines.push("  export type Request<K extends string> = {");
+  lines.push("    body: Body<K>;");
+  lines.push("    query: Query<K>;");
+  lines.push("    params: Params<K>;");
+  lines.push("  };");
+  lines.push("}");
+  lines.push("");
+  lines.push("export namespace Path {");
+  lines.push('  export type Response<M extends string, U extends string> = ResolveByPath<M, U, "response">;');
+  lines.push('  export type Body<M extends string, U extends string> = ResolveByPath<M, U, "body">;');
+  lines.push('  export type Query<M extends string, U extends string> = ResolveByPath<M, U, "query">;');
+  lines.push('  export type Params<M extends string, U extends string> = ResolveByPath<M, U, "params">;');
+  lines.push('  export type Error<M extends string, U extends string> = ResolveByPath<M, U, "error">;');
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+__name(buildApiFile, "buildApiFile");
+
+// src/emit/emit-cache.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = require("path");
+async function emitCache(pages, outDir) {
+  await (0, import_promises4.mkdir)(outDir, {
+    recursive: true
+  });
+  const entries = await Promise.all(pages.map(async (p) => {
+    const s = await (0, import_promises4.stat)(p.absolutePath);
+    return {
+      name: p.name,
+      relativePath: p.relativePath,
+      mtime: s.mtime.toISOString()
+    };
+  }));
+  const cache = {
+    pages: entries
+  };
+  await (0, import_promises4.writeFile)((0, import_node_path4.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+}
+__name(emitCache, "emitCache");
+
+// src/emit/emit-index.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = require("path");
+async function emitIndex(outDir, hasContracts = false) {
+  await (0, import_promises5.mkdir)(outDir, {
+    recursive: true
+  });
+  const exports2 = [
+    "export * from './pages.js';",
+    "export * from './routes.js';"
+  ];
+  if (hasContracts) {
+    exports2.push("export * from './api.js';");
+  }
+  const content = [
+    "// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.",
+    ...exports2,
+    ""
+  ].join("\n");
+  await (0, import_promises5.writeFile)((0, import_node_path5.join)(outDir, "index.d.ts"), content, "utf8");
+}
+__name(emitIndex, "emitIndex");
+
+// src/emit/emit-pages.ts
+var import_promises6 = require("fs/promises");
+var import_node_path6 = require("path");
+async function emitPages(pages, outDir) {
+  await (0, import_promises6.mkdir)(outDir, {
+    recursive: true
+  });
+  const body = pages.map((p) => {
+    const propType = p.propsSource ?? "unknown";
+    const key = needsQuotes(p.name) ? JSON.stringify(p.name) : p.name;
+    return `  ${key}: ${propType};`;
+  }).join("\n");
+  const content = `// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.
+export interface InertiaPages {
+${body}
+}
+`;
+  await (0, import_promises6.writeFile)((0, import_node_path6.join)(outDir, "pages.d.ts"), content, "utf8");
+}
+__name(emitPages, "emitPages");
+function needsQuotes(name) {
+  return !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+__name(needsQuotes, "needsQuotes");
+
+// src/emit/emit-routes.ts
+var import_promises7 = require("fs/promises");
+var import_node_path7 = require("path");
+async function emitRoutes(routes, outDir) {
+  await (0, import_promises7.mkdir)(outDir, {
+    recursive: true
+  });
+  const content = buildRoutesFile(routes);
+  await (0, import_promises7.writeFile)((0, import_node_path7.join)(outDir, "routes.ts"), content, "utf8");
+}
+__name(emitRoutes, "emitRoutes");
+function buildRoutesFile(routes) {
+  if (routes.length === 0) {
+    return buildEmpty();
+  }
+  const entries = routes.map((r) => `  ${JSON.stringify(r.name)}: ${JSON.stringify(r.path)},`).join("\n");
+  const routeNameUnion = routes.map((r) => `  | ${JSON.stringify(r.name)}`).join("\n");
+  const lines = [
+    "// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.",
+    "",
+    "/** Map of route name \u2192 path pattern. */",
+    "export const ROUTES = {",
+    entries,
+    "} as const;",
+    "",
+    "/** Union of all known route names. */",
+    "export type RouteName =",
+    `${routeNameUnion};`,
+    "",
+    "/**",
+    " * Extracts path-parameter names from a route path string.",
+    ' * `ExtractParams<"/users/:id">` \u2192 `"id"`',
+    " */",
+    "export type ExtractParams<Path extends string> =",
+    "  Path extends `${string}:${infer Param}/${infer Rest}`",
+    "    ? Param | ExtractParams<`/${Rest}`>",
+    "    : Path extends `${string}:${infer Param}`",
+    "      ? Param",
+    "      : never;",
+    "",
+    "/**",
+    " * Mapped type: given a `RouteName`, returns an object with each path param as `string`.",
+    ' * `RouteParams<"UsersController.show">` \u2192 `{ id: string }`',
+    ' * `RouteParams<"UsersController.list">` \u2192 `Record<string, never>`',
+    " */",
+    "export type RouteParams<K extends RouteName> =",
+    "  ExtractParams<(typeof ROUTES)[K]> extends never",
+    "    ? Record<string, never>",
+    "    : { [P in ExtractParams<(typeof ROUTES)[K]>]: string };",
+    "",
+    "/**",
+    " * Map of every route name to its resolved params object.",
+    " * Use this for `InertiaRegistry` module augmentation.",
+    " */",
+    "export type RouteParamsMap = { [K in RouteName]: RouteParams<K> };",
+    "",
+    "/**",
+    " * Build a URL from a named route, interpolating path params and appending query string.",
+    " *",
+    " * @example",
+    " * route('UsersController.show', { id: '42' }) // \u2192 '/users/42'",
+    " * route('UsersController.list')                // \u2192 '/users'",
+    " * route('users.list', undefined, { active: true }) // \u2192 '/api/users?active=true'",
+    " */",
+    "export function route<K extends RouteName>(",
+    "  name: K,",
+    "  ...args: ExtractParams<(typeof ROUTES)[K]> extends never",
+    "    ? [params?: undefined, query?: Record<string, unknown>]",
+    "    : [params: RouteParams<K>, query?: Record<string, unknown>]",
+    "): string {",
+    "  const [params, query] = args as [Record<string, string> | undefined, Record<string, unknown> | undefined];",
+    "  const path: string | undefined = ROUTES[name as RouteName];",
+    "  if (path === undefined) {",
+    "    const available = Object.keys(ROUTES).join(', ');",
+    "    throw new Error(",
+    '      `[nestjs-inertia] Route "${String(name)}" does not exist.\\n\\n` +',
+    "      `Available routes: ${available}\\n\\n` +",
+    "      `This usually means:\\n` +",
+    "      `  - The route name has a typo\\n` +",
+    "      `  - The controller hasn't been scanned by codegen yet (run: nestjs-inertia codegen)\\n` +",
+    "      `  - The @As() decorator changed the route name\\n`",
+    "    );",
+    "  }",
+    "  let resolvedPath: string = path;",
+    "  if (params) {",
+    "    resolvedPath = resolvedPath.replace(/:([^/]+)/g, (_, key) => {",
+    "      const val = params[key];",
+    "      if (val === undefined) throw new Error(`Missing route param: ${key}`);",
+    "      return encodeURIComponent(val);",
+    "    });",
+    "  }",
+    "  if (query && Object.keys(query).length > 0) {",
+    "    const qs = new URLSearchParams();",
+    "    for (const [k, v] of Object.entries(query)) {",
+    "      if (v !== undefined && v !== null) qs.append(k, String(v));",
+    "    }",
+    "    const qStr = qs.toString();",
+    "    if (qStr) {",
+    "      const sep = resolvedPath.includes('?') ? '&' : '?';",
+    "      resolvedPath = `${resolvedPath}${sep}${qStr}`;",
+    "    }",
+    "  }",
+    "  return resolvedPath;",
+    "}",
+    ""
+  ];
+  return lines.join("\n");
+}
+__name(buildRoutesFile, "buildRoutesFile");
+function buildEmpty() {
+  return [
+    "// Generated by @dudousxd/nestjs-inertia-codegen. Do not edit.",
+    "",
+    "export const ROUTES = {} as const;",
+    "export type RouteName = never;",
+    "export type ExtractParams<_Path extends string> = never;",
+    "export type RouteParams<_K extends RouteName> = Record<string, never>;",
+    'export function route(_name: never, _params?: undefined, _query?: Record<string, unknown>): string { return ""; }',
+    ""
+  ].join("\n");
+}
+__name(buildEmpty, "buildEmpty");
+
+// src/generate.ts
+async function generate(config, routes = []) {
+  const pages = await discoverPages({
+    glob: config.pages.glob,
+    cwd: config.codegen.cwd,
+    propsExport: config.pages.propsExport,
+    componentNameStrategy: config.pages.componentNameStrategy
+  });
+  await emitPages(pages, config.codegen.outDir);
+  await emitCache(pages, config.codegen.outDir);
+  const hasRoutes = routes.length > 0;
+  const hasContracts = routes.some((r) => r.contract);
+  if (hasRoutes) {
+    await emitRoutes(routes, config.codegen.outDir);
+  }
+  await emitIndex(config.codegen.outDir, hasContracts);
+  if (hasContracts) {
+    await emitApi(routes, config.codegen.outDir);
+  }
+}
+__name(generate, "generate");
+
+// src/watch/watcher.ts
+var import_promises9 = require("fs/promises");
+var import_node_path10 = require("path");
+var import_chokidar = __toESM(require("chokidar"), 1);
+
+// src/discovery/contracts-fast.ts
+var import_node_path8 = require("path");
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_ts_morph = require("ts-morph");
+async function discoverContractsFast(opts) {
+  const { cwd, glob, tsconfig } = opts;
+  const tsconfigPath = tsconfig ? (0, import_node_path8.resolve)(tsconfig) : (0, import_node_path8.join)(cwd, "tsconfig.json");
+  let project;
+  try {
+    project = new import_ts_morph.Project({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true
+    });
+  } catch {
+    project = new import_ts_morph.Project({
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true,
+      compilerOptions: {
+        allowJs: true,
+        resolveJsonModule: false,
+        strict: false
+      }
+    });
+  }
+  const files = await (0, import_fast_glob2.default)(glob, {
+    cwd,
+    absolute: true,
+    onlyFiles: true
+  });
+  for (const f of files) {
+    project.addSourceFileAtPath(f);
+  }
+  const routes = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    routes.push(...extractFromSourceFile(sourceFile));
+  }
+  return routes;
+}
+__name(discoverContractsFast, "discoverContractsFast");
+function zodAstToTs(node) {
+  if (!import_ts_morph.Node.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (import_ts_morph.Node.isPropertyAccessExpression(expr)) {
+    const methodName = expr.getName();
+    const receiver = expr.getExpression();
+    if (methodName === "optional") {
+      return `${zodAstToTs(receiver)} | undefined`;
+    }
+    if (methodName === "nullable") {
+      return `${zodAstToTs(receiver)} | null`;
+    }
+    const args = node.getArguments();
+    switch (methodName) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "unknown":
+        return "unknown";
+      case "any":
+        return "unknown";
+      case "literal": {
+        const lit = args[0];
+        if (!lit) return "unknown";
+        if (import_ts_morph.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph.SyntaxKind.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map((el) => import_ts_morph.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown");
+        return members.join(" | ");
+      }
+      case "array": {
+        const inner = args[0];
+        if (!inner) return "unknown";
+        return `Array<${zodAstToTs(inner)}>`;
+      }
+      case "object": {
+        const objArg = args[0];
+        if (!objArg || !import_ts_morph.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!import_ts_morph.Node.isPropertyAssignment(prop)) continue;
+          const key = prop.getName();
+          const valNode = prop.getInitializer();
+          if (!valNode) continue;
+          const tsType = zodAstToTs(valNode);
+          const isOpt = isOptionalChain(valNode);
+          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
+        }
+        return `{ ${lines.join("; ")} }`;
+      }
+      case "union": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return arrArg.getElements().map(zodAstToTs).join(" | ");
+      }
+      case "record": {
+        const valArg = args.length === 1 ? args[0] : args[1];
+        if (!valArg) return "unknown";
+        return `Record<string, ${zodAstToTs(valArg)}>`;
+      }
+      case "tuple": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+__name(zodAstToTs, "zodAstToTs");
+function isOptionalChain(node) {
+  if (!import_ts_morph.Node.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return import_ts_morph.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+__name(isOptionalChain, "isOptionalChain");
+function decoratorStringArg(decoratorExpr) {
+  if (!decoratorExpr) return void 0;
+  if (import_ts_morph.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph.Node.isArrayLiteralExpression(decoratorExpr)) {
+    const first = decoratorExpr.getElements()[0];
+    if (first && import_ts_morph.Node.isStringLiteral(first)) return first.getLiteralValue();
+  }
+  return void 0;
+}
+__name(decoratorStringArg, "decoratorStringArg");
+function parseDefineContractCall(callExpr) {
+  if (!import_ts_morph.Node.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = import_ts_morph.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !import_ts_morph.Node.isObjectLiteralExpression(optsArg)) return null;
+  let query = null;
+  let body = null;
+  let response = "unknown";
+  for (const prop of optsArg.getProperties()) {
+    if (!import_ts_morph.Node.isPropertyAssignment(prop)) continue;
+    const propName = prop.getName();
+    const val = prop.getInitializer();
+    if (!val) continue;
+    if (propName === "query") {
+      query = zodAstToTs(val);
+    } else if (propName === "body") {
+      body = zodAstToTs(val);
+    } else if (propName === "response") {
+      response = zodAstToTs(val);
+    }
+  }
+  return {
+    query,
+    body,
+    response
+  };
+}
+__name(parseDefineContractCall, "parseDefineContractCall");
+function deriveClassSegment(className) {
+  const noSuffix = className.replace(/Controller$/, "");
+  if (!noSuffix) {
+    throw new Error(`Controller class name "${className}" derives empty route segment after stripping "Controller". Add an @As(...) override at the class level.`);
+  }
+  return noSuffix.charAt(0).toLowerCase() + noSuffix.slice(1);
+}
+__name(deriveClassSegment, "deriveClassSegment");
+function resolveRouteName(className, methodName, classAs, methodAs) {
+  const classPortion = classAs ?? deriveClassSegment(className);
+  const methodPortion = methodAs ?? methodName;
+  return `${classPortion}.${methodPortion}`;
+}
+__name(resolveRouteName, "resolveRouteName");
+function joinPaths(prefix, suffix) {
+  if (!prefix && !suffix) return "/";
+  if (!prefix) return suffix.startsWith("/") ? suffix : `/${suffix}`;
+  if (!suffix) return prefix.startsWith("/") ? prefix : `/${prefix}`;
+  const p = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const s = suffix.startsWith("/") ? suffix : `/${suffix}`;
+  const combined = p + s;
+  return combined === "" ? "/" : combined;
+}
+__name(joinPaths, "joinPaths");
+function extractParams(path) {
+  const matches = path.matchAll(/:(\w+)/g);
+  return Array.from(matches).map((m) => ({
+    name: m[1],
+    source: "path"
+  }));
+}
+__name(extractParams, "extractParams");
+function resolveTypeNodeToString(typeNode, sourceFile, depth) {
+  if (depth <= 0) return "unknown";
+  if (import_ts_morph.Node.isArrayTypeNode(typeNode)) {
+    const elementType = typeNode.getElementTypeNode();
+    return `Array<${resolveTypeNodeToString(elementType, sourceFile, depth)}>`;
+  }
+  if (import_ts_morph.Node.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    const name = import_ts_morph.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    if (name === "string" || name === "number" || name === "boolean") return name;
+    if (name === "Date") return "string";
+    if (name === "unknown" || name === "any") return "unknown";
+    if (name === "Array") {
+      const typeArgs = typeNode.getTypeArguments();
+      const firstTypeArg = typeArgs[0];
+      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
+        return `Array<${resolveTypeNodeToString(firstTypeArg, sourceFile, depth)}>`;
+      }
+      return "Array<unknown>";
+    }
+    if (name === "Promise") {
+      const typeArgs = typeNode.getTypeArguments();
+      const firstTypeArg = typeArgs[0];
+      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
+        return resolveTypeNodeToString(firstTypeArg, sourceFile, depth);
+      }
+      return "unknown";
+    }
+    const classDec = sourceFile.getClass(name);
+    if (classDec) {
+      return resolveClassDeclaration(classDec, sourceFile, depth - 1);
+    }
+    return name;
+  }
+  const kind = typeNode.getKind();
+  if (kind === import_ts_morph.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph.SyntaxKind.AnyKeyword) return "unknown";
+  return typeNode.getText();
+}
+__name(resolveTypeNodeToString, "resolveTypeNodeToString");
+function resolveClassDeclaration(cls, sourceFile, depth) {
+  if (depth < 0) return "unknown";
+  const lines = [];
+  for (const prop of cls.getProperties()) {
+    const propName = prop.getName();
+    const isOptional = prop.hasQuestionToken();
+    const propTypeNode = prop.getTypeNode();
+    let propType = "unknown";
+    if (propTypeNode) {
+      propType = resolveTypeNodeToString(propTypeNode, sourceFile, depth);
+    }
+    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType}`);
+  }
+  return `{ ${lines.join("; ")} }`;
+}
+__name(resolveClassDeclaration, "resolveClassDeclaration");
+function extractBodyType(method, sourceFile) {
+  for (const param of method.getParameters()) {
+    const bodyDecorator = param.getDecorators().find((d) => d.getName() === "Body");
+    if (!bodyDecorator) continue;
+    const bodyArgs = bodyDecorator.getArguments();
+    if (bodyArgs.length > 0) continue;
+    const typeNode = param.getTypeNode();
+    if (typeNode) {
+      return resolveTypeNodeToString(typeNode, sourceFile, 3);
+    }
+  }
+  return null;
+}
+__name(extractBodyType, "extractBodyType");
+function extractQueryType(method, sourceFile) {
+  for (const param of method.getParameters()) {
+    const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
+    if (!queryDecorator) continue;
+    const queryArgs = queryDecorator.getArguments();
+    if (queryArgs.length > 0) continue;
+    const typeNode = param.getTypeNode();
+    if (typeNode) {
+      return resolveTypeNodeToString(typeNode, sourceFile, 3);
+    }
+  }
+  return null;
+}
+__name(extractQueryType, "extractQueryType");
+function extractParamsType(method, sourceFile) {
+  const entries = [];
+  for (const param of method.getParameters()) {
+    const paramDecorator = param.getDecorators().find((d) => d.getName() === "Param");
+    if (!paramDecorator) continue;
+    const paramArgs = paramDecorator.getArguments();
+    if (paramArgs.length === 0) continue;
+    const nameArg = paramArgs[0];
+    if (!import_ts_morph.Node.isStringLiteral(nameArg)) continue;
+    const paramName = nameArg.getLiteralValue();
+    const typeNode = param.getTypeNode();
+    const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, 3) : "string";
+    entries.push(`${paramName}: ${paramType}`);
+  }
+  return entries.length > 0 ? `{ ${entries.join("; ")} }` : null;
+}
+__name(extractParamsType, "extractParamsType");
+function extractResponseType(method, sourceFile) {
+  const apiResponseDecorator = method.getDecorator("ApiResponse");
+  if (apiResponseDecorator) {
+    const args = apiResponseDecorator.getArguments();
+    const optsArg = args[0];
+    if (optsArg && import_ts_morph.Node.isObjectLiteralExpression(optsArg)) {
+      for (const prop of optsArg.getProperties()) {
+        if (!import_ts_morph.Node.isPropertyAssignment(prop)) continue;
+        if (prop.getName() !== "type") continue;
+        const val = prop.getInitializer();
+        if (!val) continue;
+        if (import_ts_morph.Node.isArrayLiteralExpression(val)) {
+          const elements = val.getElements();
+          const firstEl = elements[0];
+          if (elements.length > 0 && firstEl !== void 0) {
+            const innerType = resolveIdentifierToClassType(firstEl, sourceFile, 3);
+            return `Array<${innerType}>`;
+          }
+          return "Array<unknown>";
+        }
+        return resolveIdentifierToClassType(val, sourceFile, 3);
+      }
+    }
+  }
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    return resolveTypeNodeToString(returnTypeNode, sourceFile, 3);
+  }
+  return "unknown";
+}
+__name(extractResponseType, "extractResponseType");
+function resolveIdentifierToClassType(node, sourceFile, depth) {
+  if (!import_ts_morph.Node.isIdentifier(node)) return "unknown";
+  const name = node.getText();
+  const classDec = sourceFile.getClass(name);
+  if (classDec) {
+    return resolveClassDeclaration(classDec, sourceFile, depth - 1);
+  }
+  return name;
+}
+__name(resolveIdentifierToClassType, "resolveIdentifierToClassType");
+function extractDtoContract(method, sourceFile) {
+  const body = extractBodyType(method, sourceFile);
+  const query = extractQueryType(method, sourceFile);
+  const paramsType = extractParamsType(method, sourceFile);
+  const response = extractResponseType(method, sourceFile);
+  if (body === null && query === null && paramsType === null && response === "unknown") {
+    return null;
+  }
+  return {
+    query,
+    body,
+    response,
+    params: paramsType
+  };
+}
+__name(extractDtoContract, "extractDtoContract");
+var HTTP_METHOD_DECORATORS = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Patch: "PATCH",
+  Delete: "DELETE",
+  Options: "OPTIONS",
+  Head: "HEAD",
+  All: "ALL"
+};
+function extractFromSourceFile(sourceFile) {
+  const routes = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  const classes = sourceFile.getClasses();
+  for (const cls of classes) {
+    const controllerDecorator = cls.getDecorator("Controller");
+    if (!controllerDecorator) continue;
+    const controllerArgs = controllerDecorator.getArguments();
+    const firstArg = controllerArgs[0];
+    const prefix = decoratorStringArg(firstArg) ?? "";
+    const className = cls.getName() ?? "Unknown";
+    for (const method of cls.getMethods()) {
+      let httpMethod;
+      let handlerPath = "";
+      for (const [decoratorName, verb] of Object.entries(HTTP_METHOD_DECORATORS)) {
+        const httpDecorator = method.getDecorator(decoratorName);
+        if (httpDecorator) {
+          httpMethod = verb;
+          const httpArgs = httpDecorator.getArguments();
+          const pathArg = httpArgs[0];
+          handlerPath = decoratorStringArg(pathArg) ?? "";
+          break;
+        }
+      }
+      const applyContractDecorator = method.getDecorator("ApplyContract");
+      if (applyContractDecorator) {
+        const decoratorArgs = applyContractDecorator.getArguments();
+        const firstDecoratorArg = decoratorArgs[0];
+        if (!firstDecoratorArg) continue;
+        let contractDef = null;
+        if (import_ts_morph.Node.isCallExpression(firstDecoratorArg)) {
+          contractDef = parseDefineContractCall(firstDecoratorArg);
+        } else if (import_ts_morph.Node.isIdentifier(firstDecoratorArg)) {
+          const identName = firstDecoratorArg.getText();
+          const varDecl = sourceFile.getVariableDeclaration(identName);
+          if (!varDecl) {
+            console.warn(`[nestjs-inertia-codegen/fast] Cannot resolve '${identName}' in ${sourceFile.getFilePath()} (cross-file imports are out-of-scope for v1) \u2014 skipping`);
+            continue;
+          }
+          const initializer = varDecl.getInitializer();
+          if (!initializer) continue;
+          contractDef = parseDefineContractCall(initializer);
+        } else {
+          console.warn(`[nestjs-inertia-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`);
+          continue;
+        }
+        if (!contractDef) continue;
+        if (!httpMethod) continue;
+        const resolvedMethod = httpMethod;
+        const resolvedPath = joinPaths(prefix, handlerPath);
+        const combined = resolvedPath;
+        const params = extractParams(combined);
+        const methodName = method.getName();
+        const classAsDecorator = cls.getDecorator("As");
+        let classAs;
+        if (classAsDecorator) {
+          const classAsArgs = classAsDecorator.getArguments();
+          const classAsName = decoratorStringArg(classAsArgs[0]);
+          if (!classAsName) {
+            throw new Error(`@As decorator on class ${className} must have a non-empty string argument.`);
+          }
+          classAs = classAsName;
+        }
+        const methodAsDecorator = method.getDecorator("As");
+        let methodAs;
+        if (methodAsDecorator) {
+          const methodAsArgs = methodAsDecorator.getArguments();
+          const methodAsName = decoratorStringArg(methodAsArgs[0]);
+          if (!methodAsName) {
+            throw new Error(`@As decorator on ${className}.${methodName} must have a non-empty string argument.`);
+          }
+          methodAs = methodAsName;
+        }
+        const routeName = resolveRouteName(className, methodName, classAs, methodAs);
+        const qualifiedRef = `${className}.${methodName}`;
+        const existing = seenNames.get(routeName);
+        if (existing !== void 0) {
+          throw new Error(`Route name collision: "${routeName}" is used by both "${existing}" and "${qualifiedRef}". Use @As(...) to give one of them a unique name.`);
+        }
+        seenNames.set(routeName, qualifiedRef);
+        routes.push({
+          method: resolvedMethod,
+          path: combined,
+          name: routeName,
+          params,
+          contract: {
+            contractSource: {
+              query: contractDef.query,
+              body: contractDef.body,
+              response: contractDef.response
+            }
+          }
+        });
+      } else {
+        if (!httpMethod) continue;
+        const combined = joinPaths(prefix, handlerPath);
+        const params = extractParams(combined);
+        const methodName = method.getName();
+        const routeName = `${className}.${methodName}`;
+        const dtoContract = extractDtoContract(method, sourceFile);
+        routes.push({
+          method: httpMethod,
+          path: combined,
+          name: routeName,
+          params,
+          // Attach contract if DTO extraction produced useful type info
+          ...dtoContract ? {
+            contract: {
+              contractSource: {
+                query: dtoContract.query,
+                body: dtoContract.body,
+                response: dtoContract.response
+              }
+            }
+          } : {}
+        });
+      }
+    }
+  }
+  return routes;
+}
+__name(extractFromSourceFile, "extractFromSourceFile");
+
+// src/watch/lock-file.ts
+var import_promises8 = require("fs/promises");
+var import_node_path9 = require("path");
+var LOCK_FILE = ".watcher.lock";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isProcessAlive, "isProcessAlive");
+async function acquireLock(outDir) {
+  await (0, import_promises8.mkdir)(outDir, {
+    recursive: true
+  });
+  const lockPath = (0, import_node_path9.join)(outDir, LOCK_FILE);
+  try {
+    const raw = await (0, import_promises8.readFile)(lockPath, "utf8");
+    const existing = JSON.parse(raw);
+    if (isProcessAlive(existing.pid)) {
+      return null;
+    }
+  } catch {
+  }
+  const lockData = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await (0, import_promises8.writeFile)(lockPath, `${JSON.stringify(lockData, null, 2)}
+`, "utf8");
+  return {
+    release: /* @__PURE__ */ __name(async () => {
+      try {
+        await (0, import_promises8.unlink)(lockPath);
+      } catch {
+      }
+    }, "release")
+  };
+}
+__name(acquireLock, "acquireLock");
+
+// src/watch/watcher.ts
+var PAGES_DEBOUNCE_MS = 150;
+var NO_OP_WATCHER = {
+  close: /* @__PURE__ */ __name(async () => {
+  }, "close")
+};
+async function watch(config, onChange) {
+  const lock = await acquireLock(config.codegen.outDir);
+  if (lock === null) {
+    let holderPid = "unknown";
+    try {
+      const raw = await (0, import_promises9.readFile)((0, import_node_path10.join)(config.codegen.outDir, ".watcher.lock"), "utf8");
+      const data = JSON.parse(raw);
+      if (data.pid !== void 0) holderPid = String(data.pid);
+    } catch {
+    }
+    console.warn(`[nestjs-inertia-codegen] auto-watch skipped \u2014 another process (PID ${holderPid}) is already running the watcher in ${config.codegen.outDir}. Files will continue to regenerate from that process. To take over, stop the other watcher.`);
+    return NO_OP_WATCHER;
+  }
+  try {
+    await generate(config);
+  } catch {
+  }
+  let pagesDebounceTimer;
+  const pagesWatcher = import_chokidar.default.watch((0, import_node_path10.join)(config.codegen.cwd, config.pages.glob), {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 80,
+      pollInterval: 20
+    }
+  });
+  function schedulePagesRegenerate() {
+    if (pagesDebounceTimer !== void 0) {
+      clearTimeout(pagesDebounceTimer);
+    }
+    pagesDebounceTimer = setTimeout(async () => {
+      pagesDebounceTimer = void 0;
+      try {
+        await generate(config);
+      } catch {
+      }
+      onChange?.();
+    }, PAGES_DEBOUNCE_MS);
+  }
+  __name(schedulePagesRegenerate, "schedulePagesRegenerate");
+  pagesWatcher.on("add", schedulePagesRegenerate);
+  pagesWatcher.on("change", schedulePagesRegenerate);
+  pagesWatcher.on("unlink", schedulePagesRegenerate);
+  let contractsDebounceTimer;
+  const contractsWatcher = import_chokidar.default.watch((0, import_node_path10.join)(config.codegen.cwd, config.contracts.glob), {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 80,
+      pollInterval: 20
+    }
+  });
+  function scheduleContractsRegenerate() {
+    if (contractsDebounceTimer !== void 0) {
+      clearTimeout(contractsDebounceTimer);
+    }
+    contractsDebounceTimer = setTimeout(async () => {
+      contractsDebounceTimer = void 0;
+      try {
+        const routes = await discoverContractsFast({
+          cwd: config.codegen.cwd,
+          glob: config.contracts.glob,
+          ...config.app?.tsconfig ? {
+            tsconfig: config.app.tsconfig
+          } : {}
+        });
+        await emitRoutes(routes, config.codegen.outDir);
+        const hasContracts = routes.some((r) => r.contract);
+        await emitIndex(config.codegen.outDir, hasContracts);
+        if (hasContracts) {
+          await emitApi(routes, config.codegen.outDir);
+        }
+      } catch {
+      }
+      onChange?.();
+    }, config.contracts.debounceMs);
+  }
+  __name(scheduleContractsRegenerate, "scheduleContractsRegenerate");
+  contractsWatcher.on("add", scheduleContractsRegenerate);
+  contractsWatcher.on("change", scheduleContractsRegenerate);
+  contractsWatcher.on("unlink", scheduleContractsRegenerate);
+  return {
+    close: /* @__PURE__ */ __name(async () => {
+      if (pagesDebounceTimer !== void 0) {
+        clearTimeout(pagesDebounceTimer);
+        pagesDebounceTimer = void 0;
+      }
+      if (contractsDebounceTimer !== void 0) {
+        clearTimeout(contractsDebounceTimer);
+        contractsDebounceTimer = void 0;
+      }
+      await pagesWatcher.close();
+      await contractsWatcher.close();
+      await lock.release();
+    }, "close")
+  };
+}
+__name(watch, "watch");
+
+// src/index.ts
+var VERSION = "1.0.0";
+
+// src/cli/codegen.ts
+async function runCodegen(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const config = await loadConfig(cwd);
+  if (opts.watch) {
+    const watcher = await watch(config);
+    await new Promise((resolve3) => {
+      function onSignal() {
+        watcher.close().then(resolve3).catch(resolve3);
+      }
+      __name(onSignal, "onSignal");
+      process.once("SIGINT", onSignal);
+      process.once("SIGTERM", onSignal);
+    });
+    return;
+  }
+  const routes = await discoverContractsFast({
+    cwd: config.codegen.cwd,
+    glob: config.contracts.glob,
+    ...config.app?.tsconfig ? {
+      tsconfig: config.app.tsconfig
+    } : {}
+  });
+  await generate(config, routes);
+  console.log("\u2713 Codegen generated artifacts in", config.codegen.outDir);
+}
+__name(runCodegen, "runCodegen");
+
+// src/cli/init.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_promises10 = require("fs/promises");
+var import_node_path11 = require("path");
+var import_node_readline = require("readline");
+var GITIGNORE_ENTRY = ".nestjs-inertia/";
+var green = /* @__PURE__ */ __name((s) => `\x1B[32m${s}\x1B[0m`, "green");
+var yellow = /* @__PURE__ */ __name((s) => `\x1B[33m${s}\x1B[0m`, "yellow");
+var cyan = /* @__PURE__ */ __name((s) => `\x1B[36m${s}\x1B[0m`, "cyan");
+var dim = /* @__PURE__ */ __name((s) => `\x1B[2m${s}\x1B[0m`, "dim");
+var bold = /* @__PURE__ */ __name((s) => `\x1B[1m${s}\x1B[0m`, "bold");
+function logCreated(path) {
+  console.log(`  ${green("\u2713")} ${path} ${dim("(created)")}`);
+}
+__name(logCreated, "logCreated");
+function logPatched(path, detail) {
+  console.log(`  ${green("\u2713")} ${path} ${dim(`(${detail})`)}`);
+}
+__name(logPatched, "logPatched");
+function logSkipped(path) {
+  console.log(`  ${cyan("\u2192")} ${path} ${dim("(already exists, skipped)")}`);
+}
+__name(logSkipped, "logSkipped");
+function logWarning(msg) {
+  console.log(`  ${yellow("\u26A0")} ${msg}`);
+}
+__name(logWarning, "logWarning");
+function logSection(title) {
+  console.log(`
+${bold(title)}`);
+}
+__name(logSection, "logSection");
+async function readPackageJson(cwd) {
+  try {
+    const raw = await (0, import_promises10.readFile)((0, import_node_path11.join)(cwd, "package.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+__name(readPackageJson, "readPackageJson");
+function allDeps(pkg) {
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  return [
+    ...Object.keys(deps),
+    ...Object.keys(devDeps)
+  ];
+}
+__name(allDeps, "allDeps");
+async function detectFramework(cwd) {
+  const pkg = await readPackageJson(cwd);
+  const deps = allDeps(pkg);
+  if (deps.includes("@inertiajs/react") || deps.includes("react")) return "react";
+  if (deps.includes("@inertiajs/vue3") || deps.includes("vue")) return "vue";
+  if (deps.includes("@inertiajs/svelte") || deps.includes("svelte")) return "svelte";
+  return null;
+}
+__name(detectFramework, "detectFramework");
+async function detectTemplateEngine(cwd) {
+  const pkg = await readPackageJson(cwd);
+  const deps = allDeps(pkg);
+  if (deps.includes("handlebars")) return "handlebars";
+  if (deps.includes("ejs")) return "ejs";
+  if (deps.includes("pug")) return "pug";
+  if (deps.includes("liquidjs")) return "liquid";
+  return "html";
+}
+__name(detectTemplateEngine, "detectTemplateEngine");
+async function detectPackageManager(cwd) {
+  async function exists(file) {
+    try {
+      await (0, import_promises10.access)((0, import_node_path11.join)(cwd, file));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  __name(exists, "exists");
+  if (await exists("pnpm-lock.yaml")) return "pnpm";
+  if (await exists("yarn.lock")) return "yarn";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+async function promptFramework() {
+  if (!process.stdin.isTTY) return "react";
+  return new Promise((resolve3) => {
+    const rl = (0, import_node_readline.createInterface)({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("[nestjs-inertia] Which frontend framework? (react/vue/svelte) [react]: ", (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "vue") resolve3("vue");
+      else if (trimmed === "svelte") resolve3("svelte");
+      else resolve3("react");
+    });
+  });
+}
+__name(promptFramework, "promptFramework");
+async function fileExists2(filePath) {
+  try {
+    await (0, import_promises10.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(fileExists2, "fileExists");
+async function writeIfNotExists(filePath, content, label) {
+  if (await fileExists2(filePath)) {
+    logSkipped(label);
+    return;
+  }
+  const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+  if (dir) {
+    await (0, import_promises10.mkdir)(dir, {
+      recursive: true
+    });
+  }
+  await (0, import_promises10.writeFile)(filePath, content, "utf8");
+  logCreated(label);
+}
+__name(writeIfNotExists, "writeIfNotExists");
+async function handleViteConfig(cwd, framework) {
+  const filePath = (0, import_node_path11.join)(cwd, "vite.config.ts");
+  if (await fileExists2(filePath)) {
+    const existing = await (0, import_promises10.readFile)(filePath, "utf8");
+    const hasPlugin = existing.includes("nestInertia") || existing.includes("nestjs-inertia-vite/plugin");
+    if (!hasPlugin) {
+      logSkipped("vite.config.ts");
+      logWarning(`vite.config.ts exists but nestInertia plugin not detected \u2014 add it manually:
+    import nestInertia from '@dudousxd/nestjs-inertia-vite/plugin';
+    plugins: [nestInertia({ ${framework}: true })]`);
+    } else {
+      logSkipped("vite.config.ts");
+    }
+    return;
+  }
+  const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+  if (dir) {
+    await (0, import_promises10.mkdir)(dir, {
+      recursive: true
+    });
+  }
+  await (0, import_promises10.writeFile)(filePath, viteConfigTemplate(framework), "utf8");
+  logCreated("vite.config.ts");
+}
+__name(handleViteConfig, "handleViteConfig");
+async function patchGitignore(gitignorePath) {
+  let existing = "";
+  if (await fileExists2(gitignorePath)) {
+    existing = await (0, import_promises10.readFile)(gitignorePath, "utf8");
+  }
+  if (existing.split("\n").some((line) => line.trim() === GITIGNORE_ENTRY)) {
+    console.log(`  ${cyan("\u2192")} .gitignore ${dim("(already contains .nestjs-inertia/, skipped)")}`);
+    return;
+  }
+  const newContent = existing.endsWith("\n") || existing === "" ? `${existing}${GITIGNORE_ENTRY}
+` : `${existing}
+${GITIGNORE_ENTRY}
+`;
+  await (0, import_promises10.writeFile)(gitignorePath, newContent, "utf8");
+  logPatched(".gitignore", "added .nestjs-inertia/");
+}
+__name(patchGitignore, "patchGitignore");
+function installDeps(pkgManager, deps, dev) {
+  if (deps.length === 0) return;
+  const flag = dev ? pkgManager === "npm" ? "--save-dev" : "-D" : "";
+  const cmd = pkgManager === "npm" ? `npm install ${flag} ${deps.join(" ")}` : pkgManager === "yarn" ? `yarn add ${flag} ${deps.join(" ")}` : `pnpm add ${flag} ${deps.join(" ")}`;
+  logPatched(deps.join(", "), "installed");
+  try {
+    (0, import_node_child_process.execSync)(cmd, {
+      stdio: "inherit"
+    });
+  } catch {
+    logWarning(`Failed to install deps. Run manually:
+    ${cmd}`);
+  }
+}
+__name(installDeps, "installDeps");
+async function patchPackageJsonScripts(cwd, scripts) {
+  const pkgPath = (0, import_node_path11.join)(cwd, "package.json");
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await (0, import_promises10.readFile)(pkgPath, "utf8"));
+  } catch {
+    return;
+  }
+  const existing = pkg.scripts ?? {};
+  let changed = false;
+  for (const [key, value] of Object.entries(scripts)) {
+    if (!(key in existing)) {
+      existing[key] = value;
+      changed = true;
+      logPatched("package.json", `added ${key} script`);
+    } else {
+      console.log(`  ${cyan("\u2192")} package.json ${dim(`(${key} already defined, skipped)`)}`);
+    }
+  }
+  if (!changed) {
+    return;
+  }
+  pkg.scripts = existing;
+  await (0, import_promises10.writeFile)(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+__name(patchPackageJsonScripts, "patchPackageJsonScripts");
+function findAfterLastImport(content) {
+  const lastImportIndex = content.lastIndexOf("\nimport ");
+  if (lastImportIndex !== -1) {
+    const endOfLine = content.indexOf("\n", lastImportIndex + 1);
+    return endOfLine !== -1 ? endOfLine + 1 : content.length;
+  }
+  if (content.startsWith("import ")) {
+    const endOfLine = content.indexOf("\n");
+    return endOfLine !== -1 ? endOfLine + 1 : content.length;
+  }
+  return 0;
+}
+__name(findAfterLastImport, "findAfterLastImport");
+function patchAppModule(filePath, rootView) {
+  let content;
+  try {
+    content = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  } catch {
+    return "skipped";
+  }
+  let changed = false;
+  if (!content.includes("InertiaModule")) {
+    const insertAt = findAfterLastImport(content);
+    if (insertAt > 0) {
+      content = `${content.slice(0, insertAt)}import { InertiaModule } from '@dudousxd/nestjs-inertia';
+${content.slice(insertAt)}`;
+    }
+    const importsMatch = content.match(/imports\s*:\s*\[/);
+    if (importsMatch?.index !== void 0) {
+      const bracketPos = content.indexOf("[", importsMatch.index) + 1;
+      const indent = "    ";
+      content = `${content.slice(0, bracketPos)}
+${indent}InertiaModule.forRoot({
+${indent}  rootView: '${rootView}',
+${indent}}),${content.slice(bracketPos)}`;
+      changed = true;
+    }
+  }
+  if (!content.includes("HomeController")) {
+    const insertAt = findAfterLastImport(content);
+    if (insertAt > 0) {
+      content = `${content.slice(0, insertAt)}import { HomeController } from './home.controller';
+${content.slice(insertAt)}`;
+    }
+    const controllersMatch = content.match(/controllers\s*:\s*\[/);
+    if (controllersMatch?.index !== void 0) {
+      const bracketPos = content.indexOf("[", controllersMatch.index) + 1;
+      const indent = "    ";
+      content = `${content.slice(0, bracketPos)}
+${indent}HomeController,${content.slice(bracketPos)}`;
+      changed = true;
+    }
+  }
+  if (!changed) return "already";
+  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
+  return "patched";
+}
+__name(patchAppModule, "patchAppModule");
+function patchMainTs(filePath) {
+  let content;
+  try {
+    content = (0, import_node_fs.readFileSync)(filePath, "utf8");
+  } catch {
+    return "skipped";
+  }
+  if (content.includes("setupInertiaVite")) return "already";
+  const insertAt = findAfterLastImport(content);
+  if (insertAt > 0) {
+    content = `${content.slice(0, insertAt)}import { setupInertiaVite } from '@dudousxd/nestjs-inertia-vite';
+${content.slice(insertAt)}`;
+  }
+  const createMatch = content.match(/(?:const|let)\s+(\w+)\s*=\s*await\s+NestFactory\.create[^;]+;/);
+  if (!createMatch || createMatch.index === void 0) return "skipped";
+  const appVarName = createMatch[1];
+  const insertAfterPos = createMatch.index + createMatch[0].length;
+  const viteSetup = `
+  // Inertia + Vite integration (dev: HMR middleware, prod: static assets)
+  await setupInertiaVite(${appVarName}, {
+    mode: process.env.NODE_ENV ?? 'development',
+    root: 'inertia',
+    publicDir: 'dist/inertia/client',
+    outDir: 'dist/inertia',
+  });`;
+  content = `${content.slice(0, insertAfterPos)}
+${viteSetup}${content.slice(insertAfterPos)}`;
+  (0, import_node_fs.writeFileSync)(filePath, content, "utf8");
+  return "patched";
+}
+__name(patchMainTs, "patchMainTs");
+function configTemplate(framework) {
+  const glob = framework === "react" ? "inertia/pages/**/*.tsx" : framework === "vue" ? "inertia/pages/**/*.vue" : "inertia/pages/**/*.svelte";
+  return `import { defineConfig } from '@dudousxd/nestjs-inertia-codegen';
+
+export default defineConfig({
+  pages: {
+    glob: '${glob}',
+  },
+});
+`;
+}
+__name(configTemplate, "configTemplate");
+var DTS_TEMPLATE = `// Auto-generated by nestjs-inertia-codegen. Commit this file.
+// Re-run \`nestjs-inertia codegen\` to refresh after adding/removing pages.
+
+import '.nestjs-inertia/index.js';
+
+declare module '@dudousxd/nestjs-inertia' {
+  interface InertiaRegistry {
+    pages: import('.nestjs-inertia/pages.js').InertiaPages;
+    shared: import('.nestjs-inertia/shared.js').InertiaSharedProps;
+    routes: import('.nestjs-inertia/routes.js').RouteParamsMap;
+  }
+}
+`;
+function htmlShellTemplate(framework, _engine) {
+  const ext = framework === "react" ? "tsx" : "ts";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>My App</title>
+  @inertiaHead
+</head>
+<body>
+  @inertia
+  @vite('inertia/app.${ext}')
+</body>
+</html>
+`;
+}
+__name(htmlShellTemplate, "htmlShellTemplate");
+function viteConfigTemplate(framework) {
+  const pluginOption = `{ ${framework}: true }`;
+  return `import { defineConfig } from 'vite';
+import nestInertia from '@dudousxd/nestjs-inertia-vite/plugin';
+
+export default defineConfig({
+  plugins: [nestInertia(${pluginOption})],
+});
+`;
+}
+__name(viteConfigTemplate, "viteConfigTemplate");
+function entryPointTemplate(framework) {
+  if (framework === "react") {
+    return `import { createRoot } from 'react-dom/client';
+import { createInertiaApp } from '@inertiajs/react';
+
+createInertiaApp({
+  resolve: (name) => {
+    const pages = import.meta.glob('./pages/*.tsx', { eager: true });
+    return (pages as Record<string, unknown>)[\`./pages/\${name}.tsx\`];
+  },
+  setup({ el, App, props }) {
+    createRoot(el!).render(<App {...props} />);
+  },
+});
+`;
+  }
+  if (framework === "vue") {
+    return `import { createApp, h } from 'vue';
+import { createInertiaApp } from '@inertiajs/vue3';
+
+createInertiaApp({
+  resolve: (name) => {
+    const pages = import.meta.glob('./pages/*.vue', { eager: true });
+    return (pages as Record<string, unknown>)[\`./pages/\${name}.vue\`];
+  },
+  setup({ el, App, props, plugin }) {
+    createApp({ render: () => h(App, props) }).use(plugin).mount(el!);
+  },
+});
+`;
+  }
+  return `import { mount } from 'svelte';
+import { createInertiaApp } from '@inertiajs/svelte';
+
+createInertiaApp({
+  resolve: (name) => {
+    const pages = import.meta.glob('./pages/*.svelte', { eager: true });
+    return (pages as Record<string, unknown>)[\`./pages/\${name}.svelte\`];
+  },
+  setup({ el, App, props }) {
+    mount(App, { target: el!, props });
+  },
+});
+`;
+}
+__name(entryPointTemplate, "entryPointTemplate");
+function samplePageTemplate(framework) {
+  if (framework === "react") {
+    return `export type ComponentProps = {
+  greeting: string;
+};
+
+export default function Home({ greeting }: ComponentProps) {
+  return (
+    <main>
+      <h1>{greeting}</h1>
+      <p>Edit this page at <code>inertia/pages/Home.tsx</code></p>
+    </main>
+  );
+}
+`;
+  }
+  if (framework === "vue") {
+    return `<script setup lang="ts">
+defineProps<{ greeting: string }>();
+</script>
+
+<template>
+  <main>
+    <h1>{{ greeting }}</h1>
+    <p>Edit this page at <code>inertia/pages/Home.vue</code></p>
+  </main>
+</template>
+`;
+  }
+  return `<script lang="ts">
+  let { greeting } = $props<{ greeting: string }>();
+</script>
+
+<main>
+  <h1>{greeting}</h1>
+  <p>Edit this page at <code>inertia/pages/Home.svelte</code></p>
+</main>
+`;
+}
+__name(samplePageTemplate, "samplePageTemplate");
+var SAMPLE_CONTROLLER = `import { Controller, Get } from '@nestjs/common';
+import { Inertia } from '@dudousxd/nestjs-inertia';
+
+@Controller()
+export class HomeController {
+  @Get('/')
+  @Inertia('Home')
+  index() {
+    return { greeting: 'Welcome to NestJS + Inertia.js!' };
+  }
+}
+`;
+async function runInit(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  console.log(`
+${bold("nestjs-inertia init")}`);
+  let framework = await detectFramework(cwd);
+  if (!framework) {
+    framework = await promptFramework();
+  }
+  const engine = await detectTemplateEngine(cwd);
+  const engineLabel = engine === "html" ? "plain HTML" : engine;
+  const frameworkLabel = framework.charAt(0).toUpperCase() + framework.slice(1);
+  console.log(`
+  Detected: ${bold(`${frameworkLabel} + ${engineLabel}`)}`);
+  const shellFileName = engine === "html" ? "index.html" : `index.${engine === "handlebars" ? "hbs" : engine}`;
+  const entryExt = framework === "react" ? "tsx" : "ts";
+  const pageExt = framework === "react" ? "tsx" : framework === "vue" ? "vue" : "svelte";
+  logSection("Scaffold files");
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "nestjs-inertia.config.ts"), configTemplate(framework), "nestjs-inertia.config.ts");
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "nestjs-inertia.d.ts"), DTS_TEMPLATE, "nestjs-inertia.d.ts");
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "inertia", shellFileName), htmlShellTemplate(framework, engine), `inertia/${shellFileName}`);
+  await handleViteConfig(cwd, framework);
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "inertia", `app.${entryExt}`), entryPointTemplate(framework), `inertia/app.${entryExt}`);
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "inertia", "pages", `Home.${pageExt}`), samplePageTemplate(framework), `inertia/pages/Home.${pageExt}`);
+  await writeIfNotExists((0, import_node_path11.join)(cwd, "src", "home.controller.ts"), SAMPLE_CONTROLLER, "src/home.controller.ts");
+  logSection("Patch existing files");
+  const rootView = engine === "html" ? "inertia/index.html" : `inertia/index.${engine === "handlebars" ? "hbs" : engine}`;
+  const appModulePath = (0, import_node_path11.join)(cwd, "src", "app.module.ts");
+  const appModuleResult = patchAppModule(appModulePath, rootView);
+  if (appModuleResult === "patched") {
+    logPatched("src/app.module.ts", "added InertiaModule.forRoot");
+    logPatched("src/app.module.ts", "added HomeController to controllers");
+  } else if (appModuleResult === "already") {
+    console.log(`  ${cyan("\u2192")} src/app.module.ts ${dim("(InertiaModule already registered, skipped)")}`);
+  } else {
+    logWarning("src/app.module.ts not found \u2014 add InertiaModule.forRoot() manually");
+  }
+  const mainTsPath = (0, import_node_path11.join)(cwd, "src", "main.ts");
+  const mainTsResult = patchMainTs(mainTsPath);
+  if (mainTsResult === "patched") {
+    logPatched("src/main.ts", "added setupInertiaVite after NestFactory.create");
+  } else if (mainTsResult === "already") {
+    console.log(`  ${cyan("\u2192")} src/main.ts ${dim("(setupInertiaVite already present, skipped)")}`);
+  } else {
+    logWarning("src/main.ts not found \u2014 add setupInertiaVite() manually");
+  }
+  await patchGitignore((0, import_node_path11.join)(cwd, ".gitignore"));
+  await patchPackageJsonScripts(cwd, {
+    "build:client": "vite build",
+    "build:ssr": "VITE_SSR=1 vite build --ssr"
+  });
+  logSection("Install dependencies");
+  const pkg = await readPackageJson(cwd);
+  const installedDeps = allDeps(pkg);
+  const pkgManager = await detectPackageManager(cwd);
+  const commonDeps = [
+    "vite"
+  ].filter((d) => !installedDeps.includes(d));
+  let frameworkDeps = [];
+  let frameworkDevDeps = [];
+  if (framework === "react") {
+    const needed = [
+      "@inertiajs/react",
+      "react",
+      "react-dom"
+    ].filter((d) => !installedDeps.includes(d));
+    const neededDev = [
+      "@types/react",
+      "@types/react-dom",
+      "@vitejs/plugin-react"
+    ].filter((d) => !installedDeps.includes(d));
+    frameworkDeps = needed;
+    frameworkDevDeps = neededDev;
+  } else if (framework === "vue") {
+    const needed = [
+      "@inertiajs/vue3",
+      "vue"
+    ].filter((d) => !installedDeps.includes(d));
+    const neededDev = [
+      "@vitejs/plugin-vue"
+    ].filter((d) => !installedDeps.includes(d));
+    frameworkDeps = needed;
+    frameworkDevDeps = neededDev;
+  } else {
+    const needed = [
+      "@inertiajs/svelte",
+      "svelte"
+    ].filter((d) => !installedDeps.includes(d));
+    const neededDev = [
+      "@sveltejs/vite-plugin-svelte"
+    ].filter((d) => !installedDeps.includes(d));
+    frameworkDeps = needed;
+    frameworkDevDeps = neededDev;
+  }
+  const depsToInstall = [
+    ...commonDeps,
+    ...frameworkDeps
+  ];
+  const devDepsToInstall = frameworkDevDeps;
+  if (!opts.skipInstall) {
+    installDeps(pkgManager, depsToInstall, false);
+    installDeps(pkgManager, devDepsToInstall, true);
+  }
+  console.log(`
+${green("\u2713")} Setup complete! Run: ${bold("nest start --watch")}
+`);
+}
+__name(runInit, "runInit");
+
+// src/cli/main.ts
+async function run(argv) {
+  const cli = (0, import_cac.cac)("nestjs-inertia");
+  cli.command("codegen", "Generate typed artifacts from your NestJS + Inertia app").option("--watch", "Watch for file changes and re-generate automatically").action(async (opts) => {
+    await runCodegen({
+      watch: Boolean(opts.watch),
+      cwd: process.cwd()
+    });
+  });
+  cli.command("init", "Initialise nestjs-inertia-codegen in the current project").action(async () => {
+    await runInit({
+      cwd: process.cwd()
+    });
+  });
+  cli.help();
+  cli.version(VERSION);
+  try {
+    cli.parse([
+      "node",
+      "nestjs-inertia",
+      ...argv
+    ], {
+      run: false
+    });
+    await cli.runMatchedCommand();
+    return 0;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[nestjs-inertia] Error: ${message}`);
+    return 1;
+  }
+}
+__name(run, "run");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});
+//# sourceMappingURL=main.cjs.map