@dudousxd/nestjs-codegen 0.2.1 → 0.4.0

package/dist/cli/main.cjs

@@ -54,112 +54,9 @@ var CodegenError = class extends Error {
   }
 };
 
-// src/adapters/zod.ts
-function toObjectKey(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-function messageSuffix(messageRaw2) {
-  return messageRaw2 ? `{ message: ${messageRaw2} }` : "";
-}
-function renderStringChecks(checks) {
-  let out = "";
-  for (const c of checks) {
-    switch (c.check) {
-      case "email":
-        out += `.email(${messageSuffix(c.messageRaw)})`;
-        break;
-      case "url":
-        out += `.url(${messageSuffix(c.messageRaw)})`;
-        break;
-      case "uuid":
-        out += `.uuid(${messageSuffix(c.messageRaw)})`;
-        break;
-      case "regex":
-        out += `.regex(${c.pattern})`;
-        break;
-      case "min":
-        out += `.min(${c.value})`;
-        break;
-      case "max":
-        out += `.max(${c.value})`;
-        break;
-    }
-  }
-  return out;
-}
-function render(node, ctx) {
-  switch (node.kind) {
-    case "string":
-      return `z.string()${renderStringChecks(node.checks)}`;
-    case "number": {
-      let out = "z.number()";
-      for (const c of node.checks) {
-        if (c.check === "int") out += ".int()";
-        else if (c.check === "positive") out += ".positive()";
-        else if (c.check === "negative") out += ".negative()";
-        else if (c.check === "min") out += `.min(${c.value})`;
-        else if (c.check === "max") out += `.max(${c.value})`;
-      }
-      return out;
-    }
-    case "boolean":
-      return "z.boolean()";
-    case "date":
-      return "z.coerce.date()";
-    case "unknown":
-      return node.note ? `z.unknown() /* ${node.note} */` : "z.unknown()";
-    case "instanceof":
-      return `z.instanceof(${node.ctor})`;
-    case "enum":
-      return `z.enum([${node.literals.join(", ")}])`;
-    case "literal":
-      return `z.literal(${node.raw})`;
-    case "union":
-      return `z.union([${node.options.map((o) => render(o, ctx)).join(", ")}])`;
-    case "object": {
-      if (node.fields.length === 0) {
-        return node.passthrough ? "z.object({}).passthrough()" : "z.object({})";
-      }
-      const inner = node.fields.map((f) => `${toObjectKey(f.key)}: ${render(f.value, ctx)}`).join(", ");
-      return `z.object({ ${inner} })${node.passthrough ? ".passthrough()" : ""}`;
-    }
-    case "array":
-      return `z.array(${render(node.element, ctx)})`;
-    case "optional":
-      return `${render(node.inner, ctx)}.optional()`;
-    case "ref":
-      return node.name;
-    case "lazyRef":
-      return `z.lazy(() => ${node.name})`;
-    case "annotated": {
-      const comments = node.unmappable.map((n) => `/* @${n}: not translatable to zod (server-only) */`).join(" ");
-      return `${render(node.inner, ctx)} ${comments}`;
-    }
-  }
-}
-var zodAdapter = {
-  name: "zod",
-  importStatements(usage) {
-    return usage.used ? ["import { z } from 'zod';"] : [];
-  },
-  render,
-  inferType(schemaConst) {
-    return `z.infer<typeof ${schemaConst}>`;
-  },
-  renderModule(mod) {
-    const ctx = { named: mod.named };
-    const namedNestedSchemas = /* @__PURE__ */ new Map();
-    for (const [name, node] of mod.named) {
-      namedNestedSchemas.set(name, render(node, ctx));
-    }
-    return { schemaText: render(mod.root, ctx), namedNestedSchemas, warnings: mod.warnings };
-  }
-};
-
 // src/adapters/registry.ts
 function resolveAdapter(option) {
   if (typeof option !== "string") return option;
-  if (option === "zod") return zodAdapter;
   const pkg = `@dudousxd/nestjs-codegen-${option}`;
   const named = `${option}Adapter`;
   throw new ConfigError(
@@ -209,8 +106,21 @@ If this is intentional, move the file inside your project directory.`
     );
   }
 }
+function validateUserConfig(userConfig) {
+  if (userConfig.validation == null) {
+    throw new ConfigError(
+      "validation adapter is required \u2014 install @dudousxd/nestjs-codegen-zod and pass zodAdapter, or use @dudousxd/nestjs-codegen-valibot / -arktype"
+    );
+  }
+  if (userConfig.pages && typeof userConfig.pages.glob !== "string") {
+    throw new ConfigError(
+      "Config validation failed: `pages.glob` must be a string when `pages` is set"
+    );
+  }
+}
 function applyDefaults(userConfig, cwd) {
-  const outDir = userConfig.codegen?.outDir ? resolveAbsolute(cwd, userConfig.codegen.outDir) : (0, import_node_path.join)(cwd, ".nestjs-inertia");
+  validateUserConfig(userConfig);
+  const outDir = userConfig.codegen?.outDir ? resolveAbsolute(cwd, userConfig.codegen.outDir) : (0, import_node_path.join)(cwd, ".nestjs-codegen");
   const resolvedCwd = userConfig.codegen?.cwd ? resolveAbsolute(cwd, userConfig.codegen.cwd) : cwd;
   let app = null;
   if (userConfig.app) {
@@ -228,7 +138,8 @@ function applyDefaults(userConfig, cwd) {
   }
   return {
     extensions: userConfig.extensions ?? [],
-    validation: resolveAdapter(userConfig.validation ?? "zod"),
+    // Non-null: validateUserConfig() above throws when `validation` is absent.
+    validation: resolveAdapter(userConfig.validation),
     pages: userConfig.pages ? {
       glob: userConfig.pages.glob,
       propsExport: userConfig.pages.propsExport ?? "ComponentProps",
@@ -282,18 +193,12 @@ Run \`nestjs-codegen init\` to create a starter config.`
       `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\` must be a string when \`pages\` is set (${configPath})`
-    );
-  }
   return applyDefaults(userConfig, resolvedCwd);
 }
 
 // src/generate.ts
 var import_promises9 = require("fs/promises");
-var import_node_path9 = require("path");
-var import_ts_morph3 = require("ts-morph");
+var import_node_path10 = require("path");
 
 // src/discovery/pages.ts
 var import_promises2 = require("fs/promises");
@@ -348,6 +253,7 @@ function extractPropsSource(source, exportName) {
 }
 
 // src/discovery/shared-props.ts
+var import_node_path3 = require("path");
 var import_ts_morph = require("ts-morph");
 function discoverSharedProps(project, moduleEntry) {
   try {
@@ -368,6 +274,31 @@ function discoverSharedProps(project, moduleEntry) {
     return null;
   }
 }
+function discoverSharedPropsFromConfig(config) {
+  if (!config.app?.moduleEntry) return null;
+  try {
+    const tsconfigPath = config.app.tsconfig ?? (0, import_node_path3.join)(config.codegen.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, strict: false }
+      });
+    }
+    return discoverSharedProps(project, config.app.moduleEntry);
+  } catch {
+    return null;
+  }
+}
 function findForRootCall(sourceFile) {
   const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
@@ -387,9 +318,9 @@ function findForRootCall(sourceFile) {
 function findShareInitializer(forRootCall) {
   if (!import_ts_morph.Node.isCallExpression(forRootCall)) return null;
   const args = forRootCall.getArguments();
-  const firstArg3 = args[0];
-  if (!firstArg3 || !import_ts_morph.Node.isObjectLiteralExpression(firstArg3)) return null;
-  for (const prop of firstArg3.getProperties()) {
+  const firstArg2 = args[0];
+  if (!firstArg2 || !import_ts_morph.Node.isObjectLiteralExpression(firstArg2)) return null;
+  for (const prop of firstArg2.getProperties()) {
     if (import_ts_morph.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
       return prop.getInitializer() ?? null;
     }
@@ -488,9 +419,9 @@ function extractFromReturnTypeAnnotation(typeNode) {
     const typeName = typeNode.getTypeName();
     if (import_ts_morph.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
       const typeArgs = typeNode.getTypeArguments();
-      const firstArg3 = typeArgs[0];
-      if (firstArg3) {
-        return extractFromReturnTypeAnnotation(firstArg3);
+      const firstArg2 = typeArgs[0];
+      if (firstArg2) {
+        return extractFromReturnTypeAnnotation(firstArg2);
       }
       return null;
     }
@@ -596,25 +527,14 @@ function inferExpressionType(node) {
 
 // src/emit/emit-api.ts
 var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 
 // src/extension/registry.ts
 var import_ts_morph2 = require("ts-morph");
 function resolveApiSlots(extensions) {
-  let transport;
-  let transportOwner;
   let layer;
   let layerOwner;
   for (const ext of extensions) {
-    if (ext.apiTransport) {
-      if (transport) {
-        throw new CodegenError(
-          `api transport claimed by both "${transportOwner}" and "${ext.name}" \u2014 only one extension may set apiTransport.`
-        );
-      }
-      transport = ext.apiTransport;
-      transportOwner = ext.name;
-    }
     if (ext.apiClientLayer) {
       if (layer) {
         throw new CodegenError(
@@ -626,11 +546,22 @@ function resolveApiSlots(extensions) {
     }
   }
   return {
-    ...transport ? { transport } : {},
     ...layer ? { layer } : {}
   };
 }
 var CORE_FILES = /* @__PURE__ */ new Set(["routes.ts", "api.ts", "forms.ts", "index.d.ts", "pages.d.ts"]);
+function mergeExclusive(target, incoming, {
+  owner,
+  describe
+}) {
+  for (const [key, value] of incoming) {
+    const prev = target.get(key);
+    if (prev !== void 0) {
+      throw new CodegenError(describe(key, prev.owner, owner));
+    }
+    target.set(key, { value, owner });
+  }
+}
 function createExtensionContext(config, getRoutes) {
   let project;
   return {
@@ -675,29 +606,36 @@ async function collectEmittedFiles(extensions, ctx) {
           `Extension "${ext.name}" tried to emit the core-owned file "${file.path}". Core files (${[...CORE_FILES].join(", ")}) cannot be produced by extensions.`
         );
       }
-      const prev = owners.get(key);
-      if (prev !== void 0) {
-        throw new CodegenError(
-          `Output file "${file.path}" is emitted by both "${prev}" and "${ext.name}". Two extensions cannot write the same file.`
-        );
-      }
-      owners.set(key, ext.name);
+      mergeExclusive(owners, [[key, file]], {
+        owner: ext.name,
+        describe: (_key, prevOwner, owner) => `Output file "${file.path}" is emitted by both "${prevOwner}" and "${owner}". Two extensions cannot write the same file.`
+      });
       files.push(file);
     }
   }
   return files;
 }
 
+// src/extension/types.ts
+function requestShape(route) {
+  const cs = route.contract?.contractSource;
+  const isGet = route.method.toUpperCase() === "GET";
+  const isQuery = isGet || !!cs?.filterFields?.length;
+  const hasBody = !!cs?.bodyRef || cs?.body != null && cs.body !== "never";
+  const hasQuery = isGet || !!cs?.queryRef || cs?.query != null && cs.query !== "never";
+  return { isGet, isQuery, hasBody, hasQuery };
+}
+
 // src/emit/emit-api.ts
 async function emitApi(routes, outDir, opts = {}) {
   await (0, import_promises3.mkdir)(outDir, { recursive: true });
   const content = buildApiFile(routes, outDir, opts);
-  await (0, import_promises3.writeFile)((0, import_node_path3.join)(outDir, "api.ts"), content, "utf8");
+  await (0, import_promises3.writeFile)((0, import_node_path4.join)(outDir, "api.ts"), content, "utf8");
 }
 function splitName(name) {
   return name.split(".");
 }
-function toObjectKey2(segment) {
+function toObjectKey(segment) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
     return segment;
   }
@@ -790,7 +728,7 @@ function emitFilterQueryType(c) {
 }
 function buildResponseType(c, outDir) {
   if (c.controllerRef) {
-    let relPath = (0, import_node_path3.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    let relPath = (0, import_node_path4.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
     if (!relPath.startsWith(".")) relPath = `./${relPath}`;
     return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
   }
@@ -804,7 +742,7 @@ function emitRouterTypeBlock(tree, indent, outDir) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey2(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "leaf") {
       const c = node;
       const method = c.method.toUpperCase();
@@ -830,15 +768,12 @@ function emitRouterTypeBlock(tree, indent, outDir) {
   return lines;
 }
 function buildRequestModel(c) {
-  const isGet = c.method.toUpperCase() === "GET";
   const m = c.method.toLowerCase();
   const flat = JSON.stringify(c.name);
   const path = JSON.stringify(c.path);
   const TA = buildRouterTypeAccess(c.name);
   const withParams = hasPathParams(c.params);
-  const hasBody = !!c.contractSource.bodyRef || c.contractSource.body != null && c.contractSource.body !== "never";
-  const isQuery = isGet || !!c.contractSource.filterFields?.length;
-  const hasQuery = isGet || !!c.contractSource.queryRef || c.contractSource.query != null && c.contractSource.query !== "never";
+  const { isGet, isQuery, hasBody, hasQuery } = requestShape(c.route);
   const fields = [];
   if (withParams) fields.push(`params: ${TA}['params']`);
   if (hasQuery) fields.push(`query?: ${TA}['query']`);
@@ -860,7 +795,6 @@ function buildRequestModel(c) {
     urlExpr,
     optsExpr,
     responseType: `${TA}['response']`,
-    bodyType: `${TA}['body']`,
     queryKeyExpr: `[${flat}, input] as const`
   };
 }
@@ -908,7 +842,7 @@ function emitApiObjectBlock(tree, indent, p) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey2(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "branch") {
       lines.push(`${pad}${objKey}: {`);
       lines.push(...emitApiObjectBlock(node.children, indent + 2, p));
@@ -916,30 +850,28 @@ function emitApiObjectBlock(tree, indent, p) {
       continue;
     }
     const req = buildRequestModel(node);
-    const route = {
-      method: node.method,
-      path: node.path,
-      name: node.name,
-      params: node.params,
-      contract: { contractSource: node.contractSource },
-      ...node.controllerRef ? { controllerRef: node.controllerRef } : {}
+    const leaf = {
+      route: node.route,
+      request: req,
+      requestExpr: renderFetcherRequest(req)
     };
-    const leaf = { route, request: req, requestExpr: "" };
-    leaf.requestExpr = p.transport ? p.transport.renderRequest(leaf, p.ctx) : renderFetcherRequest(req);
-    const members = {};
-    if (p.layer) Object.assign(members, p.layer.buildMembers(leaf.requestExpr, leaf, p.ctx));
+    const owned = /* @__PURE__ */ new Map();
+    if (p.layer) {
+      mergeExclusive(owned, Object.entries(p.layer.buildMembers(leaf.requestExpr, leaf, p.ctx)), {
+        owner: p.layer.name,
+        describe: (name, prevOwner, owner) => `api member "${name}" on route "${req.routeName}" is contributed by more than one extension (conflict between "${prevOwner}" and "${owner}").`
+      });
+    }
     for (const ext of p.memberExts) {
       const extra = ext.apiMembers?.(leaf, p.ctx);
       if (!extra) continue;
-      for (const [name, value] of Object.entries(extra)) {
-        if (name in members) {
-          throw new Error(
-            `api member "${name}" on route "${req.routeName}" is contributed by more than one extension (conflict at "${ext.name}").`
-          );
-        }
-        members[name] = value;
-      }
+      mergeExclusive(owned, Object.entries(extra), {
+        owner: ext.name,
+        describe: (name, prevOwner, owner) => `api member "${name}" on route "${req.routeName}" is contributed by more than one extension (conflict between "${prevOwner}" and "${owner}").`
+      });
     }
+    const members = {};
+    for (const [name, { value }] of owned) members[name] = value;
     lines.push(...renderLeaf(pad, objKey, req, leaf.requestExpr, members));
   }
   return lines;
@@ -948,10 +880,82 @@ function buildRouterTypeAccess(name) {
   const segments = splitName(name);
   return `ApiRouter${segments.map((s) => `[${JSON.stringify(s)}]`).join("")}`;
 }
+var RESOLVER_HELPERS = [
+  // --- Recursive helper type _RouterAt: walks nested ApiRouter by dot-path ---
+  "type _RouterAt<R, P extends string> = P extends `${infer Head}.${infer Tail}`",
+  "  ? Head extends keyof R ? _RouterAt<R[Head], Tail> : never",
+  "  : P extends keyof R ? R[P] : never;",
+  "",
+  // --- ResolveByName: resolve a field from a dot-path name ---
+  "type ResolveByName<K extends string, Field extends string> = _RouterAt<ApiRouter, K> extends infer R ? Field extends keyof R ? R[Field] : never : never;",
+  "",
+  // --- ResolveByPath: scan all leaves for matching method + url ---
+  // Flattens ApiRouter recursively and finds the entry whose method === M and url === U.
+  "type _LeafValues<T> = T extends { method: string; url: string }",
+  "  ? T",
+  "  : T extends object ? _LeafValues<T[keyof T]> : never;",
+  "",
+  "type ResolveByPath<M extends string, U extends string, Field extends string> = _LeafValues<ApiRouter> extends infer L",
+  "  ? L extends { method: M; url: U }",
+  "    ? Field extends keyof L ? L[Field] : never",
+  "    : never",
+  "  : never;",
+  ""
+];
+var ROUTE_NAMESPACE = [
+  "export namespace Route {",
+  '  export type Response<K extends string> = ResolveByName<K, "response">;',
+  '  export type Body<K extends string> = ResolveByName<K, "body">;',
+  '  export type Query<K extends string> = ResolveByName<K, "query">;',
+  '  export type Params<K extends string> = ResolveByName<K, "params">;',
+  '  export type Error<K extends string> = ResolveByName<K, "error">;',
+  '  export type FilterFields<K extends string> = ResolveByName<K, "filterFields">;',
+  "  export type Request<K extends string> = {",
+  "    body: Body<K>;",
+  "    query: Query<K>;",
+  "    params: Params<K>;",
+  "  };",
+  "}",
+  ""
+];
+var PATH_NAMESPACE = [
+  "export namespace Path {",
+  '  export type Response<M extends string, U extends string> = ResolveByPath<M, U, "response">;',
+  '  export type Body<M extends string, U extends string> = ResolveByPath<M, U, "body">;',
+  '  export type Query<M extends string, U extends string> = ResolveByPath<M, U, "query">;',
+  '  export type Params<M extends string, U extends string> = ResolveByPath<M, U, "params">;',
+  '  export type Error<M extends string, U extends string> = ResolveByPath<M, U, "error">;',
+  '  export type FilterFields<M extends string, U extends string> = ResolveByPath<M, U, "filterFields">;',
+  "}",
+  ""
+];
+var EMPTY_ROUTE_NAMESPACE = [
+  "export namespace Route {",
+  "  export type Response<K extends string> = never;",
+  "  export type Body<K extends string> = never;",
+  "  export type Query<K extends string> = never;",
+  "  export type Params<K extends string> = never;",
+  "  export type Error<K extends string> = never;",
+  "  export type FilterFields<K extends string> = never;",
+  "  export type Request<K extends string> = { body: never; query: never; params: never };",
+  "}",
+  ""
+];
+var EMPTY_PATH_NAMESPACE = [
+  "export namespace Path {",
+  "  export type Response<M extends string, U extends string> = never;",
+  "  export type Body<M extends string, U extends string> = never;",
+  "  export type Query<M extends string, U extends string> = never;",
+  "  export type Params<M extends string, U extends string> = never;",
+  "  export type Error<M extends string, U extends string> = never;",
+  "  export type FilterFields<M extends string, U extends string> = never;",
+  "}",
+  ""
+];
 function buildApiFile(routes, outDir, opts = {}) {
   const fetcherImportPath = opts.fetcherImportPath;
   const extensions = opts.extensions ?? [];
-  const { transport, layer } = resolveApiSlots(extensions);
+  const { layer } = resolveApiSlots(extensions);
   const memberExts = extensions.filter((e) => e.apiMembers);
   const headerExts = extensions.filter((e) => e.apiHeader);
   const contracted = routes.filter((r) => r.contract);
@@ -996,7 +1000,6 @@ function buildApiFile(routes, outDir, opts = {}) {
     seenImports.add(imp);
     extImports.push(imp);
   };
-  for (const imp of transport?.imports?.(ctx) ?? []) pushImport(imp);
   for (const imp of layer?.imports?.(ctx) ?? []) pushImport(imp);
   for (const ext of headerExts) {
     for (const imp of ext.apiHeader?.(ctx)?.imports ?? []) pushImport(imp);
@@ -1012,8 +1015,8 @@ function buildApiFile(routes, outDir, opts = {}) {
     const emittedNames = /* @__PURE__ */ new Set();
     for (const [filePath, names] of importsByFile) {
       let relPath;
-      if ((0, import_node_path3.isAbsolute)(filePath)) {
-        relPath = (0, import_node_path3.relative)(outDir, filePath).replace(/\.ts$/, "");
+      if ((0, import_node_path4.isAbsolute)(filePath)) {
+        relPath = (0, import_node_path4.relative)(outDir, filePath).replace(/\.ts$/, "");
         if (!relPath.startsWith(".")) relPath = `./${relPath}`;
       } else {
         relPath = filePath;
@@ -1041,27 +1044,8 @@ function buildApiFile(routes, outDir, opts = {}) {
     lines.push("}");
     lines.push("export type Api = ReturnType<typeof createApi>;");
     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 FilterFields<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("  export type FilterFields<M extends string, U extends string> = never;");
-    lines.push("}");
-    lines.push("");
+    lines.push(...EMPTY_ROUTE_NAMESPACE);
+    lines.push(...EMPTY_PATH_NAMESPACE);
     return lines.join("\n");
   }
   const tree = /* @__PURE__ */ new Map();
@@ -1079,7 +1063,8 @@ function buildApiFile(routes, outDir, opts = {}) {
       path: r.path,
       params: r.params,
       controllerRef: r.controllerRef,
-      contractSource: c.contractSource
+      contractSource: c.contractSource,
+      route: r
     };
     insertIntoTree(tree, segments, leaf, name);
   }
@@ -1092,7 +1077,6 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("  return {");
   lines.push(
     ...emitApiObjectBlock(tree, 4, {
-      ...transport ? { transport } : {},
       ...layer ? { layer } : {},
       memberExts,
       ctx
@@ -1103,61 +1087,9 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("");
   lines.push("export type Api = ReturnType<typeof createApi>;");
   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 FilterFields<K extends string> = ResolveByName<K, "filterFields">;');
-  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(
-    '  export type FilterFields<M extends string, U extends string> = ResolveByPath<M, U, "filterFields">;'
-  );
-  lines.push("}");
-  lines.push("");
+  lines.push(...RESOLVER_HELPERS);
+  lines.push(...ROUTE_NAMESPACE);
+  lines.push(...PATH_NAMESPACE);
   for (const ext of headerExts) {
     const statements = ext.apiHeader?.(ctx)?.statements;
     if (statements?.length) {
@@ -1169,7 +1101,7 @@ function buildApiFile(routes, outDir, opts = {}) {
 
 // src/emit/emit-cache.ts
 var import_promises4 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 async function emitCache(pages, outDir) {
   await (0, import_promises4.mkdir)(outDir, { recursive: true });
   const entries = await Promise.all(
@@ -1183,95 +1115,21 @@ async function emitCache(pages, outDir) {
     })
   );
   const cache = { pages: entries };
-  await (0, import_promises4.writeFile)((0, import_node_path4.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises4.writeFile)((0, import_node_path5.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 
 // src/emit/emit-forms.ts
 var import_promises5 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 async function emitForms(routes, outDir, config, adapter) {
   if (config && config.enabled === false) return false;
-  if (adapter && adapter.name !== "zod") {
-    const content2 = buildFormsFileWithAdapter(routes, adapter);
-    if (content2 === null) return false;
-    await (0, import_promises5.mkdir)(outDir, { recursive: true });
-    await (0, import_promises5.writeFile)((0, import_node_path5.join)(outDir, "forms.ts"), content2, "utf8");
-    return true;
-  }
-  const entries = collectFormEntries(routes);
-  if (entries.length === 0) return false;
+  const content = buildFormsFileWithAdapter(routes, outDir, adapter, config);
+  if (content === null) return false;
   await (0, import_promises5.mkdir)(outDir, { recursive: true });
-  const content = buildFormsFile(entries, outDir, config);
-  await (0, import_promises5.writeFile)((0, import_node_path5.join)(outDir, "forms.ts"), content, "utf8");
+  await (0, import_promises5.writeFile)((0, import_node_path6.join)(outDir, "forms.ts"), content, "utf8");
   return true;
 }
-function buildFormsFileWithAdapter(routes, adapter) {
-  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
-  const methodNameCounts = /* @__PURE__ */ new Map();
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    if (!cs.bodySchema && !cs.querySchema) continue;
-    methodNameCounts.set(
-      deriveBaseName(route.name).method,
-      (methodNameCounts.get(deriveBaseName(route.name).method) ?? 0) + 1
-    );
-  }
-  const named = /* @__PURE__ */ new Map();
-  const decls = [];
-  const mapEntries = [];
-  let used = false;
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    const { method, full } = deriveBaseName(route.name);
-    const base = (methodNameCounts.get(method) ?? 0) > 1 ? full : method;
-    const block = [];
-    if (cs.bodyZodText && !cs.bodySchema) {
-      block.push(
-        `// warning: ${route.name} body is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
-      );
-    }
-    let bodyConst;
-    if (cs.bodySchema) {
-      used = true;
-      const r = adapter.renderModule(cs.bodySchema);
-      for (const [n, t] of r.namedNestedSchemas) named.set(n, t);
-      bodyConst = `${base}BodySchema`;
-      block.push(`export const ${bodyConst} = ${r.schemaText};`);
-      block.push(`export type ${base}Body = ${adapter.inferType(bodyConst)};`);
-    }
-    if (cs.querySchema) {
-      used = true;
-      const r = adapter.renderModule(cs.querySchema);
-      for (const [n, t] of r.namedNestedSchemas) named.set(n, t);
-      const queryConst = `${base}QuerySchema`;
-      block.push(`export const ${queryConst} = ${r.schemaText};`);
-      block.push(`export type ${base}Query = ${adapter.inferType(queryConst)};`);
-    }
-    if (block.length === 0) continue;
-    decls.push(`// ${route.name}`, ...block, "");
-    if (bodyConst) mapEntries.push(`  ${JSON.stringify(route.name)}: ${bodyConst},`);
-  }
-  if (!used) return null;
-  const lines = ["// Generated by @dudousxd/nestjs-codegen. Do not edit."];
-  for (const imp of adapter.importStatements({ used: true })) lines.push(imp);
-  lines.push("");
-  if (named.size > 0) {
-    lines.push("// Hoisted nested schemas (shared across endpoints).");
-    for (const [n, t] of named) lines.push(`const ${n} = ${t};`);
-    lines.push("");
-  }
-  lines.push(...decls);
-  lines.push("/** Route name \u2192 body schema map. */");
-  lines.push("export const formSchemas = {");
-  lines.push(...mapEntries);
-  lines.push("} as const;");
-  lines.push("");
-  return lines.join("\n");
-}
-function hasSchema(src) {
-  return !!src && (src.ref !== null || src.text !== null);
-}
 function pascal(segment) {
   return segment.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
@@ -1281,124 +1139,16 @@ function deriveBaseName(routeName) {
   const full = segments.map(pascal).join("");
   return { method, full };
 }
-function collectFormEntries(routes) {
-  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
-  const methodNameCounts = /* @__PURE__ */ new Map();
-  const candidates = [];
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    const body = { ref: cs.bodyZodRef ?? null, text: cs.bodyZodText ?? null };
-    const query = { ref: cs.queryZodRef ?? null, text: cs.queryZodText ?? null };
-    if (!hasSchema(body) && !hasSchema(query)) continue;
-    const { method, full } = deriveBaseName(route.name);
-    methodNameCounts.set(method, (methodNameCounts.get(method) ?? 0) + 1);
-    candidates.push({ route, method, full });
-  }
-  const entries = [];
-  for (const { route, method, full } of candidates) {
-    const cs = route.contract.contractSource;
-    const collision = (methodNameCounts.get(method) ?? 0) > 1;
-    const baseName = collision ? full : method;
-    const body = { ref: cs.bodyZodRef ?? null, text: cs.bodyZodText ?? null };
-    const query = { ref: cs.queryZodRef ?? null, text: cs.queryZodText ?? null };
-    entries.push({
-      routeName: route.name,
-      baseName,
-      body: hasSchema(body) ? body : void 0,
-      query: hasSchema(query) ? query : void 0,
-      nestedSchemas: cs.formNestedSchemas ?? null,
-      warnings: cs.formWarnings ?? []
-    });
-  }
-  return entries;
-}
 function relImport(outDir, filePath) {
-  let relPath = (0, import_node_path5.relative)(outDir, filePath).replace(/\.ts$/, "");
+  let relPath = (0, import_node_path6.relative)(outDir, filePath).replace(/\.ts$/, "");
   if (!relPath.startsWith(".")) relPath = `./${relPath}`;
   return relPath;
 }
 function refRootIdentifier(refName) {
   return refName.split(".")[0] ?? refName;
 }
-function buildFormsFile(entries, outDir, config) {
-  const zodImport = config?.zodImport ?? "zod";
-  const lines = [
-    "// Generated by @dudousxd/nestjs-codegen. Do not edit.",
-    `import { z } from '${zodImport}';`
-  ];
-  const importsByFile = /* @__PURE__ */ new Map();
-  const refAlias = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const src of [entry.body, entry.query]) {
-      if (src?.ref && !src.text) {
-        const root = refRootIdentifier(src.ref.name);
-        const set = importsByFile.get(src.ref.filePath) ?? /* @__PURE__ */ new Set();
-        set.add(root);
-        importsByFile.set(src.ref.filePath, set);
-      }
-    }
-  }
-  if (importsByFile.size > 0) {
-    const emitted = /* @__PURE__ */ new Set();
-    for (const [filePath, roots] of [...importsByFile.entries()].sort()) {
-      const relPath = relImport(outDir, filePath);
-      const specifiers = [];
-      for (const root of [...roots].sort()) {
-        if (emitted.has(root)) {
-          const alias = `${root}_${emitted.size}`;
-          specifiers.push(`${root} as ${alias}`);
-          emitted.add(alias);
-          refAlias.set(`${filePath}\0${root}`, alias);
-        } else {
-          specifiers.push(root);
-          emitted.add(root);
-          refAlias.set(`${filePath}\0${root}`, root);
-        }
-      }
-      lines.push(`import { ${specifiers.join(", ")} } from '${relPath}';`);
-    }
-  }
-  lines.push("");
-  const { globalSchemas, renamesByEntry } = planNestedSchemas(entries);
-  if (globalSchemas.size > 0) {
-    lines.push("// Hoisted nested schemas (shared across endpoints).");
-    for (const [name, text] of globalSchemas) {
-      lines.push(`const ${name} = ${text};`);
-    }
-    lines.push("");
-  }
-  const mapEntries = [];
-  for (const entry of entries) {
-    lines.push(`// ${entry.routeName}`);
-    if (entry.warnings && entry.warnings.length > 0) {
-      for (const w of entry.warnings) {
-        lines.push(`// warning: ${w}`);
-      }
-    }
-    const rename = renamesByEntry.get(entry) ?? null;
-    if (entry.body) {
-      const schemaName = `${entry.baseName}BodySchema`;
-      const typeName = `${entry.baseName}Body`;
-      const text = applyRenames(renderSchema(entry.body, outDir, refAlias), rename);
-      lines.push(`export const ${schemaName} = ${text};`);
-      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-      mapEntries.push(`  ${JSON.stringify(entry.routeName)}: ${schemaName},`);
-    }
-    if (entry.query) {
-      const schemaName = `${entry.baseName}QuerySchema`;
-      const typeName = `${entry.baseName}Query`;
-      const text = applyRenames(renderSchema(entry.query, outDir, refAlias), rename);
-      lines.push(`export const ${schemaName} = ${text};`);
-      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-    }
-    lines.push("");
-  }
-  lines.push("/** Route name \u2192 body schema map. */");
-  lines.push("export const formSchemas = {");
-  lines.push(...mapEntries);
-  lines.push("} as const;");
-  lines.push("");
-  return lines.join("\n");
+function hasSource(src) {
+  return !!(src.schema || src.zodText || src.zodRef);
 }
 function applyRenames(text, renames) {
   if (!renames || renames.size === 0) return text;
@@ -1464,44 +1214,206 @@ function planNestedSchemas(entries) {
   }
   return { globalSchemas, renamesByEntry };
 }
-function renderSchema(src, outDir, refAlias) {
-  if (src.text) return src.text;
-  if (src.ref) {
-    const root = refRootIdentifier(src.ref.name);
-    const alias = refAlias.get(`${src.ref.filePath}\0${root}`) ?? root;
-    const member = src.ref.name.slice(root.length);
-    return `${alias}${member}`;
-  }
-  return "z.unknown()";
-}
-
-// src/emit/emit-index.ts
-var import_promises6 = require("fs/promises");
-var import_node_path6 = require("path");
-async function emitIndex(outDir, hasContracts = false, hasForms = false) {
-  await (0, import_promises6.mkdir)(outDir, { recursive: true });
-  const exports2 = ["export * from './pages.js';", "export * from './routes.js';"];
-  if (hasContracts) {
-    exports2.push("export * from './api.js';");
+function buildFormsFileWithAdapter(routes, outDir, adapter, config) {
+  const acceptsRawZod = adapter.acceptsRawZodSource === true;
+  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
+  const methodNameCounts = /* @__PURE__ */ new Map();
+  const candidates = [];
+  for (const route of sorted) {
+    const cs = route.contract.contractSource;
+    const body = {
+      schema: cs.bodySchema ?? null,
+      zodText: cs.bodyZodText ?? null,
+      zodRef: cs.bodyZodRef ?? null
+    };
+    const query = {
+      schema: cs.querySchema ?? null,
+      zodText: cs.queryZodText ?? null,
+      zodRef: cs.queryZodRef ?? null
+    };
+    if (!hasSource(body) && !hasSource(query)) continue;
+    const { method, full } = deriveBaseName(route.name);
+    methodNameCounts.set(method, (methodNameCounts.get(method) ?? 0) + 1);
+    candidates.push({
+      routeName: route.name,
+      baseName: full,
+      // resolved below
+      body: hasSource(body) ? body : void 0,
+      query: hasSource(query) ? query : void 0,
+      nestedSchemas: cs.formNestedSchemas ?? null,
+      warnings: cs.formWarnings ?? []
+    });
   }
-  if (hasForms) {
-    exports2.push("export * from './forms.js';");
+  const entries = candidates.map((c) => {
+    const { method, full } = deriveBaseName(c.routeName);
+    const collision = (methodNameCounts.get(method) ?? 0) > 1;
+    return { ...c, baseName: collision ? full : method };
+  });
+  if (entries.length === 0) return null;
+  const importsByFile = /* @__PURE__ */ new Map();
+  const refAlias = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const src of [entry.body, entry.query]) {
+      if (src?.zodRef && !src.zodText && !src.schema) {
+        const root = refRootIdentifier(src.zodRef.name);
+        const set = importsByFile.get(src.zodRef.filePath) ?? /* @__PURE__ */ new Set();
+        set.add(root);
+        importsByFile.set(src.zodRef.filePath, set);
+      }
+    }
   }
-  const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports2, ""].join(
-    "\n"
-  );
-  await (0, import_promises6.writeFile)((0, import_node_path6.join)(outDir, "index.d.ts"), content, "utf8");
-}
-
-// src/emit/emit-pages.ts
-var import_promises7 = require("fs/promises");
-var import_node_path7 = require("path");
-async function emitPages(pages, outDir, _options = {}) {
-  await (0, import_promises7.mkdir)(outDir, { recursive: true });
-  const pageNameUnion = pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never";
-  const augBody = pages.map((p) => {
-    const key = needsQuotes(p.name) ? JSON.stringify(p.name) : p.name;
-    const valueType = buildAugmentationType(p, outDir);
+  const importLines = [];
+  if (importsByFile.size > 0) {
+    const emitted = /* @__PURE__ */ new Set();
+    for (const [filePath, roots] of [...importsByFile.entries()].sort()) {
+      const relPath = relImport(outDir, filePath);
+      const specifiers = [];
+      for (const root of [...roots].sort()) {
+        if (emitted.has(root)) {
+          const alias = `${root}_${emitted.size}`;
+          specifiers.push(`${root} as ${alias}`);
+          emitted.add(alias);
+          refAlias.set(`${filePath}\0${root}`, alias);
+        } else {
+          specifiers.push(root);
+          emitted.add(root);
+          refAlias.set(`${filePath}\0${root}`, root);
+        }
+      }
+      importLines.push(`import { ${specifiers.join(", ")} } from '${relPath}';`);
+    }
+  }
+  const { globalSchemas, renamesByEntry } = planNestedSchemas(entries);
+  const irNamed = /* @__PURE__ */ new Map();
+  const irTypeAliases = /* @__PURE__ */ new Map();
+  const irAnnotations = /* @__PURE__ */ new Map();
+  const decls = [];
+  const mapEntries = [];
+  let used = false;
+  const renderSource = (src, rename) => {
+    if (src.schema) {
+      const r = adapter.renderModule(src.schema);
+      for (const [n, t] of r.namedNestedSchemas) irNamed.set(n, t);
+      if (r.namedTypeAliases) for (const [n, t] of r.namedTypeAliases) irTypeAliases.set(n, t);
+      if (r.namedAnnotations) for (const [n, a] of r.namedAnnotations) irAnnotations.set(n, a);
+      return { text: r.schemaText };
+    }
+    if (src.zodText) {
+      if (!acceptsRawZod) {
+        return {
+          text: "",
+          warn: `is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
+        };
+      }
+      return { text: applyRenames(src.zodText, rename) };
+    }
+    if (src.zodRef) {
+      if (!acceptsRawZod) {
+        return {
+          text: "",
+          warn: `is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
+        };
+      }
+      const root = refRootIdentifier(src.zodRef.name);
+      const alias = refAlias.get(`${src.zodRef.filePath}\0${root}`) ?? root;
+      const member = src.zodRef.name.slice(root.length);
+      return { text: `${alias}${member}` };
+    }
+    return null;
+  };
+  for (const entry of entries) {
+    const block = [];
+    const rename = renamesByEntry.get(entry) ?? null;
+    let bodyConst;
+    if (entry.warnings && entry.warnings.length > 0) {
+      for (const w of entry.warnings) block.push(`// warning: ${w}`);
+    }
+    if (entry.body) {
+      const rendered = renderSource(entry.body, rename);
+      if (rendered?.warn) {
+        block.push(`// warning: ${entry.routeName} body ${rendered.warn}`);
+      } else if (rendered) {
+        used = true;
+        bodyConst = `${entry.baseName}BodySchema`;
+        block.push(`export const ${bodyConst} = ${rendered.text};`);
+        block.push(`export type ${entry.baseName}Body = ${adapter.inferType(bodyConst)};`);
+      }
+    }
+    if (entry.query) {
+      const rendered = renderSource(entry.query, rename);
+      if (rendered?.warn) {
+        block.push(`// warning: ${entry.routeName} query ${rendered.warn}`);
+      } else if (rendered) {
+        used = true;
+        const queryConst = `${entry.baseName}QuerySchema`;
+        block.push(`export const ${queryConst} = ${rendered.text};`);
+        block.push(`export type ${entry.baseName}Query = ${adapter.inferType(queryConst)};`);
+      }
+    }
+    if (block.length === 0) continue;
+    decls.push(`// ${entry.routeName}`, ...block, "");
+    if (bodyConst) mapEntries.push(`  ${JSON.stringify(entry.routeName)}: ${bodyConst},`);
+  }
+  if (!used) return null;
+  const lines = ["// Generated by @dudousxd/nestjs-codegen. Do not edit."];
+  if (acceptsRawZod) {
+    const zodImport = config?.zodImport ?? "zod";
+    lines.push(`import { z } from '${zodImport}';`);
+  } else {
+    for (const imp of adapter.importStatements({ used: true })) lines.push(imp);
+  }
+  lines.push(...importLines);
+  lines.push("");
+  const allNested = /* @__PURE__ */ new Map();
+  for (const [n, t] of globalSchemas) allNested.set(n, t);
+  for (const [n, t] of irNamed) if (!allNested.has(n)) allNested.set(n, t);
+  if (allNested.size > 0) {
+    lines.push("// Hoisted nested schemas (shared across endpoints).");
+    for (const [n, alias] of irTypeAliases) {
+      if (allNested.has(n)) lines.push(`${alias};`);
+    }
+    for (const [n, t] of allNested) {
+      const annotation = irAnnotations.get(n);
+      lines.push(`const ${n}${annotation ? `: ${annotation}` : ""} = ${t};`);
+    }
+    lines.push("");
+  }
+  lines.push(...decls);
+  lines.push("/** Route name \u2192 body schema map. */");
+  lines.push("export const formSchemas = {");
+  lines.push(...mapEntries);
+  lines.push("} as const;");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/emit/emit-index.ts
+var import_promises6 = require("fs/promises");
+var import_node_path7 = require("path");
+async function emitIndex(outDir, hasContracts = false, hasForms = false) {
+  await (0, import_promises6.mkdir)(outDir, { recursive: true });
+  const exports2 = ["export * from './pages.js';", "export * from './routes.js';"];
+  if (hasContracts) {
+    exports2.push("export * from './api.js';");
+  }
+  if (hasForms) {
+    exports2.push("export * from './forms.js';");
+  }
+  const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports2, ""].join(
+    "\n"
+  );
+  await (0, import_promises6.writeFile)((0, import_node_path7.join)(outDir, "index.d.ts"), content, "utf8");
+}
+
+// src/emit/emit-pages.ts
+var import_promises7 = require("fs/promises");
+var import_node_path8 = require("path");
+async function emitPages(pages, outDir, _options = {}) {
+  await (0, import_promises7.mkdir)(outDir, { recursive: true });
+  const pageNameUnion = pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never";
+  const augBody = pages.map((p) => {
+    const key = needsQuotes(p.name) ? JSON.stringify(p.name) : p.name;
+    const valueType = buildAugmentationType(p, outDir);
     return `    ${key}: ${valueType};`;
   }).join("\n");
   const propsHelper = "\nexport type InertiaProps<K extends InertiaPageName> = import('@dudousxd/nestjs-inertia').InertiaPages[K];\n";
@@ -1516,7 +1428,7 @@ ${augBody}
   }
 ${sharedPropsBlock}}
 `;
-  await (0, import_promises7.writeFile)((0, import_node_path7.join)(outDir, "pages.d.ts"), content, "utf8");
+  await (0, import_promises7.writeFile)((0, import_node_path8.join)(outDir, "pages.d.ts"), content, "utf8");
 }
 function buildSharedPropsBlock(sharedProps) {
   if (!sharedProps) return "";
@@ -1535,7 +1447,7 @@ ${propsBody}
 `;
 }
 function buildAugmentationType(page, outDir) {
-  let importPath = (0, import_node_path7.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
+  let importPath = (0, import_node_path8.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
   if (!importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
@@ -1547,11 +1459,11 @@ function needsQuotes(name) {
 
 // src/emit/emit-routes.ts
 var import_promises8 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 async function emitRoutes(routes, outDir) {
   await (0, import_promises8.mkdir)(outDir, { recursive: true });
   const content = buildRoutesFile(routes);
-  await (0, import_promises8.writeFile)((0, import_node_path8.join)(outDir, "routes.ts"), content, "utf8");
+  await (0, import_promises8.writeFile)((0, import_node_path9.join)(outDir, "routes.ts"), content, "utf8");
 }
 function buildRoutesFile(routes) {
   if (routes.length === 0) {
@@ -1679,30 +1591,7 @@ async function generate(config, inputRoutes = []) {
       propsExport: pagesConfig.propsExport,
       componentNameStrategy: pagesConfig.componentNameStrategy
     });
-    let sharedProps = null;
-    if (config.app?.moduleEntry) {
-      try {
-        const tsconfigPath = config.app.tsconfig ?? (0, import_node_path9.join)(config.codegen.cwd, "tsconfig.json");
-        let project;
-        try {
-          project = new import_ts_morph3.Project({
-            tsConfigFilePath: tsconfigPath,
-            skipAddingFilesFromTsConfig: true,
-            skipLoadingLibFiles: true,
-            skipFileDependencyResolution: true
-          });
-        } catch {
-          project = new import_ts_morph3.Project({
-            skipAddingFilesFromTsConfig: true,
-            skipLoadingLibFiles: true,
-            skipFileDependencyResolution: true,
-            compilerOptions: { allowJs: true, strict: false }
-          });
-        }
-        sharedProps = discoverSharedProps(project, config.app.moduleEntry);
-      } catch {
-      }
-    }
+    const sharedProps = discoverSharedPropsFromConfig(config);
     await emitPages(pages, config.codegen.outDir, {
       propsExport: pagesConfig.propsExport,
       sharedProps
@@ -1726,8 +1615,8 @@ async function generate(config, inputRoutes = []) {
   if (extensions.length > 0) {
     const extraFiles = await collectEmittedFiles(extensions, ctx);
     for (const file of extraFiles) {
-      const dest = (0, import_node_path9.join)(config.codegen.outDir, file.path);
-      await (0, import_promises9.mkdir)((0, import_node_path9.dirname)(dest), { recursive: true });
+      const dest = (0, import_node_path10.join)(config.codegen.outDir, file.path);
+      await (0, import_promises9.mkdir)((0, import_node_path10.dirname)(dest), { recursive: true });
       await (0, import_promises9.writeFile)(dest, file.contents, "utf8");
     }
   }
@@ -1735,35 +1624,31 @@ async function generate(config, inputRoutes = []) {
 
 // src/watch/watcher.ts
 var import_promises12 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var import_chokidar = __toESM(require("chokidar"), 1);
 
 // src/discovery/contracts-fast.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var import_ts_morph9 = require("ts-morph");
 
+// src/discovery/dto-type-resolver.ts
+var import_ts_morph7 = require("ts-morph");
+
 // src/discovery/dto-to-ir.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
 
 // src/discovery/type-ref-resolution.ts
 var import_node_fs = require("fs");
-var import_node_path10 = require("path");
-var import_ts_morph4 = require("ts-morph");
-var _ctx = { projectRoot: "", tsconfigPaths: null };
-function setDiscoveryContext(ctx) {
-  const prev = _ctx;
-  _ctx = ctx;
-  return prev;
-}
-function restoreDiscoveryContext(ctx) {
-  _ctx = ctx;
-}
-function _projectRoot() {
-  return _ctx.projectRoot;
+var import_node_path11 = require("path");
+var import_ts_morph3 = require("ts-morph");
+var _EMPTY_CTX = { projectRoot: "", tsconfigPaths: null };
+var _ctxByProject = /* @__PURE__ */ new WeakMap();
+function setDiscoveryContext(project, ctx) {
+  _ctxByProject.set(project, ctx);
 }
-function _tsconfigPaths() {
-  return _ctx.tsconfigPaths;
+function _ctxFor(project) {
+  return _ctxByProject.get(project) ?? _EMPTY_CTX;
 }
 var _debug = process.env.NESTJS_INERTIA_DEBUG === "1";
 function dbg(...args) {
@@ -1805,18 +1690,19 @@ function findTypeInFile(name, file) {
   }
   return null;
 }
-function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
+function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
   if (moduleSpecifier.startsWith(".")) {
-    const dir = (0, import_node_path10.dirname)(sourceFile.getFilePath());
+    const dir = (0, import_node_path11.dirname)(sourceFile.getFilePath());
     const noExt = moduleSpecifier.replace(/\.(js|ts)$/, "");
     return [
-      (0, import_node_path10.resolve)(dir, `${noExt}.ts`),
-      (0, import_node_path10.resolve)(dir, `${moduleSpecifier}.ts`),
-      (0, import_node_path10.resolve)(dir, moduleSpecifier, "index.ts")
+      (0, import_node_path11.resolve)(dir, `${noExt}.ts`),
+      (0, import_node_path11.resolve)(dir, `${moduleSpecifier}.ts`),
+      (0, import_node_path11.resolve)(dir, moduleSpecifier, "index.ts")
     ];
   }
-  const baseUrl = _projectRoot();
-  const tsconfigPaths = _tsconfigPaths();
+  const ctx = _ctxFor(project);
+  const baseUrl = ctx.projectRoot;
+  const tsconfigPaths = ctx.tsconfigPaths;
   dbg(
     "resolveModuleSpecifier",
     moduleSpecifier,
@@ -1832,8 +1718,8 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
         const rest = moduleSpecifier.slice(prefix.length);
         const candidates = [];
         for (const mapping of mappings) {
-          const resolved = (0, import_node_path10.resolve)(baseUrl, mapping.replace("*", rest));
-          candidates.push(`${resolved}.ts`, (0, import_node_path10.resolve)(resolved, "index.ts"));
+          const resolved = (0, import_node_path11.resolve)(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, (0, import_node_path11.resolve)(resolved, "index.ts"));
         }
         dbg("  resolved candidates:", candidates);
         return candidates;
@@ -1933,13 +1819,13 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     name = nodeOrName;
   } else {
     const typeNode = nodeOrName;
-    if (opts.unwrapContainers && import_ts_morph4.Node.isArrayTypeNode(typeNode)) {
+    if (opts.unwrapContainers && import_ts_morph3.Node.isArrayTypeNode(typeNode)) {
       const inner = resolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project, opts);
       return inner ? { ...inner, isArray: true } : null;
     }
-    if (!import_ts_morph4.Node.isTypeReference(typeNode)) return null;
+    if (!import_ts_morph3.Node.isTypeReference(typeNode)) return null;
     const typeName = typeNode.getTypeName();
-    const refName = import_ts_morph4.Node.isIdentifier(typeName) ? typeName.getText() : null;
+    const refName = import_ts_morph3.Node.isIdentifier(typeName) ? typeName.getText() : null;
     if (!refName) return null;
     if (opts.unwrapContainers && refName === "Promise") {
       const first = typeNode.getTypeArguments()[0];
@@ -1962,7 +1848,7 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     if (!namedImport) continue;
     const moduleSpecifier = importDecl.getModuleSpecifierValue();
     if (opts.allowBareSpecifier && !moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
-      const tsconfigPaths = _tsconfigPaths();
+      const tsconfigPaths = _ctxFor(project).tsconfigPaths;
       const isAlias = tsconfigPaths != null && Object.keys(tsconfigPaths).some((p) => {
         const prefix = p.replace("*", "");
         return moduleSpecifier.startsWith(prefix);
@@ -2031,10 +1917,7 @@ function extractSchemaFromDto(classDecl, sourceFile, project) {
     depth: 0
   };
   const root = buildObject(classDecl, sourceFile, ctx);
-  for (const schemaName of ctx.recursiveSchemas) {
-    ctx.named.set(schemaName, { kind: "unknown", note: "recursive type \u2014 not expanded" });
-  }
-  return { root, named: ctx.named, warnings: ctx.warnings };
+  return { root, named: ctx.named, warnings: ctx.warnings, recursive: ctx.recursiveSchemas };
 }
 function buildObject(classDecl, classFile, ctx) {
   const props = classDecl.getProperties();
@@ -2054,7 +1937,7 @@ function buildProperty(prop, classFile, ctx) {
   const dec = (n) => decorators.get(n);
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
+  const isArrayType = !!typeNode && import_ts_morph4.Node.isArrayTypeNode(typeNode);
   const typeRefName = resolveTypeFactoryName(dec("Type"));
   if (has("ValidateNested") || typeRefName) {
     const childName = typeRefName ?? singularClassName(typeText);
@@ -2185,18 +2068,27 @@ function baseFromType(typeText, isArrayType) {
   }
 }
 function buildNestedReference(className, fromFile, ctx) {
-  if (ctx.visiting.has(className) || ctx.depth >= 8) {
+  if (ctx.visiting.has(className)) {
     const reserved = ctx.emittedClasses.get(className) ?? aliasFor(className, ctx);
     ctx.emittedClasses.set(className, reserved);
     ctx.recursiveSchemas.add(reserved);
     if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
       ctx.warnedDecorators.add(`recursive:${reserved}`);
-      const msg = `${className} is a recursive type and was not expanded; the generated schema uses unknown for it.`;
+      const msg = `${className} is a recursive type; the generated schema validates it via a lazy self-reference.`;
       ctx.warnings.push(msg);
       console.warn(`[nestjs-codegen] ${msg}`);
     }
     return { kind: "lazyRef", name: reserved };
   }
+  if (ctx.depth >= 8) {
+    if (!ctx.warnedDecorators.has(`deep:${className}`)) {
+      ctx.warnedDecorators.add(`deep:${className}`);
+      const msg = `${className} nesting is too deep to expand; the generated schema uses unknown for it.`;
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen] ${msg}`);
+    }
+    return { kind: "unknown", note: "nesting too deep \u2014 not expanded" };
+  }
   const existing = ctx.emittedClasses.get(className);
   if (existing) return { kind: "ref", name: existing };
   const schemaName = aliasFor(className, ctx);
@@ -2234,22 +2126,22 @@ function firstArgText(decorator) {
 }
 function numericArg(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph5.Node.isNumericLiteral(arg)) return arg.getText();
+  if (arg && import_ts_morph4.Node.isNumericLiteral(arg)) return arg.getText();
   return null;
 }
 function numericArgs(decorator) {
   const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph5.Node.isNumericLiteral(n) ? n.getText() : null;
+  const num = (n) => n && import_ts_morph4.Node.isNumericLiteral(n) ? n.getText() : null;
   return [num(args[0]), num(args[1])];
 }
 function messageRaw(decorator) {
   const args = decorator?.getArguments() ?? [];
   for (const arg of args) {
-    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph5.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
+        if (import_ts_morph4.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
           const init = prop.getInitializer();
-          if (init && import_ts_morph5.Node.isStringLiteral(init)) return init.getText();
+          if (init && import_ts_morph4.Node.isStringLiteral(init)) return init.getText();
         }
       }
     }
@@ -2259,9 +2151,9 @@ function messageRaw(decorator) {
 function resolveTypeFactoryName(decorator) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph5.Node.isArrowFunction(arg)) {
+  if (import_ts_morph4.Node.isArrowFunction(arg)) {
     const body = arg.getBody();
-    if (import_ts_morph5.Node.isIdentifier(body)) return body.getText();
+    if (import_ts_morph4.Node.isIdentifier(body)) return body.getText();
   }
   return null;
 }
@@ -2272,7 +2164,7 @@ function singularClassName(typeText) {
 function enumSchemaFromDecorator(decorator, classFile, ctx) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph5.Node.isIdentifier(arg)) {
+  if (import_ts_morph4.Node.isIdentifier(arg)) {
     const name = arg.getText();
     const resolved = findType(name, classFile, ctx.project);
     if (resolved && resolved.kind === "enum") {
@@ -2286,12 +2178,12 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
     }
     return { kind: "unknown", note: `@IsEnum(${name}): enum not resolvable to literals` };
   }
-  if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+  if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
     const values = [];
     for (const p of arg.getProperties()) {
-      if (!import_ts_morph5.Node.isPropertyAssignment(p)) continue;
+      if (!import_ts_morph4.Node.isPropertyAssignment(p)) continue;
       const init = p.getInitializer();
-      if (init && import_ts_morph5.Node.isStringLiteral(init)) values.push(init.getText());
+      if (init && import_ts_morph4.Node.isStringLiteral(init)) values.push(init.getText());
     }
     if (values.length > 0) return { kind: "enum", literals: values };
   }
@@ -2299,9 +2191,9 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
 }
 function inSchemaFromDecorator(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph5.Node.isArrayLiteralExpression(arg)) {
+  if (arg && import_ts_morph4.Node.isArrayLiteralExpression(arg)) {
     const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph5.Node.isStringLiteral(e));
+    const allStrings = elements.every((e) => import_ts_morph4.Node.isStringLiteral(e));
     if (allStrings && elements.length > 0) {
       return { kind: "enum", literals: elements.map((e) => e.getText()) };
     }
@@ -2315,427 +2207,99 @@ function inSchemaFromDecorator(decorator) {
   return null;
 }
 
-// src/discovery/dto-to-zod.ts
+// src/discovery/filter-for.ts
 var import_ts_morph6 = require("ts-morph");
-var KNOWN_DECORATORS2 = /* @__PURE__ */ new Set([
-  "IsString",
-  "IsNumber",
-  "IsInt",
-  "IsBoolean",
-  "IsDate",
-  "IsEmail",
-  "IsUrl",
-  "IsUUID",
-  "MinLength",
-  "MaxLength",
-  "Length",
-  "Min",
-  "Max",
-  "IsPositive",
-  "IsNegative",
-  "Matches",
-  "IsEnum",
-  "IsIn",
-  "IsOptional",
-  "IsNotEmpty",
-  "IsArray",
-  "ValidateNested",
-  "Type",
-  "IsObject",
-  "Allow",
-  "IsDefined"
-]);
-function extractZodFromDto(classDecl, sourceFile, project) {
-  const ctx = {
-    sourceFile,
-    project,
-    namedNestedSchemas: /* @__PURE__ */ new Map(),
-    warnings: [],
-    warnedDecorators: /* @__PURE__ */ new Set(),
-    emittedClasses: /* @__PURE__ */ new Map(),
-    visiting: /* @__PURE__ */ new Set(),
-    recursiveSchemas: /* @__PURE__ */ new Set(),
-    depth: 0
-  };
-  const schemaText = buildObjectSchema(classDecl, sourceFile, ctx);
-  for (const schemaName of ctx.recursiveSchemas) {
-    ctx.namedNestedSchemas.set(schemaName, "z.unknown() /* recursive type \u2014 not expanded */");
-  }
-  return {
-    schemaText,
-    namedNestedSchemas: ctx.namedNestedSchemas,
-    warnings: ctx.warnings
-  };
+
+// src/discovery/filter-field-types.ts
+var import_ts_morph5 = require("ts-morph");
+
+// src/discovery/enum-resolution.ts
+function resolveEnumValues(name, sourceFile, project) {
+  const resolved = findType(name, sourceFile, project);
+  if (!resolved || resolved.kind !== "enum") return null;
+  let numeric = true;
+  const values = resolved.members.map((m) => {
+    const parsed = JSON.parse(m);
+    if (typeof parsed === "string") numeric = false;
+    return String(parsed);
+  });
+  if (values.length === 0) return null;
+  return { values, numeric };
 }
-function buildObjectSchema(classDecl, classFile, ctx) {
-  const props = classDecl.getProperties();
-  if (props.length === 0) {
-    return "z.object({}).passthrough()";
-  }
-  const fields = [];
-  for (const prop of props) {
-    const name = prop.getName();
-    const expr = buildPropertySchema(prop, classFile, ctx);
-    fields.push(`${toObjectKey3(name)}: ${expr}`);
-  }
-  return `z.object({ ${fields.join(", ")} })`;
+
+// src/discovery/filter-field-types.ts
+var STRING_TYPE_KEYWORDS = ["varchar", "text", "string", "char", "uuid", "enum"];
+var NUMBER_TYPE_KEYWORDS = ["int", "float", "double", "decimal", "number", "numeric", "real"];
+var BOOLEAN_TYPE_KEYWORDS = ["bool", "boolean", "bit"];
+var DATE_TYPE_KEYWORDS = ["date", "time", "timestamp", "datetime"];
+var JSON_TYPE_KEYWORDS = ["json", "jsonb"];
+function classifyTypeKeyword(raw) {
+  const t = raw.toLowerCase();
+  if (STRING_TYPE_KEYWORDS.some((s) => t.includes(s))) return "string";
+  if (NUMBER_TYPE_KEYWORDS.some((s) => t.includes(s))) return "number";
+  if (BOOLEAN_TYPE_KEYWORDS.some((s) => t.includes(s))) return "boolean";
+  if (DATE_TYPE_KEYWORDS.some((s) => t.includes(s))) return "date";
+  if (JSON_TYPE_KEYWORDS.some((s) => t.includes(s))) return "json";
+  return null;
 }
-function toObjectKey3(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+function markNullable(r, nullable) {
+  return nullable ? { ...r, nullable: true } : r;
 }
-function buildPropertySchema(prop, classFile, ctx) {
-  const decorators = /* @__PURE__ */ new Map();
-  for (const d of prop.getDecorators()) decorators.set(d.getName(), d);
-  const has = (n) => decorators.has(n);
-  const dec = (n) => decorators.get(n);
-  const typeNode = prop.getTypeNode();
-  const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
-  const comments = [];
-  const typeRefName = resolveTypeFactoryName2(dec("Type"));
-  if (has("ValidateNested") || typeRefName) {
-    const childName = typeRefName ?? singularClassName2(typeText);
-    if (childName) {
-      const childExpr = buildNestedReference2(childName, classFile, ctx);
-      const wrapArray = has("IsArray") || isArrayType;
-      let expr2 = wrapArray ? `z.array(${childExpr})` : childExpr;
-      expr2 = applyPresence2(expr2, decorators);
-      return expr2;
-    }
-  }
-  let base = baseFromType2(typeText, isArrayType, ctx, classFile);
-  const refinements = [];
-  if (has("IsString")) base = "z.string()";
-  if (has("IsBoolean")) base = "z.boolean()";
-  if (has("IsDate")) base = "z.coerce.date()";
-  if (has("IsNumber")) base = "z.number()";
-  if (has("IsInt")) base = "z.number().int()";
-  if (has("IsObject") && !has("ValidateNested")) base = "z.object({}).passthrough()";
-  if (has("Allow")) base = "z.unknown()";
-  if (has("IsEmail")) {
-    base = ensureStringBase(base);
-    refinements.push(`.email(${messageArg(dec("IsEmail"))})`);
-  }
-  if (has("IsUrl")) {
-    base = ensureStringBase(base);
-    refinements.push(`.url(${messageArg(dec("IsUrl"))})`);
-  }
-  if (has("IsUUID")) {
-    base = ensureStringBase(base);
-    refinements.push(`.uuid(${messageArg(dec("IsUUID"))})`);
-  }
-  if (has("Matches")) {
-    const re = firstArgText2(dec("Matches"));
-    if (re) {
-      base = ensureStringBase(base);
-      refinements.push(`.regex(${re})`);
+function classifyTypeNode(typeNode, sourceFile, project, opts) {
+  if (import_ts_morph5.Node.isUnionTypeNode(typeNode)) {
+    let nullable = false;
+    const stringLits = [];
+    const numberLits = [];
+    const others = [];
+    for (const member of typeNode.getTypeNodes()) {
+      const kind = member.getKind();
+      if (kind === import_ts_morph5.SyntaxKind.NullKeyword || kind === import_ts_morph5.SyntaxKind.UndefinedKeyword) {
+        nullable = true;
+        continue;
+      }
+      if (import_ts_morph5.Node.isLiteralTypeNode(member)) {
+        const lit = member.getLiteral();
+        if (import_ts_morph5.Node.isStringLiteral(lit)) {
+          stringLits.push(lit.getLiteralValue());
+          continue;
+        }
+        if (import_ts_morph5.Node.isNumericLiteral(lit)) {
+          numberLits.push(lit.getText());
+          continue;
+        }
+        if (lit.getKind() === import_ts_morph5.SyntaxKind.NullKeyword) {
+          nullable = true;
+          continue;
+        }
+      }
+      others.push(member);
+    }
+    if (others.length === 0 && stringLits.length > 0 && numberLits.length === 0) {
+      return markNullable({ kind: "string", enumValues: stringLits }, nullable);
+    }
+    if (others.length === 0 && numberLits.length > 0 && stringLits.length === 0) {
+      return markNullable({ kind: "number", enumValues: numberLits, numericEnum: true }, nullable);
+    }
+    if (others.length === 1) {
+      const inner = classifyTypeNode(others[0], sourceFile, project, opts);
+      return markNullable(inner, nullable || inner.nullable === true);
     }
+    return markNullable({ kind: "unknown" }, nullable);
   }
-  if (has("MinLength")) {
-    const n = numericArg2(dec("MinLength"));
-    if (n !== null) refinements.push(`.min(${n})`);
+  switch (typeNode.getKind()) {
+    case import_ts_morph5.SyntaxKind.StringKeyword:
+      return { kind: "string" };
+    case import_ts_morph5.SyntaxKind.NumberKeyword:
+      return { kind: "number" };
+    case import_ts_morph5.SyntaxKind.BooleanKeyword:
+      return { kind: "boolean" };
+    case import_ts_morph5.SyntaxKind.AnyKeyword:
+    case import_ts_morph5.SyntaxKind.UnknownKeyword:
+      return { kind: "unknown" };
+    default:
+      break;
   }
-  if (has("MaxLength")) {
-    const n = numericArg2(dec("MaxLength"));
-    if (n !== null) refinements.push(`.max(${n})`);
-  }
-  if (has("Length")) {
-    const [min, max] = numericArgs2(dec("Length"));
-    if (min !== null) refinements.push(`.min(${min})`);
-    if (max !== null) refinements.push(`.max(${max})`);
-  }
-  if (has("Min")) {
-    const n = numericArg2(dec("Min"));
-    if (n !== null) refinements.push(`.min(${n})`);
-  }
-  if (has("Max")) {
-    const n = numericArg2(dec("Max"));
-    if (n !== null) refinements.push(`.max(${n})`);
-  }
-  if (has("IsPositive")) refinements.push(".positive()");
-  if (has("IsNegative")) refinements.push(".negative()");
-  if (has("IsNotEmpty") && isStringBase(base)) refinements.push(".min(1)");
-  if (has("IsEnum")) {
-    const enumExpr = enumSchemaFromDecorator2(dec("IsEnum"), classFile, ctx);
-    if (enumExpr) base = enumExpr;
-  }
-  if (has("IsIn")) {
-    const inExpr = inSchemaFromDecorator2(dec("IsIn"));
-    if (inExpr) base = inExpr;
-  }
-  for (const name of decorators.keys()) {
-    if (!KNOWN_DECORATORS2.has(name)) {
-      comments.push(`/* @${name}: not translatable to zod (server-only) */`);
-      if (!ctx.warnedDecorators.has(name)) {
-        ctx.warnedDecorators.add(name);
-        const msg = `@${name} is not translatable to zod and was skipped (server-only validation).`;
-        ctx.warnings.push(msg);
-        console.warn(`[nestjs-codegen/forms] ${msg}`);
-      }
-    }
-  }
-  let expr = base + refinements.join("");
-  if (isArrayType && !expr.startsWith("z.array(")) {
-    expr = `z.array(${expr})`;
-  }
-  expr = applyPresence2(expr, decorators);
-  if (comments.length > 0) {
-    expr = `${expr} ${comments.join(" ")}`;
-  }
-  return expr;
-}
-function applyPresence2(expr, decorators) {
-  if (decorators.has("IsDefined")) return expr;
-  if (decorators.has("IsOptional")) return `${expr}.optional()`;
-  return expr;
-}
-function baseFromType2(typeText, isArrayType, ctx, classFile) {
-  const inner = isArrayType ? typeText.slice(0, -2).trim() : typeText;
-  switch (inner) {
-    case "string":
-      return "z.string()";
-    case "number":
-      return "z.number()";
-    case "boolean":
-      return "z.boolean()";
-    case "Date":
-      return "z.coerce.date()";
-    case "File":
-    case "Express.Multer.File":
-      return "z.instanceof(File)";
-    default:
-      return "z.unknown()";
-  }
-}
-function ensureStringBase(base) {
-  return isStringBase(base) ? base : "z.string()";
-}
-function isStringBase(base) {
-  return base.startsWith("z.string(");
-}
-function buildNestedReference2(className, fromFile, ctx) {
-  if (ctx.visiting.has(className) || ctx.depth >= 8) {
-    const reserved = ctx.emittedClasses.get(className) ?? aliasFor2(className, ctx);
-    ctx.emittedClasses.set(className, reserved);
-    ctx.recursiveSchemas.add(reserved);
-    if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
-      ctx.warnedDecorators.add(`recursive:${reserved}`);
-      const msg = `${className} is a recursive type and was not expanded; the generated form schema uses z.unknown() for it.`;
-      ctx.warnings.push(msg);
-      console.warn(`[nestjs-codegen/forms] ${msg}`);
-    }
-    return `z.lazy(() => ${reserved})`;
-  }
-  const existing = ctx.emittedClasses.get(className);
-  if (existing) return existing;
-  const schemaName = aliasFor2(className, ctx);
-  const resolved = findType(className, fromFile, ctx.project);
-  if (!resolved || resolved.kind !== "class") {
-    return "z.object({}).passthrough()";
-  }
-  ctx.emittedClasses.set(className, schemaName);
-  ctx.visiting.add(className);
-  ctx.depth += 1;
-  const childText = buildObjectSchema(resolved.decl, resolved.file, ctx);
-  ctx.depth -= 1;
-  ctx.visiting.delete(className);
-  ctx.namedNestedSchemas.set(schemaName, childText);
-  return schemaName;
-}
-function aliasFor2(className, ctx) {
-  const baseName = `${className}Schema`;
-  let candidate = baseName;
-  let i = 1;
-  const used = new Set(ctx.namedNestedSchemas.keys());
-  for (const v of ctx.emittedClasses.values()) used.add(v);
-  while (used.has(candidate)) {
-    candidate = `${baseName}_${i}`;
-    i += 1;
-  }
-  return candidate;
-}
-function firstArg2(decorator) {
-  return decorator?.getArguments()[0];
-}
-function firstArgText2(decorator) {
-  const arg = firstArg2(decorator);
-  return arg ? arg.getText() : null;
-}
-function numericArg2(decorator) {
-  const arg = firstArg2(decorator);
-  if (arg && import_ts_morph6.Node.isNumericLiteral(arg)) return arg.getText();
-  return null;
-}
-function numericArgs2(decorator) {
-  const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph6.Node.isNumericLiteral(n) ? n.getText() : null;
-  return [num(args[0]), num(args[1])];
-}
-function messageArg(decorator) {
-  const args = decorator?.getArguments() ?? [];
-  for (const arg of args) {
-    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
-      for (const prop of arg.getProperties()) {
-        if (import_ts_morph6.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
-          const init = prop.getInitializer();
-          if (init && import_ts_morph6.Node.isStringLiteral(init)) {
-            return `{ message: ${init.getText()} }`;
-          }
-        }
-      }
-    }
-  }
-  return "";
-}
-function resolveTypeFactoryName2(decorator) {
-  const arg = firstArg2(decorator);
-  if (!arg) return null;
-  if (import_ts_morph6.Node.isArrowFunction(arg)) {
-    const body = arg.getBody();
-    if (import_ts_morph6.Node.isIdentifier(body)) return body.getText();
-  }
-  return null;
-}
-function singularClassName2(typeText) {
-  const inner = typeText.endsWith("[]") ? typeText.slice(0, -2).trim() : typeText;
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(inner) ? inner : null;
-}
-function enumSchemaFromDecorator2(decorator, classFile, ctx) {
-  const arg = firstArg2(decorator);
-  if (!arg) return null;
-  if (import_ts_morph6.Node.isIdentifier(arg)) {
-    const name = arg.getText();
-    const resolved = findType(name, classFile, ctx.project);
-    if (resolved && resolved.kind === "enum") {
-      return `z.enum([${resolved.members.join(", ")}])`;
-    }
-    const msg = `@IsEnum(${name}): enum could not be resolved to literal members and is not importable into the generated form schema; falling back to z.unknown().`;
-    if (!ctx.warnedDecorators.has(`IsEnum:${name}`)) {
-      ctx.warnedDecorators.add(`IsEnum:${name}`);
-      ctx.warnings.push(msg);
-      console.warn(`[nestjs-codegen/forms] ${msg}`);
-    }
-    return `z.unknown() /* @IsEnum(${name}): enum not resolvable to literals */`;
-  }
-  if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
-    const values = [];
-    for (const p of arg.getProperties()) {
-      if (!import_ts_morph6.Node.isPropertyAssignment(p)) continue;
-      const init = p.getInitializer();
-      if (init && import_ts_morph6.Node.isStringLiteral(init)) values.push(init.getText());
-    }
-    if (values.length > 0) return `z.enum([${values.join(", ")}])`;
-  }
-  return null;
-}
-function inSchemaFromDecorator2(decorator) {
-  const arg = firstArg2(decorator);
-  if (arg && import_ts_morph6.Node.isArrayLiteralExpression(arg)) {
-    const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph6.Node.isStringLiteral(e));
-    if (allStrings && elements.length > 0) {
-      return `z.enum([${elements.map((e) => e.getText()).join(", ")}])`;
-    }
-    if (elements.length > 0) {
-      return `z.union([${elements.map((e) => `z.literal(${e.getText()})`).join(", ")}])`;
-    }
-  }
-  return null;
-}
-
-// src/discovery/filter-for.ts
-var import_ts_morph8 = require("ts-morph");
-
-// src/discovery/filter-field-types.ts
-var import_ts_morph7 = require("ts-morph");
-
-// src/discovery/enum-resolution.ts
-function resolveEnumValues(name, sourceFile, project) {
-  const resolved = findType(name, sourceFile, project);
-  if (!resolved || resolved.kind !== "enum") return null;
-  let numeric = true;
-  const values = resolved.members.map((m) => {
-    const parsed = JSON.parse(m);
-    if (typeof parsed === "string") numeric = false;
-    return String(parsed);
-  });
-  if (values.length === 0) return null;
-  return { values, numeric };
-}
-
-// src/discovery/filter-field-types.ts
-var STRING_TYPE_KEYWORDS = ["varchar", "text", "string", "char", "uuid", "enum"];
-var NUMBER_TYPE_KEYWORDS = ["int", "float", "double", "decimal", "number", "numeric", "real"];
-var BOOLEAN_TYPE_KEYWORDS = ["bool", "boolean", "bit"];
-var DATE_TYPE_KEYWORDS = ["date", "time", "timestamp", "datetime"];
-var JSON_TYPE_KEYWORDS = ["json", "jsonb"];
-function classifyTypeKeyword(raw) {
-  const t = raw.toLowerCase();
-  if (STRING_TYPE_KEYWORDS.some((s) => t.includes(s))) return "string";
-  if (NUMBER_TYPE_KEYWORDS.some((s) => t.includes(s))) return "number";
-  if (BOOLEAN_TYPE_KEYWORDS.some((s) => t.includes(s))) return "boolean";
-  if (DATE_TYPE_KEYWORDS.some((s) => t.includes(s))) return "date";
-  if (JSON_TYPE_KEYWORDS.some((s) => t.includes(s))) return "json";
-  return null;
-}
-function markNullable(r, nullable) {
-  return nullable ? { ...r, nullable: true } : r;
-}
-function classifyTypeNode(typeNode, sourceFile, project, opts) {
-  if (import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
-    let nullable = false;
-    const stringLits = [];
-    const numberLits = [];
-    const others = [];
-    for (const member of typeNode.getTypeNodes()) {
-      const kind = member.getKind();
-      if (kind === import_ts_morph7.SyntaxKind.NullKeyword || kind === import_ts_morph7.SyntaxKind.UndefinedKeyword) {
-        nullable = true;
-        continue;
-      }
-      if (import_ts_morph7.Node.isLiteralTypeNode(member)) {
-        const lit = member.getLiteral();
-        if (import_ts_morph7.Node.isStringLiteral(lit)) {
-          stringLits.push(lit.getLiteralValue());
-          continue;
-        }
-        if (import_ts_morph7.Node.isNumericLiteral(lit)) {
-          numberLits.push(lit.getText());
-          continue;
-        }
-        if (lit.getKind() === import_ts_morph7.SyntaxKind.NullKeyword) {
-          nullable = true;
-          continue;
-        }
-      }
-      others.push(member);
-    }
-    if (others.length === 0 && stringLits.length > 0 && numberLits.length === 0) {
-      return markNullable({ kind: "string", enumValues: stringLits }, nullable);
-    }
-    if (others.length === 0 && numberLits.length > 0 && stringLits.length === 0) {
-      return markNullable({ kind: "number", enumValues: numberLits, numericEnum: true }, nullable);
-    }
-    if (others.length === 1) {
-      const inner = classifyTypeNode(others[0], sourceFile, project, opts);
-      return markNullable(inner, nullable || inner.nullable === true);
-    }
-    return markNullable({ kind: "unknown" }, nullable);
-  }
-  switch (typeNode.getKind()) {
-    case import_ts_morph7.SyntaxKind.StringKeyword:
-      return { kind: "string" };
-    case import_ts_morph7.SyntaxKind.NumberKeyword:
-      return { kind: "number" };
-    case import_ts_morph7.SyntaxKind.BooleanKeyword:
-      return { kind: "boolean" };
-    case import_ts_morph7.SyntaxKind.AnyKeyword:
-    case import_ts_morph7.SyntaxKind.UnknownKeyword:
-      return { kind: "unknown" };
-    default:
-      break;
-  }
-  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph5.Node.isTypeReference(typeNode)) {
     const refName = typeNode.getTypeName().getText();
     if (refName === "Date") return { kind: "date" };
     if (refName === "Record" || refName === "Object") return { kind: "json" };
@@ -2748,25 +2312,25 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     if (typeRef) return { kind: "unknown", typeRef };
     return { kind: "unknown" };
   }
-  if (import_ts_morph7.Node.isTypeLiteral(typeNode)) return { kind: "json" };
+  if (import_ts_morph5.Node.isTypeLiteral(typeNode)) return { kind: "json" };
   return { kind: "unknown" };
 }
 function enumFromDecoratorArgs(args, sourceFile, project) {
   for (const arg of args) {
-    if (import_ts_morph7.Node.isArrowFunction(arg)) {
+    if (import_ts_morph5.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph7.Node.isIdentifier(body)) {
+      if (import_ts_morph5.Node.isIdentifier(body)) {
         const en = resolveEnumValues(body.getText(), sourceFile, project);
         if (en) return en;
       }
     }
-    if (import_ts_morph7.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
       const itemsProp = arg.getProperty("items");
-      if (itemsProp && import_ts_morph7.Node.isPropertyAssignment(itemsProp)) {
+      if (itemsProp && import_ts_morph5.Node.isPropertyAssignment(itemsProp)) {
         const init = itemsProp.getInitializer();
-        if (init && import_ts_morph7.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph5.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph7.Node.isIdentifier(body)) {
+          if (import_ts_morph5.Node.isIdentifier(body)) {
             const en = resolveEnumValues(body.getText(), sourceFile, project);
             if (en) return en;
           }
@@ -2789,7 +2353,7 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
       return { kind: "string" };
     }
     for (const arg of args) {
-      if (import_ts_morph7.Node.isStringLiteral(arg)) {
+      if (import_ts_morph5.Node.isStringLiteral(arg)) {
         const raw = arg.getLiteralValue();
         const kind = classifyTypeKeyword(raw);
         if (kind) {
@@ -2797,11 +2361,11 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           return { kind };
         }
       }
-      if (import_ts_morph7.Node.isObjectLiteralExpression(arg)) {
+      if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
         const enumProp = arg.getProperty("enum");
-        if (enumProp && import_ts_morph7.Node.isPropertyAssignment(enumProp)) {
+        if (enumProp && import_ts_morph5.Node.isPropertyAssignment(enumProp)) {
           const init = enumProp.getInitializer();
-          if (init && import_ts_morph7.Node.isIdentifier(init)) {
+          if (init && import_ts_morph5.Node.isIdentifier(init)) {
             const en = resolveEnumValues(init.getText(), sourceFile, project);
             if (en) {
               return en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
@@ -2810,9 +2374,9 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           }
         }
         const typeProp = arg.getProperty("type");
-        if (typeProp && import_ts_morph7.Node.isPropertyAssignment(typeProp)) {
+        if (typeProp && import_ts_morph5.Node.isPropertyAssignment(typeProp)) {
           const init = typeProp.getInitializer();
-          if (init && import_ts_morph7.Node.isStringLiteral(init)) {
+          if (init && import_ts_morph5.Node.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
           }
@@ -2848,7 +2412,7 @@ function toFilterFieldType(name, r) {
 
 // src/discovery/filter-for.ts
 function classifyFilterForHint(typeInit) {
-  if (import_ts_morph8.Node.isStringLiteral(typeInit)) {
+  if (import_ts_morph6.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -2862,10 +2426,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (import_ts_morph8.Node.isArrayLiteralExpression(typeInit)) {
+  if (import_ts_morph6.Node.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!import_ts_morph8.Node.isStringLiteral(el)) return null;
+      if (!import_ts_morph6.Node.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -2900,11 +2464,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && import_ts_morph8.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && import_ts_morph6.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && import_ts_morph8.Node.isPropertyAssignment(typeProp)) {
+      if (typeProp && import_ts_morph6.Node.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -2927,14 +2491,14 @@ function extractApplyFilterInfo(method, sourceFile, project) {
     const args = filterDecorator.getArguments();
     if (args.length === 0) continue;
     const filterClassArg = args[0];
-    if (!filterClassArg || !import_ts_morph8.Node.isIdentifier(filterClassArg)) continue;
+    if (!filterClassArg || !import_ts_morph6.Node.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && import_ts_morph8.Node.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && import_ts_morph8.Node.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && import_ts_morph6.Node.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && import_ts_morph8.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && import_ts_morph6.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
@@ -2997,22 +2561,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (import_ts_morph8.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && import_ts_morph8.Node.isPropertyAssignment(entityProp)) {
+      if (entityProp && import_ts_morph6.Node.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && import_ts_morph8.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph6.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph8.Node.isIdentifier(body)) {
+          if (import_ts_morph6.Node.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    if (import_ts_morph8.Node.isArrowFunction(arg)) {
+    if (import_ts_morph6.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph8.Node.isIdentifier(body)) {
+      if (import_ts_morph6.Node.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -3036,11 +2600,11 @@ function extractFilterableEntityFields(filterClass, project) {
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!import_ts_morph8.Node.isObjectLiteralExpression(optionsArg)) return [];
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return [];
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph8.Node.isPropertyAssignment(entityProp)) return [];
+  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return [];
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph8.Node.isIdentifier(entityInit)) return [];
+  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return [];
   const entityName = entityInit.getText();
   const filterSourceFile = filterClass.getSourceFile();
   const resolvedEntity = findType(entityName, filterSourceFile, project);
@@ -3056,17 +2620,17 @@ function extractFilterableEntityFields(filterClass, project) {
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
     const relArgs = relationsDecorator.getArguments();
-    if (relArgs.length > 0 && import_ts_morph8.Node.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && import_ts_morph6.Node.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!import_ts_morph8.Node.isPropertyAssignment(relProp)) continue;
+        if (!import_ts_morph6.Node.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !import_ts_morph8.Node.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !import_ts_morph6.Node.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !import_ts_morph8.Node.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !import_ts_morph6.Node.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !import_ts_morph8.Node.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !import_ts_morph6.Node.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (import_ts_morph8.Node.isStringLiteral(el)) {
+          if (import_ts_morph6.Node.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -3076,267 +2640,65 @@ function extractFilterableEntityFields(filterClass, project) {
   return fields;
 }
 
-// src/discovery/contracts-fast.ts
-async function discoverContractsFast(opts) {
-  const { cwd, glob, tsconfig } = opts;
-  const tsconfigPath = tsconfig ? (0, import_node_path11.resolve)(tsconfig) : (0, import_node_path11.join)(cwd, "tsconfig.json");
-  let project;
-  try {
-    project = new import_ts_morph9.Project({
-      tsConfigFilePath: tsconfigPath,
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true
-    });
-  } catch {
-    project = new import_ts_morph9.Project({
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true,
-      compilerOptions: {
-        allowJs: true,
-        resolveJsonModule: false,
-        strict: false
-      }
-    });
+// src/discovery/dto-type-resolver.ts
+var WRAPPER_TYPES = {
+  // MikroORM Ref/Reference/LoadedReference/IdentifiedReference are server-side
+  // wrappers around related entities; the wire shape is just the referenced
+  // entity. Unwrap to the type argument.
+  Ref: "unwrap",
+  Reference: "unwrap",
+  LoadedReference: "unwrap",
+  IdentifiedReference: "unwrap",
+  // MikroORM Opt<T> is a marker, Loaded<T, ...> is a wrapper; both reduce to T.
+  Opt: "unwrap",
+  Loaded: "unwrap",
+  // Promise<T> — unwrap
+  Promise: "unwrap",
+  // MikroORM Collection<T> serializes as an array of T on the wire.
+  Collection: "arrayOf",
+  // Array<T> generic form
+  Array: "arrayOf"
+};
+var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
+  "Record",
+  "Omit",
+  "Pick",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Map",
+  "Set"
+]);
+function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
+  if (depth <= 0) return "unknown";
+  if (import_ts_morph7.Node.isArrayTypeNode(typeNode)) {
+    const elementType = typeNode.getElementTypeNode();
+    return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
   }
-  const files = await (0, import_fast_glob2.default)(glob, { cwd, absolute: true, onlyFiles: true });
-  for (const f of files) {
-    project.addSourceFileAtPath(f);
+  if (import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
   }
-  const routes = [];
-  const prevCtx = setDiscoveryContext({
-    projectRoot: cwd,
-    tsconfigPaths: loadTsconfigPaths(tsconfigPath)
-  });
-  try {
-    for (const sourceFile of project.getSourceFiles()) {
-      routes.push(...extractFromSourceFile(sourceFile, project));
-    }
-  } finally {
-    restoreDiscoveryContext(prevCtx);
+  if (import_ts_morph7.Node.isIntersectionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
   }
-  return routes;
-}
-function zodAstToTs(node) {
-  if (!import_ts_morph9.Node.isCallExpression(node)) return "unknown";
-  const expr = node.getExpression();
-  if (import_ts_morph9.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_morph9.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph9.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph9.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph9.SyntaxKind.FalseKeyword) return "false";
-        return "unknown";
-      }
-      case "enum": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        const members = arrArg.getElements().map(
-          (el) => import_ts_morph9.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_morph9.Node.isObjectLiteralExpression(objArg)) return "unknown";
-        const lines = [];
-        for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph9.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_morph9.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_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
-      }
-      default:
-        return "unknown";
-    }
-  }
-  return "unknown";
-}
-function isOptionalChain(node) {
-  if (!import_ts_morph9.Node.isCallExpression(node)) return false;
-  const expr = node.getExpression();
-  return import_ts_morph9.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
-}
-function decoratorStringArg(decoratorExpr) {
-  if (!decoratorExpr) return void 0;
-  if (import_ts_morph9.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph9.Node.isArrayLiteralExpression(decoratorExpr)) {
-    const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph9.Node.isStringLiteral(first)) return first.getLiteralValue();
-  }
-  return void 0;
-}
-function parseDefineContractCall(callExpr) {
-  if (!import_ts_morph9.Node.isCallExpression(callExpr)) return null;
-  const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph9.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph9.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-  if (calleeName !== "defineContract") return null;
-  const args = callExpr.getArguments();
-  const optsArg = args[0];
-  if (!optsArg || !import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) return null;
-  let query = null;
-  let body = null;
-  let response = "unknown";
-  let bodyZodText = null;
-  let queryZodText = null;
-  for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
-    const propName = prop.getName();
-    const val = prop.getInitializer();
-    if (!val) continue;
-    if (propName === "query") {
-      query = zodAstToTs(val);
-      queryZodText = val.getText();
-    } else if (propName === "body") {
-      body = zodAstToTs(val);
-      bodyZodText = val.getText();
-    } else if (propName === "response") {
-      response = zodAstToTs(val);
-    }
-  }
-  return { query, body, response, bodyZodText, queryZodText };
-}
-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);
-}
-function resolveRouteName(className, methodName, classAs, methodAs) {
-  const classPortion = classAs ?? deriveClassSegment(className);
-  const methodPortion = methodAs ?? methodName;
-  return `${classPortion}.${methodPortion}`;
-}
-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;
-}
-function extractParams(path) {
-  const matches = path.matchAll(/:(\w+)/g);
-  return Array.from(matches).map((m) => ({ name: m[1], source: "path" }));
-}
-function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
-  if (depth <= 0) return "unknown";
-  if (import_ts_morph9.Node.isArrayTypeNode(typeNode)) {
-    const elementType = typeNode.getElementTypeNode();
-    return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
-  }
-  if (import_ts_morph9.Node.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
-  }
-  if (import_ts_morph9.Node.isIntersectionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
-  }
-  if (import_ts_morph9.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph7.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth)})`;
   }
-  if (import_ts_morph9.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph9.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph7.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" || name === "void") return "unknown";
     if (name === "StreamableFile" || name === "Observable" || name === "ReadableStream")
       return "unknown";
-    if (name === "Ref" || name === "Reference" || name === "LoadedReference" || name === "IdentifiedReference") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      return "unknown";
+    const wrapperMode = WRAPPER_TYPES[name];
+    if (wrapperMode) {
+      return unwrapFirstTypeArg(typeNode, sourceFile, project, depth, wrapperMode);
     }
-    if (name === "Collection") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return `Array<${resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth)}>`;
-      }
-      return "Array<unknown>";
-    }
-    if (name === "Opt" || name === "Loaded") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      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, project, depth)}>`;
-      }
-      return "Array<unknown>";
-    }
-    if (["Record", "Omit", "Pick", "Partial", "Required", "Readonly", "Map", "Set"].includes(name)) {
+    if (PASSTHROUGH_UTILITY.has(name)) {
       return typeNode.getText();
     }
-    if (name === "Promise") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      return "unknown";
-    }
     const resolved = findType(name, sourceFile, project);
     if (resolved) {
       return expandTypeDecl(resolved, project, depth - 1);
@@ -3345,13 +2707,22 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
     return "unknown";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph9.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph9.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph9.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph9.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph9.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph7.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph7.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph7.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph7.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph7.SyntaxKind.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
+function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode) {
+  const typeArgs = typeNode.getTypeArguments();
+  const firstTypeArg = typeArgs[0];
+  if (typeArgs.length > 0 && firstTypeArg !== void 0) {
+    const inner = resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
+    return mode === "arrayOf" ? `Array<${inner}>` : inner;
+  }
+  return mode === "arrayOf" ? "Array<unknown>" : "unknown";
+}
 function expandTypeDecl(result, project, depth) {
   if (depth < 0) return "unknown";
   switch (result.kind) {
@@ -3417,7 +2788,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph9.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph7.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -3430,13 +2801,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph9.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph7.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -3456,7 +2827,7 @@ function extractResponseType(method, sourceFile, project) {
   return "unknown";
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph9.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph7.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -3503,11 +2874,11 @@ function extractDtoContract(method, sourceFile, project) {
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph9.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph7.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph9.Node.isIdentifier(val)) {
+            if (val && import_ts_morph7.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -3524,60 +2895,243 @@ function extractDtoContract(method, sourceFile, project) {
       }
     }
   }
-  let bodyZodText = null;
-  let queryZodText = null;
   let bodySchema = null;
   let querySchema = null;
-  const formNested = {};
   const formWarnings = [];
   const bodyClass = resolveParamClass(method, "Body", sourceFile, project);
   if (bodyClass) {
-    const result = extractZodFromDto(bodyClass.decl, bodyClass.file, project);
-    bodyZodText = result.schemaText;
-    for (const [k, v] of result.namedNestedSchemas) formNested[k] = v;
-    formWarnings.push(...result.warnings);
     bodySchema = extractSchemaFromDto(bodyClass.decl, bodyClass.file, project);
+    formWarnings.push(...bodySchema.warnings);
+  }
+  const queryClass = resolveParamClass(method, "Query", sourceFile, project);
+  if (queryClass) {
+    querySchema = extractSchemaFromDto(queryClass.decl, queryClass.file, project);
+    formWarnings.push(...querySchema.warnings);
+  }
+  return {
+    query,
+    body,
+    response,
+    params: paramsType,
+    queryRef,
+    bodyRef,
+    responseRef,
+    filterFields: filterInfo?.fieldNames ?? null,
+    filterFieldTypes: filterInfo?.fieldTypes ?? null,
+    filterSource: filterInfo?.source ?? null,
+    formWarnings,
+    bodySchema,
+    querySchema
+  };
+}
+function resolveParamClass(method, decoratorName, sourceFile, project) {
+  for (const param of method.getParameters()) {
+    if (!param.getDecorators().some((d) => d.getName() === decoratorName)) continue;
+    const typeNode = param.getTypeNode();
+    if (!typeNode) continue;
+    const text = typeNode.getText().replace(/\[\]$/, "");
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(text)) continue;
+    const resolved = findType(text, sourceFile, project);
+    if (resolved && resolved.kind === "class") {
+      return { decl: resolved.decl, file: resolved.file };
+    }
+  }
+  return null;
+}
+
+// src/discovery/zod-ast-to-ts.ts
+var import_ts_morph8 = require("ts-morph");
+function zodAstToTs(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (import_ts_morph8.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_morph8.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph8.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => import_ts_morph8.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_morph8.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!import_ts_morph8.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_morph8.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_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return import_ts_morph8.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function parseDefineContractCall(callExpr) {
+  if (!import_ts_morph8.Node.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = import_ts_morph8.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph8.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
+  let query = null;
+  let body = null;
+  let response = "unknown";
+  let bodyZodText = null;
+  let queryZodText = null;
+  for (const prop of optsArg.getProperties()) {
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+    const propName = prop.getName();
+    const val = prop.getInitializer();
+    if (!val) continue;
+    if (propName === "query") {
+      query = zodAstToTs(val);
+      queryZodText = val.getText();
+    } else if (propName === "body") {
+      body = zodAstToTs(val);
+      bodyZodText = val.getText();
+    } else if (propName === "response") {
+      response = zodAstToTs(val);
+    }
+  }
+  return { query, body, response, bodyZodText, queryZodText };
+}
+
+// src/discovery/contracts-fast.ts
+async function discoverContractsFast(opts) {
+  const { cwd, glob, tsconfig } = opts;
+  const tsconfigPath = tsconfig ? (0, import_node_path12.resolve)(tsconfig) : (0, import_node_path12.join)(cwd, "tsconfig.json");
+  let project;
+  try {
+    project = new import_ts_morph9.Project({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true
+    });
+  } catch {
+    project = new import_ts_morph9.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 queryClass = resolveParamClass(method, "Query", sourceFile, project);
-  if (queryClass) {
-    const result = extractZodFromDto(queryClass.decl, queryClass.file, project);
-    queryZodText = result.schemaText;
-    for (const [k, v] of result.namedNestedSchemas) formNested[k] = v;
-    formWarnings.push(...result.warnings);
-    querySchema = extractSchemaFromDto(queryClass.decl, queryClass.file, project);
+  const routes = [];
+  setDiscoveryContext(project, {
+    projectRoot: cwd,
+    tsconfigPaths: loadTsconfigPaths(tsconfigPath)
+  });
+  for (const sourceFile of project.getSourceFiles()) {
+    routes.push(...extractFromSourceFile(sourceFile, project));
   }
-  return {
-    query,
-    body,
-    response,
-    params: paramsType,
-    queryRef,
-    bodyRef,
-    responseRef,
-    filterFields: filterInfo?.fieldNames ?? null,
-    filterFieldTypes: filterInfo?.fieldTypes ?? null,
-    filterSource: filterInfo?.source ?? null,
-    bodyZodText,
-    queryZodText,
-    formNestedSchemas: Object.keys(formNested).length > 0 ? formNested : null,
-    formWarnings,
-    bodySchema,
-    querySchema
-  };
+  return routes;
 }
-function resolveParamClass(method, decoratorName, sourceFile, project) {
-  for (const param of method.getParameters()) {
-    if (!param.getDecorators().some((d) => d.getName() === decoratorName)) continue;
-    const typeNode = param.getTypeNode();
-    if (!typeNode) continue;
-    const text = typeNode.getText().replace(/\[\]$/, "");
-    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(text)) continue;
-    const resolved = findType(text, sourceFile, project);
-    if (resolved && resolved.kind === "class") {
-      return { decl: resolved.decl, file: resolved.file };
-    }
+function decoratorStringArg(decoratorExpr) {
+  if (!decoratorExpr) return void 0;
+  if (import_ts_morph9.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph9.Node.isArrayLiteralExpression(decoratorExpr)) {
+    const first = decoratorExpr.getElements()[0];
+    if (first && import_ts_morph9.Node.isStringLiteral(first)) return first.getLiteralValue();
   }
-  return null;
+  return void 0;
+}
+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);
+}
+function resolveRouteName(className, methodName, classAs, methodAs) {
+  const classPortion = classAs ?? deriveClassSegment(className);
+  const methodPortion = methodAs ?? methodName;
+  return `${classPortion}.${methodPortion}`;
+}
+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;
+}
+function extractParams(path) {
+  const matches = path.matchAll(/:(\w+)/g);
+  return Array.from(matches).map((m) => ({ name: m[1], source: "path" }));
 }
 var HTTP_METHOD_DECORATORS = {
   Get: "GET",
@@ -3589,176 +3143,186 @@ var HTTP_METHOD_DECORATORS = {
   Head: "HEAD",
   All: "ALL"
 };
+function resolveVerb(method) {
+  for (const [decoratorName, verb] of Object.entries(HTTP_METHOD_DECORATORS)) {
+    const httpDecorator = method.getDecorator(decoratorName);
+    if (httpDecorator) {
+      const httpArgs = httpDecorator.getArguments();
+      const pathArg = httpArgs[0];
+      return { httpMethod: verb, handlerPath: decoratorStringArg(pathArg) ?? "" };
+    }
+  }
+  return null;
+}
+function readAsDecorator(node, label) {
+  const asDecorator = node.getDecorator("As");
+  if (!asDecorator) return void 0;
+  const asName = decoratorStringArg(asDecorator.getArguments()[0]);
+  if (!asName) {
+    throw new Error(`@As decorator on ${label} must have a non-empty string argument.`);
+  }
+  return asName;
+}
+function buildRoute(args) {
+  const {
+    className,
+    methodName,
+    resolvedMethod,
+    combinedPath,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource
+  } = args;
+  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);
+  return {
+    method: resolvedMethod,
+    path: combinedPath,
+    name: routeName,
+    params: extractParams(combinedPath),
+    controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
+    contract: { contractSource }
+  };
+}
+function extractContractRoute(args) {
+  const { cls, method, applyContractDecorator, verb, prefix, className, sourceFile, seenNames } = args;
+  const firstDecoratorArg = applyContractDecorator.getArguments()[0];
+  if (!firstDecoratorArg) return null;
+  let contractDef = null;
+  let bodyZodRef = null;
+  let queryZodRef = null;
+  if (import_ts_morph9.Node.isCallExpression(firstDecoratorArg)) {
+    contractDef = parseDefineContractCall(firstDecoratorArg);
+  } else if (import_ts_morph9.Node.isIdentifier(firstDecoratorArg)) {
+    const identName = firstDecoratorArg.getText();
+    const varDecl = sourceFile.getVariableDeclaration(identName);
+    if (!varDecl) {
+      console.warn(
+        `[nestjs-codegen/fast] Cannot resolve '${identName}' in ${sourceFile.getFilePath()} (cross-file imports are out-of-scope for v1) \u2014 skipping`
+      );
+      return null;
+    }
+    const initializer = varDecl.getInitializer();
+    if (!initializer) return null;
+    contractDef = parseDefineContractCall(initializer);
+    if (contractDef && varDecl.isExported()) {
+      const filePath = sourceFile.getFilePath();
+      if (contractDef.body !== null) {
+        bodyZodRef = { name: `${identName}.body`, filePath };
+      }
+      if (contractDef.query !== null) {
+        queryZodRef = { name: `${identName}.query`, filePath };
+      }
+    }
+  } else {
+    console.warn(
+      `[nestjs-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`
+    );
+    return null;
+  }
+  if (!contractDef) return null;
+  if (!verb) return null;
+  const resolvedPath = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: resolvedPath,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource: {
+      query: contractDef.query,
+      body: contractDef.body,
+      response: contractDef.response,
+      // Path A: capture both the importable ref and the raw text. The emitter
+      // prefers inlining the text (client-safe — re-exporting from a controller
+      // would drag server-only deps into the client bundle).
+      bodyZodRef,
+      bodyZodText: contractDef.bodyZodText,
+      queryZodRef,
+      queryZodText: contractDef.queryZodText
+    }
+  });
+}
+function extractDtoRoute(args) {
+  const { cls, method, verb, prefix, className, sourceFile, project, seenNames } = args;
+  if (!verb) return null;
+  const combined = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  const dtoContract = extractDtoContract(method, sourceFile, project);
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: combined,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource: {
+      query: dtoContract?.query ?? null,
+      body: dtoContract?.body ?? null,
+      response: dtoContract?.response ?? "unknown",
+      queryRef: dtoContract?.queryRef ?? null,
+      bodyRef: dtoContract?.bodyRef ?? null,
+      responseRef: dtoContract?.responseRef ?? null,
+      filterFields: dtoContract?.filterFields ?? null,
+      filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
+      filterSource: dtoContract?.filterSource ?? null,
+      formWarnings: dtoContract?.formWarnings ?? [],
+      bodySchema: dtoContract?.bodySchema ?? null,
+      querySchema: dtoContract?.querySchema ?? null
+    }
+  });
+}
 function extractFromSourceFile(sourceFile, project) {
   const routes = [];
   const seenNames = /* @__PURE__ */ new Map();
-  const classes = sourceFile.getClasses();
-  for (const cls of classes) {
+  for (const cls of sourceFile.getClasses()) {
     const controllerDecorator = cls.getDecorator("Controller");
     if (!controllerDecorator) continue;
-    const controllerArgs = controllerDecorator.getArguments();
-    const firstArg3 = controllerArgs[0];
-    const prefix = decoratorStringArg(firstArg3) ?? "";
+    const firstArg2 = controllerDecorator.getArguments()[0];
+    const prefix = decoratorStringArg(firstArg2) ?? "";
     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 verb = resolveVerb(method);
       const applyContractDecorator = method.getDecorator("ApplyContract");
-      if (applyContractDecorator) {
-        const decoratorArgs = applyContractDecorator.getArguments();
-        const firstDecoratorArg = decoratorArgs[0];
-        if (!firstDecoratorArg) continue;
-        let contractDef = null;
-        let bodyZodRef = null;
-        let queryZodRef = null;
-        if (import_ts_morph9.Node.isCallExpression(firstDecoratorArg)) {
-          contractDef = parseDefineContractCall(firstDecoratorArg);
-        } else if (import_ts_morph9.Node.isIdentifier(firstDecoratorArg)) {
-          const identName = firstDecoratorArg.getText();
-          const varDecl = sourceFile.getVariableDeclaration(identName);
-          if (!varDecl) {
-            console.warn(
-              `[nestjs-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);
-          if (contractDef && varDecl.isExported()) {
-            const filePath = sourceFile.getFilePath();
-            if (contractDef.body !== null) {
-              bodyZodRef = { name: `${identName}.body`, filePath };
-            }
-            if (contractDef.query !== null) {
-              queryZodRef = { name: `${identName}.query`, filePath };
-            }
-          }
-        } else {
-          console.warn(
-            `[nestjs-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,
-          controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
-          contract: {
-            contractSource: {
-              query: contractDef.query,
-              body: contractDef.body,
-              response: contractDef.response,
-              // Path A: capture both the importable ref and the raw text. The
-              // emitter prefers inlining the text (client-safe — re-exporting from
-              // a controller would drag server-only deps into the client bundle).
-              bodyZodRef,
-              bodyZodText: contractDef.bodyZodText,
-              queryZodRef,
-              queryZodText: contractDef.queryZodText
-            }
-          }
-        });
-      } else {
-        if (!httpMethod) continue;
-        const combined = joinPaths(prefix, handlerPath);
-        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) classAs = classAsName;
-        }
-        const methodAsDecorator = method.getDecorator("As");
-        let methodAs;
-        if (methodAsDecorator) {
-          const methodAsArgs = methodAsDecorator.getArguments();
-          const methodAsName = decoratorStringArg(methodAsArgs[0]);
-          if (methodAsName) methodAs = methodAsName;
-        }
-        const routeName = resolveRouteName(className, methodName, classAs, methodAs);
-        const dtoContract = extractDtoContract(method, sourceFile, project);
-        routes.push({
-          method: httpMethod,
-          path: combined,
-          name: routeName,
-          params,
-          controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
-          contract: {
-            contractSource: {
-              query: dtoContract?.query ?? null,
-              body: dtoContract?.body ?? null,
-              response: dtoContract?.response ?? "unknown",
-              queryRef: dtoContract?.queryRef ?? null,
-              bodyRef: dtoContract?.bodyRef ?? null,
-              responseRef: dtoContract?.responseRef ?? null,
-              filterFields: dtoContract?.filterFields ?? null,
-              filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
-              filterSource: dtoContract?.filterSource ?? null,
-              bodyZodText: dtoContract?.bodyZodText ?? null,
-              queryZodText: dtoContract?.queryZodText ?? null,
-              formNestedSchemas: dtoContract?.formNestedSchemas ?? null,
-              formWarnings: dtoContract?.formWarnings ?? [],
-              bodySchema: dtoContract?.bodySchema ?? null,
-              querySchema: dtoContract?.querySchema ?? null
-            }
-          }
-        });
-      }
+      const route = applyContractDecorator ? extractContractRoute({
+        cls,
+        method,
+        applyContractDecorator,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        seenNames
+      }) : extractDtoRoute({
+        cls,
+        method,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        project,
+        seenNames
+      });
+      if (route) routes.push(route);
     }
   }
   return routes;
@@ -3767,7 +3331,7 @@ function extractFromSourceFile(sourceFile, project) {
 // src/watch/lock-file.ts
 var import_promises10 = require("fs/promises");
 var import_promises11 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var LOCK_FILE = ".watcher.lock";
 function isProcessAlive(pid) {
   try {
@@ -3779,7 +3343,7 @@ function isProcessAlive(pid) {
 }
 async function acquireLock(outDir) {
   await (0, import_promises11.mkdir)(outDir, { recursive: true });
-  const lockPath = (0, import_node_path12.join)(outDir, LOCK_FILE);
+  const lockPath = (0, import_node_path13.join)(outDir, LOCK_FILE);
   const lockData = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   try {
     const fd = await (0, import_promises10.open)(lockPath, "wx");
@@ -3819,7 +3383,7 @@ async function watch(config, onChange) {
   if (lock === null) {
     let holderPid = "unknown";
     try {
-      const raw = await (0, import_promises12.readFile)((0, import_node_path13.join)(config.codegen.outDir, ".watcher.lock"), "utf8");
+      const raw = await (0, import_promises12.readFile)((0, import_node_path14.join)(config.codegen.outDir, ".watcher.lock"), "utf8");
       const data = JSON.parse(raw);
       if (data.pid !== void 0) holderPid = String(data.pid);
     } catch {
@@ -3847,7 +3411,7 @@ async function watch(config, onChange) {
   }
   let pagesDebounceTimer;
   const pagesGlob = config.pages?.glob ?? ".nestjs-codegen-no-pages";
-  const pagesWatcher = import_chokidar.default.watch((0, import_node_path13.join)(config.codegen.cwd, pagesGlob), {
+  const pagesWatcher = import_chokidar.default.watch((0, import_node_path14.join)(config.codegen.cwd, pagesGlob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -3873,7 +3437,7 @@ async function watch(config, onChange) {
   pagesWatcher.on("change", schedulePagesRegenerate);
   pagesWatcher.on("unlink", schedulePagesRegenerate);
   let contractsDebounceTimer;
-  const contractsWatcher = import_chokidar.default.watch((0, import_node_path13.join)(config.codegen.cwd, config.contracts.glob), {
+  const contractsWatcher = import_chokidar.default.watch((0, import_node_path14.join)(config.codegen.cwd, config.contracts.glob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -3903,7 +3467,7 @@ async function watch(config, onChange) {
   contractsWatcher.on("add", scheduleContractsRegenerate);
   contractsWatcher.on("change", scheduleContractsRegenerate);
   contractsWatcher.on("unlink", scheduleContractsRegenerate);
-  const formsWatcher = import_chokidar.default.watch((0, import_node_path13.join)(config.codegen.cwd, config.forms.watch), {
+  const formsWatcher = import_chokidar.default.watch((0, import_node_path14.join)(config.codegen.cwd, config.forms.watch), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
@@ -3930,7 +3494,7 @@ async function watch(config, onChange) {
 }
 
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.4.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -3958,15 +3522,51 @@ async function runCodegen(opts = {}) {
 
 // src/cli/doctor.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path16 = require("path");
 
 // src/cli/init.ts
 var import_node_child_process = require("child_process");
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises13 = require("fs/promises");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var import_node_readline = require("readline");
+
+// src/cli/patch-utils.ts
+var import_node_fs2 = require("fs");
+function patchJsonFile(filePath, mutator, parse = (raw) => raw) {
+  let raw;
+  try {
+    raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+  } catch {
+    return "skipped";
+  }
+  const json = JSON.parse(parse(raw));
+  if (!mutator(json)) return "already";
+  (0, import_node_fs2.writeFileSync)(filePath, `${JSON.stringify(json, null, 2)}
+`, "utf8");
+  return "patched";
+}
+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;
+}
+function insertImport(content, stmt) {
+  const insertAt = findAfterLastImport(content);
+  if (insertAt <= 0) return content;
+  return `${content.slice(0, insertAt)}${stmt}
+${content.slice(insertAt)}`;
+}
+
+// src/cli/init.ts
 var GITIGNORE_ENTRY = ".nestjs-inertia/";
 var green = (s) => `\x1B[32m${s}\x1B[0m`;
 var yellow = (s) => `\x1B[33m${s}\x1B[0m`;
@@ -3991,7 +3591,7 @@ ${bold(title)}`);
 }
 async function readPackageJson(cwd) {
   try {
-    const raw = await (0, import_promises13.readFile)((0, import_node_path14.join)(cwd, "package.json"), "utf8");
+    const raw = await (0, import_promises13.readFile)((0, import_node_path15.join)(cwd, "package.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -4022,7 +3622,7 @@ async function detectTemplateEngine(cwd) {
 async function detectPackageManager(cwd) {
   async function exists(file) {
     try {
-      await (0, import_promises13.access)((0, import_node_path14.join)(cwd, file));
+      await (0, import_promises13.access)((0, import_node_path15.join)(cwd, file));
       return true;
     } catch {
       return false;
@@ -4069,7 +3669,7 @@ async function writeIfNotExists(filePath, content, label) {
   logCreated(label);
 }
 async function handleViteConfig(cwd, framework) {
-  const filePath = (0, import_node_path14.join)(cwd, "vite.config.ts");
+  const filePath = (0, import_node_path15.join)(cwd, "vite.config.ts");
   if (await fileExists2(filePath)) {
     const existing = await (0, import_promises13.readFile)(filePath, "utf8");
     const hasPlugin = existing.includes("nestInertia") || existing.includes("nestjs-inertia-vite/plugin");
@@ -4127,7 +3727,7 @@ function installDeps(pkgManager, deps, dev) {
   }
 }
 async function patchPackageJsonScripts(cwd, scripts) {
-  const pkgPath = (0, import_node_path14.join)(cwd, "package.json");
+  const pkgPath = (0, import_node_path15.join)(cwd, "package.json");
   let pkg = {};
   try {
     pkg = JSON.parse(await (0, import_promises13.readFile)(pkgPath, "utf8"));
@@ -4152,32 +3752,16 @@ async function patchPackageJsonScripts(cwd, scripts) {
   await (0, import_promises13.writeFile)(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
 }
-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;
-}
 function patchAppModule(filePath, rootView) {
   let content;
   try {
-    content = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs3.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)}`;
-    }
+    content = insertImport(content, "import { InertiaModule } from '@dudousxd/nestjs-inertia';");
     if (!content.includes("from 'node:path'") && !content.includes('from "node:path"')) {
       const insertAt2 = findAfterLastImport(content);
       content = `${content.slice(0, insertAt2)}import { resolve } from 'node:path';
@@ -4195,11 +3779,7 @@ ${indent}}),${content.slice(bracketPos)}`;
     }
   }
   if (!content.includes("HomeController")) {
-    const insertAt = findAfterLastImport(content);
-    if (insertAt > 0) {
-      content = `${content.slice(0, insertAt)}import { HomeController } from './home.controller';
-${content.slice(insertAt)}`;
-    }
+    content = insertImport(content, "import { HomeController } from './home.controller';");
     const controllersMatch = content.match(/controllers\s*:\s*\[/);
     if (controllersMatch?.index !== void 0) {
       const bracketPos = content.indexOf("[", controllersMatch.index) + 1;
@@ -4210,22 +3790,21 @@ ${indent}HomeController,${content.slice(bracketPos)}`;
     }
   }
   if (!changed) return "already";
-  (0, import_node_fs2.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs3.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 function patchMainTs(filePath) {
   let content;
   try {
-    content = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs3.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)}`;
-  }
+  content = insertImport(
+    content,
+    "import { setupInertiaVite } from '@dudousxd/nestjs-inertia-vite';"
+  );
   const createMatch = content.match(
     /(?:const|let)\s+(\w+)\s*=\s*await\s+NestFactory\.create[^;]+;/
   );
@@ -4242,7 +3821,7 @@ ${content.slice(insertAt)}`;
   });`;
   content = `${content.slice(0, insertAfterPos)}
 ${viteSetup}${content.slice(insertAfterPos)}`;
-  (0, import_node_fs2.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs3.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 function configTemplate(framework) {
@@ -4465,107 +4044,84 @@ export class HomeController {
 }
 `;
 function patchTsconfigExclude(cwd, dir, filename = "tsconfig.json") {
-  const filePath = (0, import_node_path14.join)(cwd, filename);
-  let raw;
-  try {
-    raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
-  } catch {
-    return "skipped";
-  }
-  const stripped = raw.replace(/\/\/.*$/gm, "");
-  const json = JSON.parse(stripped);
-  const exclude = json.exclude ?? [];
-  if (exclude.includes(dir)) return "already";
-  exclude.push(dir);
-  json.exclude = exclude;
-  (0, import_node_fs2.writeFileSync)(filePath, `${JSON.stringify(json, null, 2)}
-`, "utf8");
-  return "patched";
+  const filePath = (0, import_node_path15.join)(cwd, filename);
+  return patchJsonFile(
+    filePath,
+    (json) => {
+      const exclude = json.exclude ?? [];
+      if (exclude.includes(dir)) return false;
+      exclude.push(dir);
+      json.exclude = exclude;
+      return true;
+    },
+    // Strip single-line comments before JSON.parse
+    (raw) => raw.replace(/\/\/.*$/gm, "")
+  );
 }
 function patchNestCliJson(cwd, shellDir) {
-  const filePath = (0, import_node_path14.join)(cwd, "nest-cli.json");
-  let raw;
-  try {
-    raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
-  } catch {
-    return "skipped";
-  }
-  const json = JSON.parse(raw);
-  const compiler = json.compilerOptions ?? {};
-  const assets = compiler.assets ?? [];
-  const alreadyHas = assets.some((a) => {
-    if (typeof a === "string") return a.includes(shellDir);
-    return String(a.include ?? "").includes(shellDir);
-  });
-  if (alreadyHas) return "already";
-  assets.push({
-    include: `../${shellDir}/**/*`,
-    outDir: `dist/${shellDir}`,
-    watchAssets: true
+  const filePath = (0, import_node_path15.join)(cwd, "nest-cli.json");
+  return patchJsonFile(filePath, (json) => {
+    const compiler = json.compilerOptions ?? {};
+    const assets = compiler.assets ?? [];
+    const alreadyHas = assets.some((a) => {
+      if (typeof a === "string") return a.includes(shellDir);
+      return String(a.include ?? "").includes(shellDir);
+    });
+    if (alreadyHas) return false;
+    assets.push({
+      include: `../${shellDir}/**/*`,
+      outDir: `dist/${shellDir}`,
+      watchAssets: true
+    });
+    compiler.assets = assets;
+    json.compilerOptions = compiler;
+    return true;
   });
-  compiler.assets = assets;
-  json.compilerOptions = compiler;
-  (0, import_node_fs2.writeFileSync)(filePath, `${JSON.stringify(json, null, 2)}
-`, "utf8");
-  return "patched";
 }
-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";
+async function scaffoldFiles(ctx) {
+  const { cwd, framework, engine, shellFileName, entryExt, pageExt } = ctx;
   logSection("Scaffold files");
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "nestjs-inertia.config.ts"),
+    (0, import_node_path15.join)(cwd, "nestjs-inertia.config.ts"),
     configTemplate(framework),
     "nestjs-inertia.config.ts"
   );
-  await writeIfNotExists((0, import_node_path14.join)(cwd, "nestjs-inertia.d.ts"), DTS_TEMPLATE, "nestjs-inertia.d.ts");
+  await writeIfNotExists((0, import_node_path15.join)(cwd, "nestjs-inertia.d.ts"), DTS_TEMPLATE, "nestjs-inertia.d.ts");
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "tsconfig.inertia.json"),
+    (0, import_node_path15.join)(cwd, "tsconfig.inertia.json"),
     TSCONFIG_INERTIA_TEMPLATE,
     "tsconfig.inertia.json"
   );
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "inertia", "tsconfig.json"),
+    (0, import_node_path15.join)(cwd, "inertia", "tsconfig.json"),
     INERTIA_TSCONFIG_TEMPLATE,
     "inertia/tsconfig.json"
   );
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "inertia", shellFileName),
+    (0, import_node_path15.join)(cwd, "inertia", shellFileName),
     htmlShellTemplate(framework, engine),
     `inertia/${shellFileName}`
   );
   await handleViteConfig(cwd, framework);
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "inertia", "app", `client.${entryExt}`),
+    (0, import_node_path15.join)(cwd, "inertia", "app", `client.${entryExt}`),
     entryPointTemplate(framework),
     `inertia/app/client.${entryExt}`
   );
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "inertia", "pages", `Home.${pageExt}`),
+    (0, import_node_path15.join)(cwd, "inertia", "pages", `Home.${pageExt}`),
     samplePageTemplate(framework),
     `inertia/pages/Home.${pageExt}`
   );
   await writeIfNotExists(
-    (0, import_node_path14.join)(cwd, "src", "home.controller.ts"),
+    (0, import_node_path15.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_path14.join)(cwd, "src", "app.module.ts");
+}
+function patchServerAppModule(ctx) {
+  const { cwd, rootView } = ctx;
+  const appModulePath = (0, import_node_path15.join)(cwd, "src", "app.module.ts");
   const appModuleResult = patchAppModule(appModulePath, rootView);
   if (appModuleResult === "patched") {
     logPatched("src/app.module.ts", "added InertiaModule.forRoot");
@@ -4577,7 +4133,9 @@ ${bold("nestjs-inertia init")}`);
   } else {
     logWarning("src/app.module.ts not found \u2014 add InertiaModule.forRoot() manually");
   }
-  const mainTsPath = (0, import_node_path14.join)(cwd, "src", "main.ts");
+}
+function patchServerMainTs(ctx) {
+  const mainTsPath = (0, import_node_path15.join)(ctx.cwd, "src", "main.ts");
   const mainTsResult = patchMainTs(mainTsPath);
   if (mainTsResult === "patched") {
     logPatched("src/main.ts", "added setupInertiaVite after NestFactory.create");
@@ -4586,7 +4144,9 @@ ${bold("nestjs-inertia init")}`);
   } else {
     logWarning("src/main.ts not found \u2014 add setupInertiaVite() manually");
   }
-  const shellDir = rootView.split("/")[0];
+}
+function patchBuildConfigs(ctx) {
+  const { cwd, shellDir } = ctx;
   const nestCliResult = patchNestCliJson(cwd, shellDir);
   if (nestCliResult === "patched") {
     logPatched("nest-cli.json", `added asset copy for ${shellDir}/ \u2192 dist/${shellDir}/`);
@@ -4607,18 +4167,26 @@ ${bold("nestjs-inertia init")}`);
       );
     }
   }
-  await patchGitignore((0, import_node_path14.join)(cwd, ".gitignore"));
+}
+async function patchGitignoreAndDist(ctx) {
+  const { cwd } = ctx;
+  await patchGitignore((0, import_node_path15.join)(cwd, ".gitignore"));
   const tsconfigDistResult = patchTsconfigExclude(cwd, "dist", "tsconfig.json");
   if (tsconfigDistResult === "patched") {
     logPatched("tsconfig.json", "excluded dist/ from server compilation");
   } else if (tsconfigDistResult === "already") {
     console.log(`  ${cyan("\u2192")} tsconfig.json ${dim("(dist/ already excluded, skipped)")}`);
   }
-  await patchPackageJsonScripts(cwd, {
+}
+async function scaffoldPackageScripts(ctx) {
+  await patchPackageJsonScripts(ctx.cwd, {
     "build:client": "vite build",
     "build:ssr": "VITE_SSR=1 vite build --ssr",
     "typecheck:inertia": "tsc --noEmit -p tsconfig.inertia.json"
   });
+}
+async function installMissingDeps(ctx) {
+  const { cwd, framework, opts } = ctx;
   logSection("Install dependencies");
   const pkg = await readPackageJson(cwd);
   const installedDeps = allDeps(pkg);
@@ -4652,6 +4220,55 @@ ${bold("nestjs-inertia init")}`);
     installDeps(pkgManager, depsToInstall, false);
     installDeps(pkgManager, devDepsToInstall, true);
   }
+}
+var INIT_STEPS = [
+  { label: "scaffold files", run: scaffoldFiles },
+  {
+    label: "patch app.module.ts",
+    run: (ctx) => {
+      logSection("Patch existing files");
+      patchServerAppModule(ctx);
+    }
+  },
+  { label: "patch main.ts", run: patchServerMainTs },
+  { label: "patch build configs", run: patchBuildConfigs },
+  { label: "patch .gitignore + dist exclude", run: patchGitignoreAndDist },
+  { label: "add package.json scripts", run: scaffoldPackageScripts },
+  { label: "install dependencies", run: installMissingDeps }
+];
+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 rootView = engine === "html" ? "inertia/index.html" : `inertia/index.${engine === "handlebars" ? "hbs" : engine}`;
+  const ctx = {
+    opts,
+    cwd,
+    framework,
+    engine,
+    shellFileName,
+    entryExt: framework === "react" ? "tsx" : "ts",
+    pageExt: framework === "react" ? "tsx" : framework === "vue" ? "vue" : "svelte",
+    rootView,
+    shellDir: rootView.split("/")[0]
+    // e.g. "inertia" from "inertia/index.html"
+  };
+  for (const step of INIT_STEPS) {
+    if (process.env.NESTJS_CODEGEN_DEBUG) {
+      console.log(dim(`  \xB7 ${step.label}`));
+    }
+    await step.run(ctx);
+  }
   console.log(`
 ${green("\u2713")} Setup complete! Run: ${bold("nest start --watch")}
 `);
@@ -4659,18 +4276,18 @@ ${green("\u2713")} Setup complete! Run: ${bold("nest start --watch")}
 
 // src/cli/doctor.ts
 function checkFileExists(cwd, file) {
-  return (0, import_node_fs3.existsSync)((0, import_node_path15.join)(cwd, file));
+  return (0, import_node_fs4.existsSync)((0, import_node_path16.join)(cwd, file));
 }
 function readJson(path) {
   try {
-    const raw = (0, import_node_fs3.readFileSync)(path, "utf8").replace(/\/\/.*$/gm, "");
+    const raw = (0, import_node_fs4.readFileSync)(path, "utf8").replace(/\/\/.*$/gm, "");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeJsonField(filePath, dotPath, value) {
-  const raw = (0, import_node_fs3.readFileSync)(filePath, "utf8");
+  const raw = (0, import_node_fs4.readFileSync)(filePath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "");
   const obj = JSON.parse(stripped);
   let target = obj;
@@ -4690,20 +4307,20 @@ function writeJsonField(filePath, dotPath, value) {
   } else {
     target[lastKey] = value;
   }
-  (0, import_node_fs3.writeFileSync)(filePath, `${JSON.stringify(obj, null, 2)}
+  (0, import_node_fs4.writeFileSync)(filePath, `${JSON.stringify(obj, null, 2)}
 `, "utf8");
 }
 function getPackageVersion(cwd, pkg) {
   try {
-    const pkgJson = readJson((0, import_node_path15.join)(cwd, "node_modules", pkg, "package.json"));
+    const pkgJson = readJson((0, import_node_path16.join)(cwd, "node_modules", pkg, "package.json"));
     return pkgJson?.version ?? null;
   } catch {
     return null;
   }
 }
 function detectPkgManager(cwd) {
-  if ((0, import_node_fs3.existsSync)((0, import_node_path15.join)(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if ((0, import_node_fs3.existsSync)((0, import_node_path15.join)(cwd, "yarn.lock"))) return "yarn";
+  if ((0, import_node_fs4.existsSync)((0, import_node_path16.join)(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if ((0, import_node_fs4.existsSync)((0, import_node_path16.join)(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function runDoctor(opts) {
@@ -4741,7 +4358,7 @@ async function runDoctor(opts) {
     autoFix: () => runInit({ cwd })
   });
   if (foundShellDir) {
-    const nestCliPath = (0, import_node_path15.join)(cwd, "nest-cli.json");
+    const nestCliPath = (0, import_node_path16.join)(cwd, "nest-cli.json");
     const nestCli = readJson(nestCliPath);
     const compiler = nestCli?.compilerOptions ?? {};
     const assets = compiler.assets ?? [];
@@ -4780,7 +4397,7 @@ async function runDoctor(opts) {
     fix: "Run: nestjs-codegen codegen",
     autoFix: () => runCodegen({ cwd })
   });
-  const tsconfigPath = (0, import_node_path15.join)(cwd, "tsconfig.json");
+  const tsconfigPath = (0, import_node_path16.join)(cwd, "tsconfig.json");
   const tsconfig = readJson(tsconfigPath);
   const paths = tsconfig?.compilerOptions?.paths;
   checks.push({
@@ -4791,7 +4408,7 @@ async function runDoctor(opts) {
   });
   const inertiaDir = foundShellDir ?? "inertia";
   for (const tsconfigFile of ["tsconfig.json", "tsconfig.build.json"]) {
-    const tsc = readJson((0, import_node_path15.join)(cwd, tsconfigFile));
+    const tsc = readJson((0, import_node_path16.join)(cwd, tsconfigFile));
     if (!tsc) continue;
     const excl = tsc.exclude ?? [];
     const excludesIt = excl.includes(inertiaDir);
@@ -4817,14 +4434,14 @@ async function runDoctor(opts) {
       }
     });
   }
-  const inertiaTsconfigPath = (0, import_node_path15.join)(cwd, "tsconfig.inertia.json");
+  const inertiaTsconfigPath = (0, import_node_path16.join)(cwd, "tsconfig.inertia.json");
   const inertiaTsconfig = readJson(inertiaTsconfigPath);
   checks.push({
     name: "tsconfig.inertia.json exists",
     pass: !!inertiaTsconfig,
     fix: "Create tsconfig.inertia.json (typechecks inertia/ + .nestjs-inertia/)",
     autoFix: () => {
-      (0, import_node_fs3.writeFileSync)(inertiaTsconfigPath, TSCONFIG_INERTIA_TEMPLATE, "utf8");
+      (0, import_node_fs4.writeFileSync)(inertiaTsconfigPath, TSCONFIG_INERTIA_TEMPLATE, "utf8");
     }
   });
   if (inertiaTsconfig) {
@@ -4869,17 +4486,17 @@ async function runDoctor(opts) {
       fix: 'Add "nestjs-inertia.d.ts" to include array (resolves InertiaRegistry augmentation)'
     });
   }
-  const innerTsconfigPath = (0, import_node_path15.join)(cwd, "inertia", "tsconfig.json");
+  const innerTsconfigPath = (0, import_node_path16.join)(cwd, "inertia", "tsconfig.json");
   checks.push({
     name: "inertia/tsconfig.json exists (VSCode picks up ~codegen alias)",
-    pass: (0, import_node_fs3.existsSync)(innerTsconfigPath),
+    pass: (0, import_node_fs4.existsSync)(innerTsconfigPath),
     fix: "Create inertia/tsconfig.json that extends ../tsconfig.inertia.json",
     autoFix: () => {
-      (0, import_node_fs3.writeFileSync)(innerTsconfigPath, INERTIA_TSCONFIG_TEMPLATE, "utf8");
+      (0, import_node_fs4.writeFileSync)(innerTsconfigPath, INERTIA_TSCONFIG_TEMPLATE, "utf8");
     }
   });
   if (checkFileExists(cwd, "vite.config.ts")) {
-    const viteContent = (0, import_node_fs3.readFileSync)((0, import_node_path15.join)(cwd, "vite.config.ts"), "utf8");
+    const viteContent = (0, import_node_fs4.readFileSync)((0, import_node_path16.join)(cwd, "vite.config.ts"), "utf8");
     checks.push({
       name: "vite.config.ts has resolve.alias",
       pass: viteContent.includes("resolve") && viteContent.includes("alias"),
@@ -4944,16 +4561,16 @@ async function runDoctor(opts) {
     });
   }
   if (checkFileExists(cwd, ".gitignore")) {
-    const gitignorePath = (0, import_node_path15.join)(cwd, ".gitignore");
-    const gitignore = (0, import_node_fs3.readFileSync)(gitignorePath, "utf8");
+    const gitignorePath = (0, import_node_path16.join)(cwd, ".gitignore");
+    const gitignore = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
     checks.push({
       name: ".gitignore includes .nestjs-inertia/",
       pass: gitignore.includes(".nestjs-inertia"),
       fix: "Add .nestjs-inertia/ to .gitignore",
-      autoFix: () => (0, import_node_fs3.appendFileSync)(gitignorePath, "\n.nestjs-inertia/\n")
+      autoFix: () => (0, import_node_fs4.appendFileSync)(gitignorePath, "\n.nestjs-inertia/\n")
     });
   }
-  const pkgJsonPath = (0, import_node_path15.join)(cwd, "package.json");
+  const pkgJsonPath = (0, import_node_path16.join)(cwd, "package.json");
   const pkgJson = readJson(pkgJsonPath);
   const scripts = pkgJson?.scripts ?? {};
   checks.push({