@dudousxd/nestjs-codegen 0.2.1 → 0.3.0

package/dist/nest/index.cjs

@@ -68,112 +68,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(
@@ -203,8 +100,21 @@ If this is intentional, move the file inside your project directory.`
 function resolveConfig(userConfig, cwd) {
   return applyDefaults(userConfig, cwd ?? process.cwd());
 }
+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) {
@@ -222,7 +132,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",
@@ -249,13 +160,16 @@ function applyDefaults(userConfig, cwd) {
 
 // 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_path3 = require("path");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph7 = require("ts-morph");
+
+// src/discovery/dto-type-resolver.ts
+var import_ts_morph5 = require("ts-morph");
 
 // src/discovery/dto-to-ir.ts
 var import_ts_morph2 = require("ts-morph");
@@ -264,20 +178,13 @@ var import_ts_morph2 = require("ts-morph");
 var import_node_fs = require("fs");
 var import_node_path2 = require("path");
 var import_ts_morph = require("ts-morph");
-var _ctx = { projectRoot: "", tsconfigPaths: null };
-function setDiscoveryContext(ctx) {
-  const prev = _ctx;
-  _ctx = ctx;
-  return prev;
+var _EMPTY_CTX = { projectRoot: "", tsconfigPaths: null };
+var _ctxByProject = /* @__PURE__ */ new WeakMap();
+function setDiscoveryContext(project, ctx) {
+  _ctxByProject.set(project, ctx);
 }
-function restoreDiscoveryContext(ctx) {
-  _ctx = ctx;
-}
-function _projectRoot() {
-  return _ctx.projectRoot;
-}
-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) {
@@ -319,7 +226,7 @@ function findTypeInFile(name, file) {
   }
   return null;
 }
-function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
+function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
   if (moduleSpecifier.startsWith(".")) {
     const dir = (0, import_node_path2.dirname)(sourceFile.getFilePath());
     const noExt = moduleSpecifier.replace(/\.(js|ts)$/, "");
@@ -329,8 +236,9 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
       (0, import_node_path2.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,
@@ -476,7 +384,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);
@@ -829,339 +737,11 @@ function inSchemaFromDecorator(decorator) {
   return null;
 }
 
-// src/discovery/dto-to-zod.ts
-var import_ts_morph3 = 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
-  };
-}
-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(`${toObjectKey2(name)}: ${expr}`);
-  }
-  return `z.object({ ${fields.join(", ")} })`;
-}
-function toObjectKey2(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-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})`);
-    }
-  }
-  if (has("MinLength")) {
-    const n = numericArg2(dec("MinLength"));
-    if (n !== null) refinements.push(`.min(${n})`);
-  }
-  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_morph3.Node.isNumericLiteral(arg)) return arg.getText();
-  return null;
-}
-function numericArgs2(decorator) {
-  const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph3.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_morph3.Node.isObjectLiteralExpression(arg)) {
-      for (const prop of arg.getProperties()) {
-        if (import_ts_morph3.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
-          const init = prop.getInitializer();
-          if (init && import_ts_morph3.Node.isStringLiteral(init)) {
-            return `{ message: ${init.getText()} }`;
-          }
-        }
-      }
-    }
-  }
-  return "";
-}
-function resolveTypeFactoryName2(decorator) {
-  const arg = firstArg2(decorator);
-  if (!arg) return null;
-  if (import_ts_morph3.Node.isArrowFunction(arg)) {
-    const body = arg.getBody();
-    if (import_ts_morph3.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_morph3.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_morph3.Node.isObjectLiteralExpression(arg)) {
-    const values = [];
-    for (const p of arg.getProperties()) {
-      if (!import_ts_morph3.Node.isPropertyAssignment(p)) continue;
-      const init = p.getInitializer();
-      if (init && import_ts_morph3.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_morph3.Node.isArrayLiteralExpression(arg)) {
-    const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph3.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_morph5 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
 
 // src/discovery/filter-field-types.ts
-var import_ts_morph4 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
 
 // src/discovery/enum-resolution.ts
 function resolveEnumValues(name, sourceFile, project) {
@@ -1196,28 +776,28 @@ function markNullable(r, nullable) {
   return nullable ? { ...r, nullable: true } : r;
 }
 function classifyTypeNode(typeNode, sourceFile, project, opts) {
-  if (import_ts_morph4.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph3.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_morph4.SyntaxKind.NullKeyword || kind === import_ts_morph4.SyntaxKind.UndefinedKeyword) {
+      if (kind === import_ts_morph3.SyntaxKind.NullKeyword || kind === import_ts_morph3.SyntaxKind.UndefinedKeyword) {
         nullable = true;
         continue;
       }
-      if (import_ts_morph4.Node.isLiteralTypeNode(member)) {
+      if (import_ts_morph3.Node.isLiteralTypeNode(member)) {
         const lit = member.getLiteral();
-        if (import_ts_morph4.Node.isStringLiteral(lit)) {
+        if (import_ts_morph3.Node.isStringLiteral(lit)) {
           stringLits.push(lit.getLiteralValue());
           continue;
         }
-        if (import_ts_morph4.Node.isNumericLiteral(lit)) {
+        if (import_ts_morph3.Node.isNumericLiteral(lit)) {
           numberLits.push(lit.getText());
           continue;
         }
-        if (lit.getKind() === import_ts_morph4.SyntaxKind.NullKeyword) {
+        if (lit.getKind() === import_ts_morph3.SyntaxKind.NullKeyword) {
           nullable = true;
           continue;
         }
@@ -1237,19 +817,19 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     return markNullable({ kind: "unknown" }, nullable);
   }
   switch (typeNode.getKind()) {
-    case import_ts_morph4.SyntaxKind.StringKeyword:
+    case import_ts_morph3.SyntaxKind.StringKeyword:
       return { kind: "string" };
-    case import_ts_morph4.SyntaxKind.NumberKeyword:
+    case import_ts_morph3.SyntaxKind.NumberKeyword:
       return { kind: "number" };
-    case import_ts_morph4.SyntaxKind.BooleanKeyword:
+    case import_ts_morph3.SyntaxKind.BooleanKeyword:
       return { kind: "boolean" };
-    case import_ts_morph4.SyntaxKind.AnyKeyword:
-    case import_ts_morph4.SyntaxKind.UnknownKeyword:
+    case import_ts_morph3.SyntaxKind.AnyKeyword:
+    case import_ts_morph3.SyntaxKind.UnknownKeyword:
       return { kind: "unknown" };
     default:
       break;
   }
-  if (import_ts_morph4.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph3.Node.isTypeReference(typeNode)) {
     const refName = typeNode.getTypeName().getText();
     if (refName === "Date") return { kind: "date" };
     if (refName === "Record" || refName === "Object") return { kind: "json" };
@@ -1262,25 +842,25 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     if (typeRef) return { kind: "unknown", typeRef };
     return { kind: "unknown" };
   }
-  if (import_ts_morph4.Node.isTypeLiteral(typeNode)) return { kind: "json" };
+  if (import_ts_morph3.Node.isTypeLiteral(typeNode)) return { kind: "json" };
   return { kind: "unknown" };
 }
 function enumFromDecoratorArgs(args, sourceFile, project) {
   for (const arg of args) {
-    if (import_ts_morph4.Node.isArrowFunction(arg)) {
+    if (import_ts_morph3.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph4.Node.isIdentifier(body)) {
+      if (import_ts_morph3.Node.isIdentifier(body)) {
         const en = resolveEnumValues(body.getText(), sourceFile, project);
         if (en) return en;
       }
     }
-    if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
       const itemsProp = arg.getProperty("items");
-      if (itemsProp && import_ts_morph4.Node.isPropertyAssignment(itemsProp)) {
+      if (itemsProp && import_ts_morph3.Node.isPropertyAssignment(itemsProp)) {
         const init = itemsProp.getInitializer();
-        if (init && import_ts_morph4.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph3.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph4.Node.isIdentifier(body)) {
+          if (import_ts_morph3.Node.isIdentifier(body)) {
             const en = resolveEnumValues(body.getText(), sourceFile, project);
             if (en) return en;
           }
@@ -1303,7 +883,7 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
       return { kind: "string" };
     }
     for (const arg of args) {
-      if (import_ts_morph4.Node.isStringLiteral(arg)) {
+      if (import_ts_morph3.Node.isStringLiteral(arg)) {
         const raw = arg.getLiteralValue();
         const kind = classifyTypeKeyword(raw);
         if (kind) {
@@ -1311,11 +891,11 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           return { kind };
         }
       }
-      if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
+      if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
         const enumProp = arg.getProperty("enum");
-        if (enumProp && import_ts_morph4.Node.isPropertyAssignment(enumProp)) {
+        if (enumProp && import_ts_morph3.Node.isPropertyAssignment(enumProp)) {
           const init = enumProp.getInitializer();
-          if (init && import_ts_morph4.Node.isIdentifier(init)) {
+          if (init && import_ts_morph3.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 };
@@ -1324,9 +904,9 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           }
         }
         const typeProp = arg.getProperty("type");
-        if (typeProp && import_ts_morph4.Node.isPropertyAssignment(typeProp)) {
+        if (typeProp && import_ts_morph3.Node.isPropertyAssignment(typeProp)) {
           const init = typeProp.getInitializer();
-          if (init && import_ts_morph4.Node.isStringLiteral(init)) {
+          if (init && import_ts_morph3.Node.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
           }
@@ -1362,7 +942,7 @@ function toFilterFieldType(name, r) {
 
 // src/discovery/filter-for.ts
 function classifyFilterForHint(typeInit) {
-  if (import_ts_morph5.Node.isStringLiteral(typeInit)) {
+  if (import_ts_morph4.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -1376,10 +956,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (import_ts_morph5.Node.isArrayLiteralExpression(typeInit)) {
+  if (import_ts_morph4.Node.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!import_ts_morph5.Node.isStringLiteral(el)) return null;
+      if (!import_ts_morph4.Node.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -1414,11 +994,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && import_ts_morph5.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && import_ts_morph4.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && import_ts_morph5.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph4.Node.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && import_ts_morph5.Node.isPropertyAssignment(typeProp)) {
+      if (typeProp && import_ts_morph4.Node.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -1441,14 +1021,14 @@ function extractApplyFilterInfo(method, sourceFile, project) {
     const args = filterDecorator.getArguments();
     if (args.length === 0) continue;
     const filterClassArg = args[0];
-    if (!filterClassArg || !import_ts_morph5.Node.isIdentifier(filterClassArg)) continue;
+    if (!filterClassArg || !import_ts_morph4.Node.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && import_ts_morph4.Node.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && import_ts_morph5.Node.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && import_ts_morph4.Node.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && import_ts_morph5.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && import_ts_morph4.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
@@ -1511,22 +1091,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && import_ts_morph5.Node.isPropertyAssignment(entityProp)) {
+      if (entityProp && import_ts_morph4.Node.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && import_ts_morph5.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph4.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph5.Node.isIdentifier(body)) {
+          if (import_ts_morph4.Node.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    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)) {
+      if (import_ts_morph4.Node.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -1550,11 +1130,11 @@ function extractFilterableEntityFields(filterClass, project) {
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) return [];
+  if (!import_ts_morph4.Node.isObjectLiteralExpression(optionsArg)) return [];
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph5.Node.isPropertyAssignment(entityProp)) return [];
+  if (!entityProp || !import_ts_morph4.Node.isPropertyAssignment(entityProp)) return [];
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph5.Node.isIdentifier(entityInit)) return [];
+  if (!entityInit || !import_ts_morph4.Node.isIdentifier(entityInit)) return [];
   const entityName = entityInit.getText();
   const filterSourceFile = filterClass.getSourceFile();
   const resolvedEntity = findType(entityName, filterSourceFile, project);
@@ -1570,17 +1150,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_morph5.Node.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && import_ts_morph4.Node.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!import_ts_morph5.Node.isPropertyAssignment(relProp)) continue;
+        if (!import_ts_morph4.Node.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !import_ts_morph5.Node.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !import_ts_morph4.Node.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !import_ts_morph5.Node.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !import_ts_morph4.Node.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !import_ts_morph5.Node.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !import_ts_morph4.Node.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (import_ts_morph5.Node.isStringLiteral(el)) {
+          if (import_ts_morph4.Node.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -1590,267 +1170,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_path3.resolve)(tsconfig) : (0, import_node_path3.join)(cwd, "tsconfig.json");
-  let project;
-  try {
-    project = new import_ts_morph6.Project({
-      tsConfigFilePath: tsconfigPath,
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true
-    });
-  } catch {
-    project = new import_ts_morph6.Project({
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true,
-      compilerOptions: {
-        allowJs: true,
-        resolveJsonModule: false,
-        strict: false
-      }
-    });
-  }
-  const files = await (0, import_fast_glob.default)(glob, { cwd, absolute: true, onlyFiles: true });
-  for (const f of files) {
-    project.addSourceFileAtPath(f);
-  }
-  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);
-  }
-  return routes;
-}
-function zodAstToTs(node) {
-  if (!import_ts_morph6.Node.isCallExpression(node)) return "unknown";
-  const expr = node.getExpression();
-  if (import_ts_morph6.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_morph6.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph6.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph6.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph6.SyntaxKind.FalseKeyword) return "false";
-        return "unknown";
-      }
-      case "enum": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph6.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        const members = arrArg.getElements().map(
-          (el) => import_ts_morph6.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_morph6.Node.isObjectLiteralExpression(objArg)) return "unknown";
-        const lines = [];
-        for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph6.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_morph6.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_morph6.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
-      }
-      default:
-        return "unknown";
-    }
-  }
-  return "unknown";
-}
-function isOptionalChain(node) {
-  if (!import_ts_morph6.Node.isCallExpression(node)) return false;
-  const expr = node.getExpression();
-  return import_ts_morph6.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
-}
-function decoratorStringArg(decoratorExpr) {
-  if (!decoratorExpr) return void 0;
-  if (import_ts_morph6.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph6.Node.isArrayLiteralExpression(decoratorExpr)) {
-    const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph6.Node.isStringLiteral(first)) return first.getLiteralValue();
-  }
-  return void 0;
-}
-function parseDefineContractCall(callExpr) {
-  if (!import_ts_morph6.Node.isCallExpression(callExpr)) return null;
-  const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph6.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph6.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-  if (calleeName !== "defineContract") return null;
-  const args = callExpr.getArguments();
-  const optsArg = args[0];
-  if (!optsArg || !import_ts_morph6.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_morph6.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" }));
-}
+// 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_morph6.Node.isArrayTypeNode(typeNode)) {
+  if (import_ts_morph5.Node.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
   }
-  if (import_ts_morph6.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph5.Node.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
   }
-  if (import_ts_morph6.Node.isIntersectionTypeNode(typeNode)) {
+  if (import_ts_morph5.Node.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
   }
-  if (import_ts_morph6.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph5.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth)})`;
   }
-  if (import_ts_morph6.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph5.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph6.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph5.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);
@@ -1859,13 +1237,22 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
     return "unknown";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph6.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph6.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph6.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph6.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph6.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph5.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph5.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph5.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph5.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph5.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) {
@@ -1931,7 +1318,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph6.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph5.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -1944,13 +1331,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph5.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph6.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph5.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph6.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph5.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -1970,7 +1357,7 @@ function extractResponseType(method, sourceFile, project) {
   return "unknown";
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph6.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph5.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -2017,11 +1404,11 @@ function extractDtoContract(method, sourceFile, project) {
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph5.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph6.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph5.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph6.Node.isIdentifier(val)) {
+            if (val && import_ts_morph5.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -2038,27 +1425,18 @@ 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) {
-    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);
+    formWarnings.push(...querySchema.warnings);
   }
   return {
     query,
@@ -2071,9 +1449,6 @@ function extractDtoContract(method, sourceFile, project) {
     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
@@ -2093,6 +1468,201 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   }
   return null;
 }
+
+// src/discovery/zod-ast-to-ts.ts
+var import_ts_morph6 = require("ts-morph");
+function zodAstToTs(node) {
+  if (!import_ts_morph6.Node.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (import_ts_morph6.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_morph6.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph6.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph6.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph6.SyntaxKind.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph6.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => import_ts_morph6.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_morph6.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!import_ts_morph6.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_morph6.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_morph6.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!import_ts_morph6.Node.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return import_ts_morph6.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function parseDefineContractCall(callExpr) {
+  if (!import_ts_morph6.Node.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = import_ts_morph6.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph6.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !import_ts_morph6.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_morph6.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_path3.resolve)(tsconfig) : (0, import_node_path3.join)(cwd, "tsconfig.json");
+  let project;
+  try {
+    project = new import_ts_morph7.Project({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true
+    });
+  } catch {
+    project = new import_ts_morph7.Project({
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true,
+      compilerOptions: {
+        allowJs: true,
+        resolveJsonModule: false,
+        strict: false
+      }
+    });
+  }
+  const files = await (0, import_fast_glob.default)(glob, { cwd, absolute: true, onlyFiles: true });
+  for (const f of files) {
+    project.addSourceFileAtPath(f);
+  }
+  const routes = [];
+  setDiscoveryContext(project, {
+    projectRoot: cwd,
+    tsconfigPaths: loadTsconfigPaths(tsconfigPath)
+  });
+  for (const sourceFile of project.getSourceFiles()) {
+    routes.push(...extractFromSourceFile(sourceFile, project));
+  }
+  return routes;
+}
+function decoratorStringArg(decoratorExpr) {
+  if (!decoratorExpr) return void 0;
+  if (import_ts_morph7.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph7.Node.isArrayLiteralExpression(decoratorExpr)) {
+    const first = decoratorExpr.getElements()[0];
+    if (first && import_ts_morph7.Node.isStringLiteral(first)) return first.getLiteralValue();
+  }
+  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",
   Post: "POST",
@@ -2103,176 +1673,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_morph7.Node.isCallExpression(firstDecoratorArg)) {
+    contractDef = parseDefineContractCall(firstDecoratorArg);
+  } else if (import_ts_morph7.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_morph6.Node.isCallExpression(firstDecoratorArg)) {
-          contractDef = parseDefineContractCall(firstDecoratorArg);
-        } else if (import_ts_morph6.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;
@@ -2280,8 +1860,7 @@ function extractFromSourceFile(sourceFile, project) {
 
 // src/generate.ts
 var import_promises9 = require("fs/promises");
-var import_node_path11 = require("path");
-var import_ts_morph9 = require("ts-morph");
+var import_node_path12 = require("path");
 
 // src/discovery/pages.ts
 var import_promises2 = require("fs/promises");
@@ -2336,7 +1915,8 @@ function extractPropsSource(source, exportName) {
 }
 
 // src/discovery/shared-props.ts
-var import_ts_morph7 = require("ts-morph");
+var import_node_path5 = require("path");
+var import_ts_morph8 = require("ts-morph");
 function discoverSharedProps(project, moduleEntry) {
   try {
     let sourceFile = project.getSourceFile(moduleEntry);
@@ -2356,14 +1936,39 @@ function discoverSharedProps(project, moduleEntry) {
     return null;
   }
 }
+function discoverSharedPropsFromConfig(config) {
+  if (!config.app?.moduleEntry) return null;
+  try {
+    const tsconfigPath = config.app.tsconfig ?? (0, import_node_path5.join)(config.codegen.cwd, "tsconfig.json");
+    let project;
+    try {
+      project = new import_ts_morph8.Project({
+        tsConfigFilePath: tsconfigPath,
+        skipAddingFilesFromTsConfig: true,
+        skipLoadingLibFiles: true,
+        skipFileDependencyResolution: true
+      });
+    } catch {
+      project = new import_ts_morph8.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_morph7.SyntaxKind.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph8.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
     const expr = call.getExpression();
-    if (!import_ts_morph7.Node.isPropertyAccessExpression(expr)) continue;
+    if (!import_ts_morph8.Node.isPropertyAccessExpression(expr)) continue;
     const methodName = expr.getName();
     const objectExpr = expr.getExpression();
-    if (methodName === "forRoot" && import_ts_morph7.Node.isIdentifier(objectExpr)) {
+    if (methodName === "forRoot" && import_ts_morph8.Node.isIdentifier(objectExpr)) {
       const name = objectExpr.getText();
       if (name === "InertiaModule") {
         return call;
@@ -2373,19 +1978,19 @@ function findForRootCall(sourceFile) {
   return null;
 }
 function findShareInitializer(forRootCall) {
-  if (!import_ts_morph7.Node.isCallExpression(forRootCall)) return null;
+  if (!import_ts_morph8.Node.isCallExpression(forRootCall)) return null;
   const args = forRootCall.getArguments();
-  const firstArg3 = args[0];
-  if (!firstArg3 || !import_ts_morph7.Node.isObjectLiteralExpression(firstArg3)) return null;
-  for (const prop of firstArg3.getProperties()) {
-    if (import_ts_morph7.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
+  const firstArg2 = args[0];
+  if (!firstArg2 || !import_ts_morph8.Node.isObjectLiteralExpression(firstArg2)) return null;
+  for (const prop of firstArg2.getProperties()) {
+    if (import_ts_morph8.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
       return prop.getInitializer() ?? null;
     }
   }
   return null;
 }
 function extractShareType(node, sourceFile, project) {
-  if (import_ts_morph7.Node.isIdentifier(node)) {
+  if (import_ts_morph8.Node.isIdentifier(node)) {
     const ref = resolveIdentifierToImportRef(node, sourceFile, project);
     if (ref) {
       return {
@@ -2395,22 +2000,22 @@ function extractShareType(node, sourceFile, project) {
       };
     }
   }
-  if (import_ts_morph7.Node.isArrowFunction(node)) {
+  if (import_ts_morph8.Node.isArrowFunction(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph7.Node.isFunctionExpression(node)) {
+  if (import_ts_morph8.Node.isFunctionExpression(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph7.Node.isObjectLiteralExpression(node)) {
+  if (import_ts_morph8.Node.isObjectLiteralExpression(node)) {
     const result = extractFromObjectLiteral(node);
     return result ? { ...result, isImportRef: false } : null;
   }
   return null;
 }
 function resolveIdentifierToImportRef(id, sourceFile, project) {
-  if (!import_ts_morph7.Node.isIdentifier(id)) return null;
+  if (!import_ts_morph8.Node.isIdentifier(id)) return null;
   const name = id.getText();
   const localFunc = sourceFile.getFunction(name);
   if (localFunc?.isExported()) {
@@ -2444,49 +2049,49 @@ function resolveIdentifierToImportRef(id, sourceFile, project) {
   return null;
 }
 function extractFromFunctionLike(node, _sourceFile) {
-  const returnTypeNode = import_ts_morph7.Node.isArrowFunction(node) || import_ts_morph7.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  const returnTypeNode = import_ts_morph8.Node.isArrowFunction(node) || import_ts_morph8.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
   if (returnTypeNode) {
     return extractFromReturnTypeAnnotation(returnTypeNode);
   }
-  if (import_ts_morph7.Node.isArrowFunction(node)) {
+  if (import_ts_morph8.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (import_ts_morph7.Node.isParenthesizedExpression(body)) {
+    if (import_ts_morph8.Node.isParenthesizedExpression(body)) {
       const inner = body.getExpression();
-      if (import_ts_morph7.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph8.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
-    if (import_ts_morph7.Node.isObjectLiteralExpression(body)) {
+    if (import_ts_morph8.Node.isObjectLiteralExpression(body)) {
       return extractFromObjectLiteral(body);
     }
-    if (import_ts_morph7.Node.isBlock(body)) {
+    if (import_ts_morph8.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
-  if (import_ts_morph7.Node.isFunctionExpression(node)) {
+  if (import_ts_morph8.Node.isFunctionExpression(node)) {
     const body = node.getBody();
-    if (import_ts_morph7.Node.isBlock(body)) {
+    if (import_ts_morph8.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
   return null;
 }
 function extractFromReturnTypeAnnotation(typeNode) {
-  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph8.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    if (import_ts_morph7.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
+    if (import_ts_morph8.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;
     }
   }
-  if (import_ts_morph7.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph8.Node.isTypeLiteral(typeNode)) {
     const properties = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph7.Node.isPropertySignature(member)) {
+      if (import_ts_morph8.Node.isPropertySignature(member)) {
         const name = member.getName();
         const memberTypeNode = member.getTypeNode();
         const type = memberTypeNode ? memberTypeNode.getText() : "unknown";
@@ -2500,19 +2105,19 @@ function extractFromReturnTypeAnnotation(typeNode) {
   return null;
 }
 function extractFromBlockReturn(block) {
-  if (!import_ts_morph7.Node.isBlock(block)) return null;
+  if (!import_ts_morph8.Node.isBlock(block)) return null;
   const statements = block.getStatements();
   for (let i = statements.length - 1; i >= 0; i--) {
     const stmt = statements[i];
-    if (!import_ts_morph7.Node.isReturnStatement(stmt)) continue;
+    if (!import_ts_morph8.Node.isReturnStatement(stmt)) continue;
     const expr = stmt.getExpression();
     if (!expr) continue;
-    if (import_ts_morph7.Node.isObjectLiteralExpression(expr)) {
+    if (import_ts_morph8.Node.isObjectLiteralExpression(expr)) {
       return extractFromObjectLiteral(expr);
     }
-    if (import_ts_morph7.Node.isParenthesizedExpression(expr)) {
+    if (import_ts_morph8.Node.isParenthesizedExpression(expr)) {
       const inner = expr.getExpression();
-      if (import_ts_morph7.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph8.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
@@ -2521,10 +2126,10 @@ function extractFromBlockReturn(block) {
   return null;
 }
 function extractFromObjectLiteral(objLiteral) {
-  if (!import_ts_morph7.Node.isObjectLiteralExpression(objLiteral)) return null;
+  if (!import_ts_morph8.Node.isObjectLiteralExpression(objLiteral)) return null;
   const properties = [];
   for (const prop of objLiteral.getProperties()) {
-    if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
     const initializer = prop.getInitializer();
     if (!initializer) continue;
@@ -2536,21 +2141,21 @@ function extractFromObjectLiteral(objLiteral) {
   return { typeString, properties, isImportRef: false };
 }
 function inferExpressionType(node) {
-  if (import_ts_morph7.Node.isStringLiteral(node)) return "string";
-  if (import_ts_morph7.Node.isTemplateExpression(node) || import_ts_morph7.Node.isNoSubstitutionTemplateLiteral(node))
+  if (import_ts_morph8.Node.isStringLiteral(node)) return "string";
+  if (import_ts_morph8.Node.isTemplateExpression(node) || import_ts_morph8.Node.isNoSubstitutionTemplateLiteral(node))
     return "string";
-  if (import_ts_morph7.Node.isNumericLiteral(node)) return "number";
-  if (node.getKind() === import_ts_morph7.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph7.SyntaxKind.FalseKeyword) {
+  if (import_ts_morph8.Node.isNumericLiteral(node)) return "number";
+  if (node.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) {
     return "boolean";
   }
-  if (node.getKind() === import_ts_morph7.SyntaxKind.NullKeyword) return "null";
-  if (import_ts_morph7.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
-  if (import_ts_morph7.Node.isObjectLiteralExpression(node)) {
+  if (node.getKind() === import_ts_morph8.SyntaxKind.NullKeyword) return "null";
+  if (import_ts_morph8.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
+  if (import_ts_morph8.Node.isObjectLiteralExpression(node)) {
     const props = node.getProperties();
     if (props.length === 0) return "Record<string, unknown>";
     const entries = [];
     for (const prop of props) {
-      if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
+      if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
       const key = prop.getName();
       const init = prop.getInitializer();
       if (!init) continue;
@@ -2559,23 +2164,23 @@ function inferExpressionType(node) {
     if (entries.length === 0) return "Record<string, unknown>";
     return `{ ${entries.join("; ")} }`;
   }
-  if (import_ts_morph7.Node.isArrayLiteralExpression(node)) {
+  if (import_ts_morph8.Node.isArrayLiteralExpression(node)) {
     const elements = node.getElements();
     if (elements.length === 0) return "Array<unknown>";
     const first = elements[0];
     if (first) return `Array<${inferExpressionType(first)}>`;
     return "Array<unknown>";
   }
-  if (import_ts_morph7.Node.isConditionalExpression(node)) {
+  if (import_ts_morph8.Node.isConditionalExpression(node)) {
     const whenTrue = inferExpressionType(node.getWhenTrue());
     const whenFalse = inferExpressionType(node.getWhenFalse());
     if (whenTrue === whenFalse) return whenTrue;
     return `${whenTrue} | ${whenFalse}`;
   }
-  if (import_ts_morph7.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph8.Node.isParenthesizedExpression(node)) {
     return inferExpressionType(node.getExpression());
   }
-  if (import_ts_morph7.Node.isAsExpression(node)) {
+  if (import_ts_morph8.Node.isAsExpression(node)) {
     const typeNode = node.getTypeNode();
     if (typeNode) return typeNode.getText();
   }
@@ -2584,25 +2189,14 @@ function inferExpressionType(node) {
 
 // src/emit/emit-api.ts
 var import_promises3 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 
 // src/extension/registry.ts
-var import_ts_morph8 = require("ts-morph");
+var import_ts_morph9 = 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(
@@ -2614,11 +2208,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 {
@@ -2630,7 +2235,7 @@ function createExtensionContext(config, getRoutes) {
     },
     project() {
       if (!project) {
-        project = new import_ts_morph8.Project({
+        project = new import_ts_morph9.Project({
           skipAddingFilesFromTsConfig: true,
           skipLoadingLibFiles: true,
           skipFileDependencyResolution: true,
@@ -2663,29 +2268,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_path5.join)(outDir, "api.ts"), content, "utf8");
+  await (0, import_promises3.writeFile)((0, import_node_path6.join)(outDir, "api.ts"), content, "utf8");
 }
 function splitName(name) {
   return name.split(".");
 }
-function toObjectKey3(segment) {
+function toObjectKey(segment) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
     return segment;
   }
@@ -2778,7 +2390,7 @@ function emitFilterQueryType(c) {
 }
 function buildResponseType(c, outDir) {
   if (c.controllerRef) {
-    let relPath = (0, import_node_path5.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    let relPath = (0, import_node_path6.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
     if (!relPath.startsWith(".")) relPath = `./${relPath}`;
     return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
   }
@@ -2792,7 +2404,7 @@ function emitRouterTypeBlock(tree, indent, outDir) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey3(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "leaf") {
       const c = node;
       const method = c.method.toUpperCase();
@@ -2818,15 +2430,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']`);
@@ -2848,7 +2457,6 @@ function buildRequestModel(c) {
     urlExpr,
     optsExpr,
     responseType: `${TA}['response']`,
-    bodyType: `${TA}['body']`,
     queryKeyExpr: `[${flat}, input] as const`
   };
 }
@@ -2896,7 +2504,7 @@ function emitApiObjectBlock(tree, indent, p) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey3(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "branch") {
       lines.push(`${pad}${objKey}: {`);
       lines.push(...emitApiObjectBlock(node.children, indent + 2, p));
@@ -2904,30 +2512,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;
@@ -2936,10 +2542,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);
@@ -2984,7 +2662,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);
@@ -3000,8 +2677,8 @@ function buildApiFile(routes, outDir, opts = {}) {
     const emittedNames = /* @__PURE__ */ new Set();
     for (const [filePath, names] of importsByFile) {
       let relPath;
-      if ((0, import_node_path5.isAbsolute)(filePath)) {
-        relPath = (0, import_node_path5.relative)(outDir, filePath).replace(/\.ts$/, "");
+      if ((0, import_node_path6.isAbsolute)(filePath)) {
+        relPath = (0, import_node_path6.relative)(outDir, filePath).replace(/\.ts$/, "");
         if (!relPath.startsWith(".")) relPath = `./${relPath}`;
       } else {
         relPath = filePath;
@@ -3029,27 +2706,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();
@@ -3067,7 +2725,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);
   }
@@ -3080,7 +2739,6 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("  return {");
   lines.push(
     ...emitApiObjectBlock(tree, 4, {
-      ...transport ? { transport } : {},
       ...layer ? { layer } : {},
       memberExts,
       ctx
@@ -3091,61 +2749,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) {
@@ -3157,7 +2763,7 @@ function buildApiFile(routes, outDir, opts = {}) {
 
 // src/emit/emit-cache.ts
 var import_promises4 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 async function emitCache(pages, outDir) {
   await (0, import_promises4.mkdir)(outDir, { recursive: true });
   const entries = await Promise.all(
@@ -3171,95 +2777,21 @@ async function emitCache(pages, outDir) {
     })
   );
   const cache = { pages: entries };
-  await (0, import_promises4.writeFile)((0, import_node_path6.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises4.writeFile)((0, import_node_path7.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 
 // src/emit/emit-forms.ts
 var import_promises5 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_node_path8 = 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_path7.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_path7.join)(outDir, "forms.ts"), content, "utf8");
+  await (0, import_promises5.writeFile)((0, import_node_path8.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("");
 }
@@ -3269,124 +2801,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_path7.relative)(outDir, filePath).replace(/\.ts$/, "");
+  let relPath = (0, import_node_path8.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;
@@ -3452,20 +2876,172 @@ 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}`;
+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 ?? []
+    });
+  }
+  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 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 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);
+      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, t] of allNested) lines.push(`const ${n} = ${t};`);
+    lines.push("");
   }
-  return "z.unknown()";
+  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_path8 = require("path");
+var import_node_path9 = 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';"];
@@ -3478,12 +3054,12 @@ async function emitIndex(outDir, hasContracts = false, hasForms = false) {
   const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports2, ""].join(
     "\n"
   );
-  await (0, import_promises6.writeFile)((0, import_node_path8.join)(outDir, "index.d.ts"), content, "utf8");
+  await (0, import_promises6.writeFile)((0, import_node_path9.join)(outDir, "index.d.ts"), content, "utf8");
 }
 
 // src/emit/emit-pages.ts
 var import_promises7 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path10 = 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";
@@ -3504,7 +3080,7 @@ ${augBody}
   }
 ${sharedPropsBlock}}
 `;
-  await (0, import_promises7.writeFile)((0, import_node_path9.join)(outDir, "pages.d.ts"), content, "utf8");
+  await (0, import_promises7.writeFile)((0, import_node_path10.join)(outDir, "pages.d.ts"), content, "utf8");
 }
 function buildSharedPropsBlock(sharedProps) {
   if (!sharedProps) return "";
@@ -3523,7 +3099,7 @@ ${propsBody}
 `;
 }
 function buildAugmentationType(page, outDir) {
-  let importPath = (0, import_node_path9.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
+  let importPath = (0, import_node_path10.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
   if (!importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
@@ -3535,11 +3111,11 @@ function needsQuotes(name) {
 
 // src/emit/emit-routes.ts
 var import_promises8 = require("fs/promises");
-var import_node_path10 = require("path");
+var import_node_path11 = 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_path10.join)(outDir, "routes.ts"), content, "utf8");
+  await (0, import_promises8.writeFile)((0, import_node_path11.join)(outDir, "routes.ts"), content, "utf8");
 }
 function buildRoutesFile(routes) {
   if (routes.length === 0) {
@@ -3667,30 +3243,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_path11.join)(config.codegen.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, strict: false }
-          });
-        }
-        sharedProps = discoverSharedProps(project, config.app.moduleEntry);
-      } catch {
-      }
-    }
+    const sharedProps = discoverSharedPropsFromConfig(config);
     await emitPages(pages, config.codegen.outDir, {
       propsExport: pagesConfig.propsExport,
       sharedProps
@@ -3714,8 +3267,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_path11.join)(config.codegen.outDir, file.path);
-      await (0, import_promises9.mkdir)((0, import_node_path11.dirname)(dest), { recursive: true });
+      const dest = (0, import_node_path12.join)(config.codegen.outDir, file.path);
+      await (0, import_promises9.mkdir)((0, import_node_path12.dirname)(dest), { recursive: true });
       await (0, import_promises9.writeFile)(dest, file.contents, "utf8");
     }
   }
@@ -3724,7 +3277,7 @@ async function generate(config, inputRoutes = []) {
 // 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 {
@@ -3736,7 +3289,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");
@@ -3776,7 +3329,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 {
@@ -3804,7 +3357,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 }
@@ -3830,7 +3383,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 }
@@ -3860,7 +3413,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 }