@dudousxd/nestjs-codegen 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -42,10 +42,10 @@ __export(src_exports, {
   extractSchemaFromDto: () => extractSchemaFromDto,
   generate: () => generate,
   loadConfig: () => loadConfig,
+  renderTsType: () => renderTsType,
   resolveAdapter: () => resolveAdapter,
   resolveConfig: () => resolveConfig,
-  watch: () => watch,
-  zodAdapter: () => zodAdapter
+  watch: () => watch
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -73,112 +73,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(
@@ -231,8 +128,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) {
@@ -250,7 +160,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",
@@ -304,18 +215,12 @@ Run \`nestjs-codegen init\` to create a starter config.`
       `Config file must have a default export. Did you forget \`export default defineConfig({...})\`? (${configPath})`
     );
   }
-  if (userConfig.pages && typeof userConfig.pages.glob !== "string") {
-    throw new ConfigError(
-      `Config validation failed: \`pages.glob\` must be a string when \`pages\` is set (${configPath})`
-    );
-  }
   return applyDefaults(userConfig, resolvedCwd);
 }
 
 // src/generate.ts
 var import_promises9 = require("fs/promises");
-var import_node_path9 = require("path");
-var import_ts_morph3 = require("ts-morph");
+var import_node_path10 = require("path");
 
 // src/discovery/pages.ts
 var import_promises2 = require("fs/promises");
@@ -370,6 +275,7 @@ function extractPropsSource(source, exportName) {
 }
 
 // src/discovery/shared-props.ts
+var import_node_path3 = require("path");
 var import_ts_morph = require("ts-morph");
 function discoverSharedProps(project, moduleEntry) {
   try {
@@ -390,6 +296,31 @@ function discoverSharedProps(project, moduleEntry) {
     return null;
   }
 }
+function discoverSharedPropsFromConfig(config) {
+  if (!config.app?.moduleEntry) return null;
+  try {
+    const tsconfigPath = config.app.tsconfig ?? (0, import_node_path3.join)(config.codegen.cwd, "tsconfig.json");
+    let project;
+    try {
+      project = new import_ts_morph.Project({
+        tsConfigFilePath: tsconfigPath,
+        skipAddingFilesFromTsConfig: true,
+        skipLoadingLibFiles: true,
+        skipFileDependencyResolution: true
+      });
+    } catch {
+      project = new import_ts_morph.Project({
+        skipAddingFilesFromTsConfig: true,
+        skipLoadingLibFiles: true,
+        skipFileDependencyResolution: true,
+        compilerOptions: { allowJs: true, strict: false }
+      });
+    }
+    return discoverSharedProps(project, config.app.moduleEntry);
+  } catch {
+    return null;
+  }
+}
 function findForRootCall(sourceFile) {
   const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
@@ -409,9 +340,9 @@ function findForRootCall(sourceFile) {
 function findShareInitializer(forRootCall) {
   if (!import_ts_morph.Node.isCallExpression(forRootCall)) return null;
   const args = forRootCall.getArguments();
-  const firstArg3 = args[0];
-  if (!firstArg3 || !import_ts_morph.Node.isObjectLiteralExpression(firstArg3)) return null;
-  for (const prop of firstArg3.getProperties()) {
+  const firstArg2 = args[0];
+  if (!firstArg2 || !import_ts_morph.Node.isObjectLiteralExpression(firstArg2)) return null;
+  for (const prop of firstArg2.getProperties()) {
     if (import_ts_morph.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
       return prop.getInitializer() ?? null;
     }
@@ -510,9 +441,9 @@ function extractFromReturnTypeAnnotation(typeNode) {
     const typeName = typeNode.getTypeName();
     if (import_ts_morph.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
       const typeArgs = typeNode.getTypeArguments();
-      const firstArg3 = typeArgs[0];
-      if (firstArg3) {
-        return extractFromReturnTypeAnnotation(firstArg3);
+      const firstArg2 = typeArgs[0];
+      if (firstArg2) {
+        return extractFromReturnTypeAnnotation(firstArg2);
       }
       return null;
     }
@@ -618,25 +549,14 @@ function inferExpressionType(node) {
 
 // src/emit/emit-api.ts
 var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 
 // src/extension/registry.ts
 var import_ts_morph2 = require("ts-morph");
 function resolveApiSlots(extensions) {
-  let transport;
-  let transportOwner;
   let layer;
   let layerOwner;
   for (const ext of extensions) {
-    if (ext.apiTransport) {
-      if (transport) {
-        throw new CodegenError(
-          `api transport claimed by both "${transportOwner}" and "${ext.name}" \u2014 only one extension may set apiTransport.`
-        );
-      }
-      transport = ext.apiTransport;
-      transportOwner = ext.name;
-    }
     if (ext.apiClientLayer) {
       if (layer) {
         throw new CodegenError(
@@ -648,11 +568,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 {
@@ -697,29 +628,36 @@ async function collectEmittedFiles(extensions, ctx) {
           `Extension "${ext.name}" tried to emit the core-owned file "${file.path}". Core files (${[...CORE_FILES].join(", ")}) cannot be produced by extensions.`
         );
       }
-      const prev = owners.get(key);
-      if (prev !== void 0) {
-        throw new CodegenError(
-          `Output file "${file.path}" is emitted by both "${prev}" and "${ext.name}". Two extensions cannot write the same file.`
-        );
-      }
-      owners.set(key, ext.name);
+      mergeExclusive(owners, [[key, file]], {
+        owner: ext.name,
+        describe: (_key, prevOwner, owner) => `Output file "${file.path}" is emitted by both "${prevOwner}" and "${owner}". Two extensions cannot write the same file.`
+      });
       files.push(file);
     }
   }
   return files;
 }
 
+// src/extension/types.ts
+function requestShape(route) {
+  const cs = route.contract?.contractSource;
+  const isGet = route.method.toUpperCase() === "GET";
+  const isQuery = isGet || !!cs?.filterFields?.length;
+  const hasBody = !!cs?.bodyRef || cs?.body != null && cs.body !== "never";
+  const hasQuery = isGet || !!cs?.queryRef || cs?.query != null && cs.query !== "never";
+  return { isGet, isQuery, hasBody, hasQuery };
+}
+
 // src/emit/emit-api.ts
 async function emitApi(routes, outDir, opts = {}) {
   await (0, import_promises3.mkdir)(outDir, { recursive: true });
   const content = buildApiFile(routes, outDir, opts);
-  await (0, import_promises3.writeFile)((0, import_node_path3.join)(outDir, "api.ts"), content, "utf8");
+  await (0, import_promises3.writeFile)((0, import_node_path4.join)(outDir, "api.ts"), content, "utf8");
 }
 function splitName(name) {
   return name.split(".");
 }
-function toObjectKey2(segment) {
+function toObjectKey(segment) {
   if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
     return segment;
   }
@@ -812,7 +750,7 @@ function emitFilterQueryType(c) {
 }
 function buildResponseType(c, outDir) {
   if (c.controllerRef) {
-    let relPath = (0, import_node_path3.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    let relPath = (0, import_node_path4.relative)(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
     if (!relPath.startsWith(".")) relPath = `./${relPath}`;
     return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
   }
@@ -826,7 +764,7 @@ function emitRouterTypeBlock(tree, indent, outDir) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey2(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "leaf") {
       const c = node;
       const method = c.method.toUpperCase();
@@ -852,15 +790,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']`);
@@ -882,7 +817,6 @@ function buildRequestModel(c) {
     urlExpr,
     optsExpr,
     responseType: `${TA}['response']`,
-    bodyType: `${TA}['body']`,
     queryKeyExpr: `[${flat}, input] as const`
   };
 }
@@ -930,7 +864,7 @@ function emitApiObjectBlock(tree, indent, p) {
   const pad = " ".repeat(indent);
   const lines = [];
   for (const [key, node] of tree) {
-    const objKey = toObjectKey2(key);
+    const objKey = toObjectKey(key);
     if (node.kind === "branch") {
       lines.push(`${pad}${objKey}: {`);
       lines.push(...emitApiObjectBlock(node.children, indent + 2, p));
@@ -938,30 +872,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;
@@ -970,10 +902,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);
@@ -1018,7 +1022,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);
@@ -1034,8 +1037,8 @@ function buildApiFile(routes, outDir, opts = {}) {
     const emittedNames = /* @__PURE__ */ new Set();
     for (const [filePath, names] of importsByFile) {
       let relPath;
-      if ((0, import_node_path3.isAbsolute)(filePath)) {
-        relPath = (0, import_node_path3.relative)(outDir, filePath).replace(/\.ts$/, "");
+      if ((0, import_node_path4.isAbsolute)(filePath)) {
+        relPath = (0, import_node_path4.relative)(outDir, filePath).replace(/\.ts$/, "");
         if (!relPath.startsWith(".")) relPath = `./${relPath}`;
       } else {
         relPath = filePath;
@@ -1063,27 +1066,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();
@@ -1101,7 +1085,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);
   }
@@ -1114,7 +1099,6 @@ function buildApiFile(routes, outDir, opts = {}) {
   lines.push("  return {");
   lines.push(
     ...emitApiObjectBlock(tree, 4, {
-      ...transport ? { transport } : {},
       ...layer ? { layer } : {},
       memberExts,
       ctx
@@ -1125,61 +1109,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) {
@@ -1191,7 +1123,7 @@ function buildApiFile(routes, outDir, opts = {}) {
 
 // src/emit/emit-cache.ts
 var import_promises4 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 async function emitCache(pages, outDir) {
   await (0, import_promises4.mkdir)(outDir, { recursive: true });
   const entries = await Promise.all(
@@ -1205,95 +1137,21 @@ async function emitCache(pages, outDir) {
     })
   );
   const cache = { pages: entries };
-  await (0, import_promises4.writeFile)((0, import_node_path4.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
+  await (0, import_promises4.writeFile)((0, import_node_path5.join)(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 
 // src/emit/emit-forms.ts
 var import_promises5 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 async function emitForms(routes, outDir, config, adapter) {
   if (config && config.enabled === false) return false;
-  if (adapter && adapter.name !== "zod") {
-    const content2 = buildFormsFileWithAdapter(routes, adapter);
-    if (content2 === null) return false;
-    await (0, import_promises5.mkdir)(outDir, { recursive: true });
-    await (0, import_promises5.writeFile)((0, import_node_path5.join)(outDir, "forms.ts"), content2, "utf8");
-    return true;
-  }
-  const entries = collectFormEntries(routes);
-  if (entries.length === 0) return false;
+  const content = buildFormsFileWithAdapter(routes, outDir, adapter, config);
+  if (content === null) return false;
   await (0, import_promises5.mkdir)(outDir, { recursive: true });
-  const content = buildFormsFile(entries, outDir, config);
-  await (0, import_promises5.writeFile)((0, import_node_path5.join)(outDir, "forms.ts"), content, "utf8");
+  await (0, import_promises5.writeFile)((0, import_node_path6.join)(outDir, "forms.ts"), content, "utf8");
   return true;
 }
-function buildFormsFileWithAdapter(routes, adapter) {
-  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
-  const methodNameCounts = /* @__PURE__ */ new Map();
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    if (!cs.bodySchema && !cs.querySchema) continue;
-    methodNameCounts.set(
-      deriveBaseName(route.name).method,
-      (methodNameCounts.get(deriveBaseName(route.name).method) ?? 0) + 1
-    );
-  }
-  const named = /* @__PURE__ */ new Map();
-  const decls = [];
-  const mapEntries = [];
-  let used = false;
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    const { method, full } = deriveBaseName(route.name);
-    const base = (methodNameCounts.get(method) ?? 0) > 1 ? full : method;
-    const block = [];
-    if (cs.bodyZodText && !cs.bodySchema) {
-      block.push(
-        `// warning: ${route.name} body is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
-      );
-    }
-    let bodyConst;
-    if (cs.bodySchema) {
-      used = true;
-      const r = adapter.renderModule(cs.bodySchema);
-      for (const [n, t] of r.namedNestedSchemas) named.set(n, t);
-      bodyConst = `${base}BodySchema`;
-      block.push(`export const ${bodyConst} = ${r.schemaText};`);
-      block.push(`export type ${base}Body = ${adapter.inferType(bodyConst)};`);
-    }
-    if (cs.querySchema) {
-      used = true;
-      const r = adapter.renderModule(cs.querySchema);
-      for (const [n, t] of r.namedNestedSchemas) named.set(n, t);
-      const queryConst = `${base}QuerySchema`;
-      block.push(`export const ${queryConst} = ${r.schemaText};`);
-      block.push(`export type ${base}Query = ${adapter.inferType(queryConst)};`);
-    }
-    if (block.length === 0) continue;
-    decls.push(`// ${route.name}`, ...block, "");
-    if (bodyConst) mapEntries.push(`  ${JSON.stringify(route.name)}: ${bodyConst},`);
-  }
-  if (!used) return null;
-  const lines = ["// Generated by @dudousxd/nestjs-codegen. Do not edit."];
-  for (const imp of adapter.importStatements({ used: true })) lines.push(imp);
-  lines.push("");
-  if (named.size > 0) {
-    lines.push("// Hoisted nested schemas (shared across endpoints).");
-    for (const [n, t] of named) lines.push(`const ${n} = ${t};`);
-    lines.push("");
-  }
-  lines.push(...decls);
-  lines.push("/** Route name \u2192 body schema map. */");
-  lines.push("export const formSchemas = {");
-  lines.push(...mapEntries);
-  lines.push("} as const;");
-  lines.push("");
-  return lines.join("\n");
-}
-function hasSchema(src) {
-  return !!src && (src.ref !== null || src.text !== null);
-}
 function pascal(segment) {
   return segment.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
@@ -1303,124 +1161,16 @@ function deriveBaseName(routeName) {
   const full = segments.map(pascal).join("");
   return { method, full };
 }
-function collectFormEntries(routes) {
-  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
-  const methodNameCounts = /* @__PURE__ */ new Map();
-  const candidates = [];
-  for (const route of sorted) {
-    const cs = route.contract.contractSource;
-    const body = { ref: cs.bodyZodRef ?? null, text: cs.bodyZodText ?? null };
-    const query = { ref: cs.queryZodRef ?? null, text: cs.queryZodText ?? null };
-    if (!hasSchema(body) && !hasSchema(query)) continue;
-    const { method, full } = deriveBaseName(route.name);
-    methodNameCounts.set(method, (methodNameCounts.get(method) ?? 0) + 1);
-    candidates.push({ route, method, full });
-  }
-  const entries = [];
-  for (const { route, method, full } of candidates) {
-    const cs = route.contract.contractSource;
-    const collision = (methodNameCounts.get(method) ?? 0) > 1;
-    const baseName = collision ? full : method;
-    const body = { ref: cs.bodyZodRef ?? null, text: cs.bodyZodText ?? null };
-    const query = { ref: cs.queryZodRef ?? null, text: cs.queryZodText ?? null };
-    entries.push({
-      routeName: route.name,
-      baseName,
-      body: hasSchema(body) ? body : void 0,
-      query: hasSchema(query) ? query : void 0,
-      nestedSchemas: cs.formNestedSchemas ?? null,
-      warnings: cs.formWarnings ?? []
-    });
-  }
-  return entries;
-}
 function relImport(outDir, filePath) {
-  let relPath = (0, import_node_path5.relative)(outDir, filePath).replace(/\.ts$/, "");
+  let relPath = (0, import_node_path6.relative)(outDir, filePath).replace(/\.ts$/, "");
   if (!relPath.startsWith(".")) relPath = `./${relPath}`;
   return relPath;
 }
 function refRootIdentifier(refName) {
   return refName.split(".")[0] ?? refName;
 }
-function buildFormsFile(entries, outDir, config) {
-  const zodImport = config?.zodImport ?? "zod";
-  const lines = [
-    "// Generated by @dudousxd/nestjs-codegen. Do not edit.",
-    `import { z } from '${zodImport}';`
-  ];
-  const importsByFile = /* @__PURE__ */ new Map();
-  const refAlias = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const src of [entry.body, entry.query]) {
-      if (src?.ref && !src.text) {
-        const root = refRootIdentifier(src.ref.name);
-        const set = importsByFile.get(src.ref.filePath) ?? /* @__PURE__ */ new Set();
-        set.add(root);
-        importsByFile.set(src.ref.filePath, set);
-      }
-    }
-  }
-  if (importsByFile.size > 0) {
-    const emitted = /* @__PURE__ */ new Set();
-    for (const [filePath, roots] of [...importsByFile.entries()].sort()) {
-      const relPath = relImport(outDir, filePath);
-      const specifiers = [];
-      for (const root of [...roots].sort()) {
-        if (emitted.has(root)) {
-          const alias = `${root}_${emitted.size}`;
-          specifiers.push(`${root} as ${alias}`);
-          emitted.add(alias);
-          refAlias.set(`${filePath}\0${root}`, alias);
-        } else {
-          specifiers.push(root);
-          emitted.add(root);
-          refAlias.set(`${filePath}\0${root}`, root);
-        }
-      }
-      lines.push(`import { ${specifiers.join(", ")} } from '${relPath}';`);
-    }
-  }
-  lines.push("");
-  const { globalSchemas, renamesByEntry } = planNestedSchemas(entries);
-  if (globalSchemas.size > 0) {
-    lines.push("// Hoisted nested schemas (shared across endpoints).");
-    for (const [name, text] of globalSchemas) {
-      lines.push(`const ${name} = ${text};`);
-    }
-    lines.push("");
-  }
-  const mapEntries = [];
-  for (const entry of entries) {
-    lines.push(`// ${entry.routeName}`);
-    if (entry.warnings && entry.warnings.length > 0) {
-      for (const w of entry.warnings) {
-        lines.push(`// warning: ${w}`);
-      }
-    }
-    const rename = renamesByEntry.get(entry) ?? null;
-    if (entry.body) {
-      const schemaName = `${entry.baseName}BodySchema`;
-      const typeName = `${entry.baseName}Body`;
-      const text = applyRenames(renderSchema(entry.body, outDir, refAlias), rename);
-      lines.push(`export const ${schemaName} = ${text};`);
-      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-      mapEntries.push(`  ${JSON.stringify(entry.routeName)}: ${schemaName},`);
-    }
-    if (entry.query) {
-      const schemaName = `${entry.baseName}QuerySchema`;
-      const typeName = `${entry.baseName}Query`;
-      const text = applyRenames(renderSchema(entry.query, outDir, refAlias), rename);
-      lines.push(`export const ${schemaName} = ${text};`);
-      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
-    }
-    lines.push("");
-  }
-  lines.push("/** Route name \u2192 body schema map. */");
-  lines.push("export const formSchemas = {");
-  lines.push(...mapEntries);
-  lines.push("} as const;");
-  lines.push("");
-  return lines.join("\n");
+function hasSource(src) {
+  return !!(src.schema || src.zodText || src.zodRef);
 }
 function applyRenames(text, renames) {
   if (!renames || renames.size === 0) return text;
@@ -1486,38 +1236,200 @@ function planNestedSchemas(entries) {
   }
   return { globalSchemas, renamesByEntry };
 }
-function renderSchema(src, outDir, refAlias) {
-  if (src.text) return src.text;
-  if (src.ref) {
-    const root = refRootIdentifier(src.ref.name);
-    const alias = refAlias.get(`${src.ref.filePath}\0${root}`) ?? root;
-    const member = src.ref.name.slice(root.length);
-    return `${alias}${member}`;
-  }
-  return "z.unknown()";
-}
-
-// src/emit/emit-index.ts
-var import_promises6 = require("fs/promises");
-var import_node_path6 = require("path");
-async function emitIndex(outDir, hasContracts = false, hasForms = false) {
-  await (0, import_promises6.mkdir)(outDir, { recursive: true });
-  const exports2 = ["export * from './pages.js';", "export * from './routes.js';"];
-  if (hasContracts) {
-    exports2.push("export * from './api.js';");
+function buildFormsFileWithAdapter(routes, outDir, adapter, config) {
+  const acceptsRawZod = adapter.acceptsRawZodSource === true;
+  const sorted = [...routes].filter((r) => r.contract).sort((a, b) => a.name.localeCompare(b.name));
+  const methodNameCounts = /* @__PURE__ */ new Map();
+  const candidates = [];
+  for (const route of sorted) {
+    const cs = route.contract.contractSource;
+    const body = {
+      schema: cs.bodySchema ?? null,
+      zodText: cs.bodyZodText ?? null,
+      zodRef: cs.bodyZodRef ?? null
+    };
+    const query = {
+      schema: cs.querySchema ?? null,
+      zodText: cs.queryZodText ?? null,
+      zodRef: cs.queryZodRef ?? null
+    };
+    if (!hasSource(body) && !hasSource(query)) continue;
+    const { method, full } = deriveBaseName(route.name);
+    methodNameCounts.set(method, (methodNameCounts.get(method) ?? 0) + 1);
+    candidates.push({
+      routeName: route.name,
+      baseName: full,
+      // resolved below
+      body: hasSource(body) ? body : void 0,
+      query: hasSource(query) ? query : void 0,
+      nestedSchemas: cs.formNestedSchemas ?? null,
+      warnings: cs.formWarnings ?? []
+    });
   }
-  if (hasForms) {
-    exports2.push("export * from './forms.js';");
+  const entries = candidates.map((c) => {
+    const { method, full } = deriveBaseName(c.routeName);
+    const collision = (methodNameCounts.get(method) ?? 0) > 1;
+    return { ...c, baseName: collision ? full : method };
+  });
+  if (entries.length === 0) return null;
+  const importsByFile = /* @__PURE__ */ new Map();
+  const refAlias = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const src of [entry.body, entry.query]) {
+      if (src?.zodRef && !src.zodText && !src.schema) {
+        const root = refRootIdentifier(src.zodRef.name);
+        const set = importsByFile.get(src.zodRef.filePath) ?? /* @__PURE__ */ new Set();
+        set.add(root);
+        importsByFile.set(src.zodRef.filePath, set);
+      }
+    }
   }
-  const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports2, ""].join(
-    "\n"
-  );
-  await (0, import_promises6.writeFile)((0, import_node_path6.join)(outDir, "index.d.ts"), content, "utf8");
-}
-
-// src/emit/emit-pages.ts
-var import_promises7 = require("fs/promises");
+  const importLines = [];
+  if (importsByFile.size > 0) {
+    const emitted = /* @__PURE__ */ new Set();
+    for (const [filePath, roots] of [...importsByFile.entries()].sort()) {
+      const relPath = relImport(outDir, filePath);
+      const specifiers = [];
+      for (const root of [...roots].sort()) {
+        if (emitted.has(root)) {
+          const alias = `${root}_${emitted.size}`;
+          specifiers.push(`${root} as ${alias}`);
+          emitted.add(alias);
+          refAlias.set(`${filePath}\0${root}`, alias);
+        } else {
+          specifiers.push(root);
+          emitted.add(root);
+          refAlias.set(`${filePath}\0${root}`, root);
+        }
+      }
+      importLines.push(`import { ${specifiers.join(", ")} } from '${relPath}';`);
+    }
+  }
+  const { globalSchemas, renamesByEntry } = planNestedSchemas(entries);
+  const irNamed = /* @__PURE__ */ new Map();
+  const irTypeAliases = /* @__PURE__ */ new Map();
+  const irAnnotations = /* @__PURE__ */ new Map();
+  const decls = [];
+  const mapEntries = [];
+  let used = false;
+  const renderSource = (src, rename) => {
+    if (src.schema) {
+      const r = adapter.renderModule(src.schema);
+      for (const [n, t] of r.namedNestedSchemas) irNamed.set(n, t);
+      if (r.namedTypeAliases) for (const [n, t] of r.namedTypeAliases) irTypeAliases.set(n, t);
+      if (r.namedAnnotations) for (const [n, a] of r.namedAnnotations) irAnnotations.set(n, a);
+      return { text: r.schemaText };
+    }
+    if (src.zodText) {
+      if (!acceptsRawZod) {
+        return {
+          text: "",
+          warn: `is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
+        };
+      }
+      return { text: applyRenames(src.zodText, rename) };
+    }
+    if (src.zodRef) {
+      if (!acceptsRawZod) {
+        return {
+          text: "",
+          warn: `is a defineContract (zod) schema; not translated to ${adapter.name} \u2014 use the zod adapter.`
+        };
+      }
+      const root = refRootIdentifier(src.zodRef.name);
+      const alias = refAlias.get(`${src.zodRef.filePath}\0${root}`) ?? root;
+      const member = src.zodRef.name.slice(root.length);
+      return { text: `${alias}${member}` };
+    }
+    return null;
+  };
+  for (const entry of entries) {
+    const block = [];
+    const rename = renamesByEntry.get(entry) ?? null;
+    let bodyConst;
+    if (entry.warnings && entry.warnings.length > 0) {
+      for (const w of entry.warnings) block.push(`// warning: ${w}`);
+    }
+    if (entry.body) {
+      const rendered = renderSource(entry.body, rename);
+      if (rendered?.warn) {
+        block.push(`// warning: ${entry.routeName} body ${rendered.warn}`);
+      } else if (rendered) {
+        used = true;
+        bodyConst = `${entry.baseName}BodySchema`;
+        block.push(`export const ${bodyConst} = ${rendered.text};`);
+        block.push(`export type ${entry.baseName}Body = ${adapter.inferType(bodyConst)};`);
+      }
+    }
+    if (entry.query) {
+      const rendered = renderSource(entry.query, rename);
+      if (rendered?.warn) {
+        block.push(`// warning: ${entry.routeName} query ${rendered.warn}`);
+      } else if (rendered) {
+        used = true;
+        const queryConst = `${entry.baseName}QuerySchema`;
+        block.push(`export const ${queryConst} = ${rendered.text};`);
+        block.push(`export type ${entry.baseName}Query = ${adapter.inferType(queryConst)};`);
+      }
+    }
+    if (block.length === 0) continue;
+    decls.push(`// ${entry.routeName}`, ...block, "");
+    if (bodyConst) mapEntries.push(`  ${JSON.stringify(entry.routeName)}: ${bodyConst},`);
+  }
+  if (!used) return null;
+  const lines = ["// Generated by @dudousxd/nestjs-codegen. Do not edit."];
+  if (acceptsRawZod) {
+    const zodImport = config?.zodImport ?? "zod";
+    lines.push(`import { z } from '${zodImport}';`);
+  } else {
+    for (const imp of adapter.importStatements({ used: true })) lines.push(imp);
+  }
+  lines.push(...importLines);
+  lines.push("");
+  const allNested = /* @__PURE__ */ new Map();
+  for (const [n, t] of globalSchemas) allNested.set(n, t);
+  for (const [n, t] of irNamed) if (!allNested.has(n)) allNested.set(n, t);
+  if (allNested.size > 0) {
+    lines.push("// Hoisted nested schemas (shared across endpoints).");
+    for (const [n, alias] of irTypeAliases) {
+      if (allNested.has(n)) lines.push(`${alias};`);
+    }
+    for (const [n, t] of allNested) {
+      const annotation = irAnnotations.get(n);
+      lines.push(`const ${n}${annotation ? `: ${annotation}` : ""} = ${t};`);
+    }
+    lines.push("");
+  }
+  lines.push(...decls);
+  lines.push("/** Route name \u2192 body schema map. */");
+  lines.push("export const formSchemas = {");
+  lines.push(...mapEntries);
+  lines.push("} as const;");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/emit/emit-index.ts
+var import_promises6 = require("fs/promises");
 var import_node_path7 = require("path");
+async function emitIndex(outDir, hasContracts = false, hasForms = false) {
+  await (0, import_promises6.mkdir)(outDir, { recursive: true });
+  const exports2 = ["export * from './pages.js';", "export * from './routes.js';"];
+  if (hasContracts) {
+    exports2.push("export * from './api.js';");
+  }
+  if (hasForms) {
+    exports2.push("export * from './forms.js';");
+  }
+  const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports2, ""].join(
+    "\n"
+  );
+  await (0, import_promises6.writeFile)((0, import_node_path7.join)(outDir, "index.d.ts"), content, "utf8");
+}
+
+// src/emit/emit-pages.ts
+var import_promises7 = require("fs/promises");
+var import_node_path8 = require("path");
 async function emitPages(pages, outDir, _options = {}) {
   await (0, import_promises7.mkdir)(outDir, { recursive: true });
   const pageNameUnion = pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never";
@@ -1538,7 +1450,7 @@ ${augBody}
   }
 ${sharedPropsBlock}}
 `;
-  await (0, import_promises7.writeFile)((0, import_node_path7.join)(outDir, "pages.d.ts"), content, "utf8");
+  await (0, import_promises7.writeFile)((0, import_node_path8.join)(outDir, "pages.d.ts"), content, "utf8");
 }
 function buildSharedPropsBlock(sharedProps) {
   if (!sharedProps) return "";
@@ -1557,7 +1469,7 @@ ${propsBody}
 `;
 }
 function buildAugmentationType(page, outDir) {
-  let importPath = (0, import_node_path7.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
+  let importPath = (0, import_node_path8.relative)(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
   if (!importPath.startsWith(".")) {
     importPath = `./${importPath}`;
   }
@@ -1569,11 +1481,11 @@ function needsQuotes(name) {
 
 // src/emit/emit-routes.ts
 var import_promises8 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 async function emitRoutes(routes, outDir) {
   await (0, import_promises8.mkdir)(outDir, { recursive: true });
   const content = buildRoutesFile(routes);
-  await (0, import_promises8.writeFile)((0, import_node_path8.join)(outDir, "routes.ts"), content, "utf8");
+  await (0, import_promises8.writeFile)((0, import_node_path9.join)(outDir, "routes.ts"), content, "utf8");
 }
 function buildRoutesFile(routes) {
   if (routes.length === 0) {
@@ -1701,30 +1613,7 @@ async function generate(config, inputRoutes = []) {
       propsExport: pagesConfig.propsExport,
       componentNameStrategy: pagesConfig.componentNameStrategy
     });
-    let sharedProps = null;
-    if (config.app?.moduleEntry) {
-      try {
-        const tsconfigPath = config.app.tsconfig ?? (0, import_node_path9.join)(config.codegen.cwd, "tsconfig.json");
-        let project;
-        try {
-          project = new import_ts_morph3.Project({
-            tsConfigFilePath: tsconfigPath,
-            skipAddingFilesFromTsConfig: true,
-            skipLoadingLibFiles: true,
-            skipFileDependencyResolution: true
-          });
-        } catch {
-          project = new import_ts_morph3.Project({
-            skipAddingFilesFromTsConfig: true,
-            skipLoadingLibFiles: true,
-            skipFileDependencyResolution: true,
-            compilerOptions: { allowJs: true, strict: false }
-          });
-        }
-        sharedProps = discoverSharedProps(project, config.app.moduleEntry);
-      } catch {
-      }
-    }
+    const sharedProps = discoverSharedPropsFromConfig(config);
     await emitPages(pages, config.codegen.outDir, {
       propsExport: pagesConfig.propsExport,
       sharedProps
@@ -1748,8 +1637,8 @@ async function generate(config, inputRoutes = []) {
   if (extensions.length > 0) {
     const extraFiles = await collectEmittedFiles(extensions, ctx);
     for (const file of extraFiles) {
-      const dest = (0, import_node_path9.join)(config.codegen.outDir, file.path);
-      await (0, import_promises9.mkdir)((0, import_node_path9.dirname)(dest), { recursive: true });
+      const dest = (0, import_node_path10.join)(config.codegen.outDir, file.path);
+      await (0, import_promises9.mkdir)((0, import_node_path10.dirname)(dest), { recursive: true });
       await (0, import_promises9.writeFile)(dest, file.contents, "utf8");
     }
   }
@@ -1757,35 +1646,31 @@ async function generate(config, inputRoutes = []) {
 
 // src/watch/watcher.ts
 var import_promises12 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var import_chokidar = __toESM(require("chokidar"), 1);
 
 // src/discovery/contracts-fast.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var import_ts_morph9 = require("ts-morph");
 
+// src/discovery/dto-type-resolver.ts
+var import_ts_morph7 = require("ts-morph");
+
 // src/discovery/dto-to-ir.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
 
 // src/discovery/type-ref-resolution.ts
 var import_node_fs = require("fs");
-var import_node_path10 = require("path");
-var import_ts_morph4 = require("ts-morph");
-var _ctx = { projectRoot: "", tsconfigPaths: null };
-function setDiscoveryContext(ctx) {
-  const prev = _ctx;
-  _ctx = ctx;
-  return prev;
-}
-function restoreDiscoveryContext(ctx) {
-  _ctx = ctx;
-}
-function _projectRoot() {
-  return _ctx.projectRoot;
+var import_node_path11 = require("path");
+var import_ts_morph3 = require("ts-morph");
+var _EMPTY_CTX = { projectRoot: "", tsconfigPaths: null };
+var _ctxByProject = /* @__PURE__ */ new WeakMap();
+function setDiscoveryContext(project, ctx) {
+  _ctxByProject.set(project, ctx);
 }
-function _tsconfigPaths() {
-  return _ctx.tsconfigPaths;
+function _ctxFor(project) {
+  return _ctxByProject.get(project) ?? _EMPTY_CTX;
 }
 var _debug = process.env.NESTJS_INERTIA_DEBUG === "1";
 function dbg(...args) {
@@ -1827,18 +1712,19 @@ function findTypeInFile(name, file) {
   }
   return null;
 }
-function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
+function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
   if (moduleSpecifier.startsWith(".")) {
-    const dir = (0, import_node_path10.dirname)(sourceFile.getFilePath());
+    const dir = (0, import_node_path11.dirname)(sourceFile.getFilePath());
     const noExt = moduleSpecifier.replace(/\.(js|ts)$/, "");
     return [
-      (0, import_node_path10.resolve)(dir, `${noExt}.ts`),
-      (0, import_node_path10.resolve)(dir, `${moduleSpecifier}.ts`),
-      (0, import_node_path10.resolve)(dir, moduleSpecifier, "index.ts")
+      (0, import_node_path11.resolve)(dir, `${noExt}.ts`),
+      (0, import_node_path11.resolve)(dir, `${moduleSpecifier}.ts`),
+      (0, import_node_path11.resolve)(dir, moduleSpecifier, "index.ts")
     ];
   }
-  const baseUrl = _projectRoot();
-  const tsconfigPaths = _tsconfigPaths();
+  const ctx = _ctxFor(project);
+  const baseUrl = ctx.projectRoot;
+  const tsconfigPaths = ctx.tsconfigPaths;
   dbg(
     "resolveModuleSpecifier",
     moduleSpecifier,
@@ -1854,8 +1740,8 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
         const rest = moduleSpecifier.slice(prefix.length);
         const candidates = [];
         for (const mapping of mappings) {
-          const resolved = (0, import_node_path10.resolve)(baseUrl, mapping.replace("*", rest));
-          candidates.push(`${resolved}.ts`, (0, import_node_path10.resolve)(resolved, "index.ts"));
+          const resolved = (0, import_node_path11.resolve)(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, (0, import_node_path11.resolve)(resolved, "index.ts"));
         }
         dbg("  resolved candidates:", candidates);
         return candidates;
@@ -1955,13 +1841,13 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     name = nodeOrName;
   } else {
     const typeNode = nodeOrName;
-    if (opts.unwrapContainers && import_ts_morph4.Node.isArrayTypeNode(typeNode)) {
+    if (opts.unwrapContainers && import_ts_morph3.Node.isArrayTypeNode(typeNode)) {
       const inner = resolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project, opts);
       return inner ? { ...inner, isArray: true } : null;
     }
-    if (!import_ts_morph4.Node.isTypeReference(typeNode)) return null;
+    if (!import_ts_morph3.Node.isTypeReference(typeNode)) return null;
     const typeName = typeNode.getTypeName();
-    const refName = import_ts_morph4.Node.isIdentifier(typeName) ? typeName.getText() : null;
+    const refName = import_ts_morph3.Node.isIdentifier(typeName) ? typeName.getText() : null;
     if (!refName) return null;
     if (opts.unwrapContainers && refName === "Promise") {
       const first = typeNode.getTypeArguments()[0];
@@ -1984,7 +1870,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);
@@ -2053,10 +1939,7 @@ function extractSchemaFromDto(classDecl, sourceFile, project) {
     depth: 0
   };
   const root = buildObject(classDecl, sourceFile, ctx);
-  for (const schemaName of ctx.recursiveSchemas) {
-    ctx.named.set(schemaName, { kind: "unknown", note: "recursive type \u2014 not expanded" });
-  }
-  return { root, named: ctx.named, warnings: ctx.warnings };
+  return { root, named: ctx.named, warnings: ctx.warnings, recursive: ctx.recursiveSchemas };
 }
 function buildObject(classDecl, classFile, ctx) {
   const props = classDecl.getProperties();
@@ -2076,7 +1959,7 @@ function buildProperty(prop, classFile, ctx) {
   const dec = (n) => decorators.get(n);
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
+  const isArrayType = !!typeNode && import_ts_morph4.Node.isArrayTypeNode(typeNode);
   const typeRefName = resolveTypeFactoryName(dec("Type"));
   if (has("ValidateNested") || typeRefName) {
     const childName = typeRefName ?? singularClassName(typeText);
@@ -2207,18 +2090,27 @@ function baseFromType(typeText, isArrayType) {
   }
 }
 function buildNestedReference(className, fromFile, ctx) {
-  if (ctx.visiting.has(className) || ctx.depth >= 8) {
+  if (ctx.visiting.has(className)) {
     const reserved = ctx.emittedClasses.get(className) ?? aliasFor(className, ctx);
     ctx.emittedClasses.set(className, reserved);
     ctx.recursiveSchemas.add(reserved);
     if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
       ctx.warnedDecorators.add(`recursive:${reserved}`);
-      const msg = `${className} is a recursive type and was not expanded; the generated schema uses unknown for it.`;
+      const msg = `${className} is a recursive type; the generated schema validates it via a lazy self-reference.`;
       ctx.warnings.push(msg);
       console.warn(`[nestjs-codegen] ${msg}`);
     }
     return { kind: "lazyRef", name: reserved };
   }
+  if (ctx.depth >= 8) {
+    if (!ctx.warnedDecorators.has(`deep:${className}`)) {
+      ctx.warnedDecorators.add(`deep:${className}`);
+      const msg = `${className} nesting is too deep to expand; the generated schema uses unknown for it.`;
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen] ${msg}`);
+    }
+    return { kind: "unknown", note: "nesting too deep \u2014 not expanded" };
+  }
   const existing = ctx.emittedClasses.get(className);
   if (existing) return { kind: "ref", name: existing };
   const schemaName = aliasFor(className, ctx);
@@ -2256,22 +2148,22 @@ function firstArgText(decorator) {
 }
 function numericArg(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph5.Node.isNumericLiteral(arg)) return arg.getText();
+  if (arg && import_ts_morph4.Node.isNumericLiteral(arg)) return arg.getText();
   return null;
 }
 function numericArgs(decorator) {
   const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph5.Node.isNumericLiteral(n) ? n.getText() : null;
+  const num = (n) => n && import_ts_morph4.Node.isNumericLiteral(n) ? n.getText() : null;
   return [num(args[0]), num(args[1])];
 }
 function messageRaw(decorator) {
   const args = decorator?.getArguments() ?? [];
   for (const arg of args) {
-    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph5.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
+        if (import_ts_morph4.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
           const init = prop.getInitializer();
-          if (init && import_ts_morph5.Node.isStringLiteral(init)) return init.getText();
+          if (init && import_ts_morph4.Node.isStringLiteral(init)) return init.getText();
         }
       }
     }
@@ -2281,9 +2173,9 @@ function messageRaw(decorator) {
 function resolveTypeFactoryName(decorator) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph5.Node.isArrowFunction(arg)) {
+  if (import_ts_morph4.Node.isArrowFunction(arg)) {
     const body = arg.getBody();
-    if (import_ts_morph5.Node.isIdentifier(body)) return body.getText();
+    if (import_ts_morph4.Node.isIdentifier(body)) return body.getText();
   }
   return null;
 }
@@ -2294,7 +2186,7 @@ function singularClassName(typeText) {
 function enumSchemaFromDecorator(decorator, classFile, ctx) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph5.Node.isIdentifier(arg)) {
+  if (import_ts_morph4.Node.isIdentifier(arg)) {
     const name = arg.getText();
     const resolved = findType(name, classFile, ctx.project);
     if (resolved && resolved.kind === "enum") {
@@ -2308,12 +2200,12 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
     }
     return { kind: "unknown", note: `@IsEnum(${name}): enum not resolvable to literals` };
   }
-  if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+  if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
     const values = [];
     for (const p of arg.getProperties()) {
-      if (!import_ts_morph5.Node.isPropertyAssignment(p)) continue;
+      if (!import_ts_morph4.Node.isPropertyAssignment(p)) continue;
       const init = p.getInitializer();
-      if (init && import_ts_morph5.Node.isStringLiteral(init)) values.push(init.getText());
+      if (init && import_ts_morph4.Node.isStringLiteral(init)) values.push(init.getText());
     }
     if (values.length > 0) return { kind: "enum", literals: values };
   }
@@ -2321,9 +2213,9 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
 }
 function inSchemaFromDecorator(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph5.Node.isArrayLiteralExpression(arg)) {
+  if (arg && import_ts_morph4.Node.isArrayLiteralExpression(arg)) {
     const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph5.Node.isStringLiteral(e));
+    const allStrings = elements.every((e) => import_ts_morph4.Node.isStringLiteral(e));
     if (allStrings && elements.length > 0) {
       return { kind: "enum", literals: elements.map((e) => e.getText()) };
     }
@@ -2337,458 +2229,130 @@ function inSchemaFromDecorator(decorator) {
   return null;
 }
 
-// src/discovery/dto-to-zod.ts
+// src/discovery/filter-for.ts
 var import_ts_morph6 = require("ts-morph");
-var KNOWN_DECORATORS2 = /* @__PURE__ */ new Set([
-  "IsString",
-  "IsNumber",
-  "IsInt",
-  "IsBoolean",
-  "IsDate",
-  "IsEmail",
-  "IsUrl",
-  "IsUUID",
-  "MinLength",
-  "MaxLength",
-  "Length",
-  "Min",
-  "Max",
-  "IsPositive",
-  "IsNegative",
-  "Matches",
-  "IsEnum",
-  "IsIn",
-  "IsOptional",
-  "IsNotEmpty",
-  "IsArray",
-  "ValidateNested",
-  "Type",
-  "IsObject",
-  "Allow",
-  "IsDefined"
-]);
-function extractZodFromDto(classDecl, sourceFile, project) {
-  const ctx = {
-    sourceFile,
-    project,
-    namedNestedSchemas: /* @__PURE__ */ new Map(),
-    warnings: [],
-    warnedDecorators: /* @__PURE__ */ new Set(),
-    emittedClasses: /* @__PURE__ */ new Map(),
-    visiting: /* @__PURE__ */ new Set(),
-    recursiveSchemas: /* @__PURE__ */ new Set(),
-    depth: 0
-  };
-  const schemaText = buildObjectSchema(classDecl, sourceFile, ctx);
-  for (const schemaName of ctx.recursiveSchemas) {
-    ctx.namedNestedSchemas.set(schemaName, "z.unknown() /* recursive type \u2014 not expanded */");
-  }
-  return {
-    schemaText,
-    namedNestedSchemas: ctx.namedNestedSchemas,
-    warnings: ctx.warnings
-  };
+
+// src/discovery/filter-field-types.ts
+var import_ts_morph5 = require("ts-morph");
+
+// src/discovery/enum-resolution.ts
+function resolveEnumValues(name, sourceFile, project) {
+  const resolved = findType(name, sourceFile, project);
+  if (!resolved || resolved.kind !== "enum") return null;
+  let numeric = true;
+  const values = resolved.members.map((m) => {
+    const parsed = JSON.parse(m);
+    if (typeof parsed === "string") numeric = false;
+    return String(parsed);
+  });
+  if (values.length === 0) return null;
+  return { values, numeric };
 }
-function buildObjectSchema(classDecl, classFile, ctx) {
-  const props = classDecl.getProperties();
-  if (props.length === 0) {
-    return "z.object({}).passthrough()";
-  }
-  const fields = [];
-  for (const prop of props) {
-    const name = prop.getName();
-    const expr = buildPropertySchema(prop, classFile, ctx);
-    fields.push(`${toObjectKey3(name)}: ${expr}`);
-  }
-  return `z.object({ ${fields.join(", ")} })`;
+
+// src/discovery/filter-field-types.ts
+var STRING_TYPE_KEYWORDS = ["varchar", "text", "string", "char", "uuid", "enum"];
+var NUMBER_TYPE_KEYWORDS = ["int", "float", "double", "decimal", "number", "numeric", "real"];
+var BOOLEAN_TYPE_KEYWORDS = ["bool", "boolean", "bit"];
+var DATE_TYPE_KEYWORDS = ["date", "time", "timestamp", "datetime"];
+var JSON_TYPE_KEYWORDS = ["json", "jsonb"];
+function classifyTypeKeyword(raw) {
+  const t = raw.toLowerCase();
+  if (STRING_TYPE_KEYWORDS.some((s) => t.includes(s))) return "string";
+  if (NUMBER_TYPE_KEYWORDS.some((s) => t.includes(s))) return "number";
+  if (BOOLEAN_TYPE_KEYWORDS.some((s) => t.includes(s))) return "boolean";
+  if (DATE_TYPE_KEYWORDS.some((s) => t.includes(s))) return "date";
+  if (JSON_TYPE_KEYWORDS.some((s) => t.includes(s))) return "json";
+  return null;
 }
-function toObjectKey3(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+function markNullable(r, nullable) {
+  return nullable ? { ...r, nullable: true } : r;
 }
-function buildPropertySchema(prop, classFile, ctx) {
-  const decorators = /* @__PURE__ */ new Map();
-  for (const d of prop.getDecorators()) decorators.set(d.getName(), d);
-  const has = (n) => decorators.has(n);
-  const dec = (n) => decorators.get(n);
-  const typeNode = prop.getTypeNode();
-  const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
-  const comments = [];
-  const typeRefName = resolveTypeFactoryName2(dec("Type"));
-  if (has("ValidateNested") || typeRefName) {
-    const childName = typeRefName ?? singularClassName2(typeText);
-    if (childName) {
-      const childExpr = buildNestedReference2(childName, classFile, ctx);
-      const wrapArray = has("IsArray") || isArrayType;
-      let expr2 = wrapArray ? `z.array(${childExpr})` : childExpr;
-      expr2 = applyPresence2(expr2, decorators);
-      return expr2;
-    }
-  }
-  let base = baseFromType2(typeText, isArrayType, ctx, classFile);
-  const refinements = [];
-  if (has("IsString")) base = "z.string()";
-  if (has("IsBoolean")) base = "z.boolean()";
-  if (has("IsDate")) base = "z.coerce.date()";
-  if (has("IsNumber")) base = "z.number()";
-  if (has("IsInt")) base = "z.number().int()";
-  if (has("IsObject") && !has("ValidateNested")) base = "z.object({}).passthrough()";
-  if (has("Allow")) base = "z.unknown()";
-  if (has("IsEmail")) {
-    base = ensureStringBase(base);
-    refinements.push(`.email(${messageArg(dec("IsEmail"))})`);
-  }
-  if (has("IsUrl")) {
-    base = ensureStringBase(base);
-    refinements.push(`.url(${messageArg(dec("IsUrl"))})`);
+function classifyTypeNode(typeNode, sourceFile, project, opts) {
+  if (import_ts_morph5.Node.isUnionTypeNode(typeNode)) {
+    let nullable = false;
+    const stringLits = [];
+    const numberLits = [];
+    const others = [];
+    for (const member of typeNode.getTypeNodes()) {
+      const kind = member.getKind();
+      if (kind === import_ts_morph5.SyntaxKind.NullKeyword || kind === import_ts_morph5.SyntaxKind.UndefinedKeyword) {
+        nullable = true;
+        continue;
+      }
+      if (import_ts_morph5.Node.isLiteralTypeNode(member)) {
+        const lit = member.getLiteral();
+        if (import_ts_morph5.Node.isStringLiteral(lit)) {
+          stringLits.push(lit.getLiteralValue());
+          continue;
+        }
+        if (import_ts_morph5.Node.isNumericLiteral(lit)) {
+          numberLits.push(lit.getText());
+          continue;
+        }
+        if (lit.getKind() === import_ts_morph5.SyntaxKind.NullKeyword) {
+          nullable = true;
+          continue;
+        }
+      }
+      others.push(member);
+    }
+    if (others.length === 0 && stringLits.length > 0 && numberLits.length === 0) {
+      return markNullable({ kind: "string", enumValues: stringLits }, nullable);
+    }
+    if (others.length === 0 && numberLits.length > 0 && stringLits.length === 0) {
+      return markNullable({ kind: "number", enumValues: numberLits, numericEnum: true }, nullable);
+    }
+    if (others.length === 1) {
+      const inner = classifyTypeNode(others[0], sourceFile, project, opts);
+      return markNullable(inner, nullable || inner.nullable === true);
+    }
+    return markNullable({ kind: "unknown" }, nullable);
   }
-  if (has("IsUUID")) {
-    base = ensureStringBase(base);
-    refinements.push(`.uuid(${messageArg(dec("IsUUID"))})`);
+  switch (typeNode.getKind()) {
+    case import_ts_morph5.SyntaxKind.StringKeyword:
+      return { kind: "string" };
+    case import_ts_morph5.SyntaxKind.NumberKeyword:
+      return { kind: "number" };
+    case import_ts_morph5.SyntaxKind.BooleanKeyword:
+      return { kind: "boolean" };
+    case import_ts_morph5.SyntaxKind.AnyKeyword:
+    case import_ts_morph5.SyntaxKind.UnknownKeyword:
+      return { kind: "unknown" };
+    default:
+      break;
   }
-  if (has("Matches")) {
-    const re = firstArgText2(dec("Matches"));
-    if (re) {
-      base = ensureStringBase(base);
-      refinements.push(`.regex(${re})`);
+  if (import_ts_morph5.Node.isTypeReference(typeNode)) {
+    const refName = typeNode.getTypeName().getText();
+    if (refName === "Date") return { kind: "date" };
+    if (refName === "Record" || refName === "Object") return { kind: "json" };
+    const typeRef = opts?.resolveRef?.(refName) ?? null;
+    const en = resolveEnumValues(refName, sourceFile, project);
+    if (en) {
+      const base = en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
+      return typeRef ? { ...base, typeRef } : base;
     }
+    if (typeRef) return { kind: "unknown", typeRef };
+    return { kind: "unknown" };
   }
-  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_morph6.Node.isNumericLiteral(arg)) return arg.getText();
-  return null;
-}
-function numericArgs2(decorator) {
-  const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph6.Node.isNumericLiteral(n) ? n.getText() : null;
-  return [num(args[0]), num(args[1])];
-}
-function messageArg(decorator) {
-  const args = decorator?.getArguments() ?? [];
-  for (const arg of args) {
-    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
-      for (const prop of arg.getProperties()) {
-        if (import_ts_morph6.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
-          const init = prop.getInitializer();
-          if (init && import_ts_morph6.Node.isStringLiteral(init)) {
-            return `{ message: ${init.getText()} }`;
-          }
-        }
-      }
-    }
-  }
-  return "";
-}
-function resolveTypeFactoryName2(decorator) {
-  const arg = firstArg2(decorator);
-  if (!arg) return null;
-  if (import_ts_morph6.Node.isArrowFunction(arg)) {
-    const body = arg.getBody();
-    if (import_ts_morph6.Node.isIdentifier(body)) return body.getText();
-  }
-  return null;
-}
-function singularClassName2(typeText) {
-  const inner = typeText.endsWith("[]") ? typeText.slice(0, -2).trim() : typeText;
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(inner) ? inner : null;
-}
-function enumSchemaFromDecorator2(decorator, classFile, ctx) {
-  const arg = firstArg2(decorator);
-  if (!arg) return null;
-  if (import_ts_morph6.Node.isIdentifier(arg)) {
-    const name = arg.getText();
-    const resolved = findType(name, classFile, ctx.project);
-    if (resolved && resolved.kind === "enum") {
-      return `z.enum([${resolved.members.join(", ")}])`;
-    }
-    const msg = `@IsEnum(${name}): enum could not be resolved to literal members and is not importable into the generated form schema; falling back to z.unknown().`;
-    if (!ctx.warnedDecorators.has(`IsEnum:${name}`)) {
-      ctx.warnedDecorators.add(`IsEnum:${name}`);
-      ctx.warnings.push(msg);
-      console.warn(`[nestjs-codegen/forms] ${msg}`);
-    }
-    return `z.unknown() /* @IsEnum(${name}): enum not resolvable to literals */`;
-  }
-  if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
-    const values = [];
-    for (const p of arg.getProperties()) {
-      if (!import_ts_morph6.Node.isPropertyAssignment(p)) continue;
-      const init = p.getInitializer();
-      if (init && import_ts_morph6.Node.isStringLiteral(init)) values.push(init.getText());
-    }
-    if (values.length > 0) return `z.enum([${values.join(", ")}])`;
-  }
-  return null;
-}
-function inSchemaFromDecorator2(decorator) {
-  const arg = firstArg2(decorator);
-  if (arg && import_ts_morph6.Node.isArrayLiteralExpression(arg)) {
-    const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph6.Node.isStringLiteral(e));
-    if (allStrings && elements.length > 0) {
-      return `z.enum([${elements.map((e) => e.getText()).join(", ")}])`;
-    }
-    if (elements.length > 0) {
-      return `z.union([${elements.map((e) => `z.literal(${e.getText()})`).join(", ")}])`;
-    }
-  }
-  return null;
-}
-
-// src/discovery/filter-for.ts
-var import_ts_morph8 = require("ts-morph");
-
-// src/discovery/filter-field-types.ts
-var import_ts_morph7 = require("ts-morph");
-
-// src/discovery/enum-resolution.ts
-function resolveEnumValues(name, sourceFile, project) {
-  const resolved = findType(name, sourceFile, project);
-  if (!resolved || resolved.kind !== "enum") return null;
-  let numeric = true;
-  const values = resolved.members.map((m) => {
-    const parsed = JSON.parse(m);
-    if (typeof parsed === "string") numeric = false;
-    return String(parsed);
-  });
-  if (values.length === 0) return null;
-  return { values, numeric };
-}
-
-// src/discovery/filter-field-types.ts
-var STRING_TYPE_KEYWORDS = ["varchar", "text", "string", "char", "uuid", "enum"];
-var NUMBER_TYPE_KEYWORDS = ["int", "float", "double", "decimal", "number", "numeric", "real"];
-var BOOLEAN_TYPE_KEYWORDS = ["bool", "boolean", "bit"];
-var DATE_TYPE_KEYWORDS = ["date", "time", "timestamp", "datetime"];
-var JSON_TYPE_KEYWORDS = ["json", "jsonb"];
-function classifyTypeKeyword(raw) {
-  const t = raw.toLowerCase();
-  if (STRING_TYPE_KEYWORDS.some((s) => t.includes(s))) return "string";
-  if (NUMBER_TYPE_KEYWORDS.some((s) => t.includes(s))) return "number";
-  if (BOOLEAN_TYPE_KEYWORDS.some((s) => t.includes(s))) return "boolean";
-  if (DATE_TYPE_KEYWORDS.some((s) => t.includes(s))) return "date";
-  if (JSON_TYPE_KEYWORDS.some((s) => t.includes(s))) return "json";
-  return null;
-}
-function markNullable(r, nullable) {
-  return nullable ? { ...r, nullable: true } : r;
-}
-function classifyTypeNode(typeNode, sourceFile, project, opts) {
-  if (import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
-    let nullable = false;
-    const stringLits = [];
-    const numberLits = [];
-    const others = [];
-    for (const member of typeNode.getTypeNodes()) {
-      const kind = member.getKind();
-      if (kind === import_ts_morph7.SyntaxKind.NullKeyword || kind === import_ts_morph7.SyntaxKind.UndefinedKeyword) {
-        nullable = true;
-        continue;
-      }
-      if (import_ts_morph7.Node.isLiteralTypeNode(member)) {
-        const lit = member.getLiteral();
-        if (import_ts_morph7.Node.isStringLiteral(lit)) {
-          stringLits.push(lit.getLiteralValue());
-          continue;
-        }
-        if (import_ts_morph7.Node.isNumericLiteral(lit)) {
-          numberLits.push(lit.getText());
-          continue;
-        }
-        if (lit.getKind() === import_ts_morph7.SyntaxKind.NullKeyword) {
-          nullable = true;
-          continue;
-        }
-      }
-      others.push(member);
-    }
-    if (others.length === 0 && stringLits.length > 0 && numberLits.length === 0) {
-      return markNullable({ kind: "string", enumValues: stringLits }, nullable);
-    }
-    if (others.length === 0 && numberLits.length > 0 && stringLits.length === 0) {
-      return markNullable({ kind: "number", enumValues: numberLits, numericEnum: true }, nullable);
-    }
-    if (others.length === 1) {
-      const inner = classifyTypeNode(others[0], sourceFile, project, opts);
-      return markNullable(inner, nullable || inner.nullable === true);
-    }
-    return markNullable({ kind: "unknown" }, nullable);
-  }
-  switch (typeNode.getKind()) {
-    case import_ts_morph7.SyntaxKind.StringKeyword:
-      return { kind: "string" };
-    case import_ts_morph7.SyntaxKind.NumberKeyword:
-      return { kind: "number" };
-    case import_ts_morph7.SyntaxKind.BooleanKeyword:
-      return { kind: "boolean" };
-    case import_ts_morph7.SyntaxKind.AnyKeyword:
-    case import_ts_morph7.SyntaxKind.UnknownKeyword:
-      return { kind: "unknown" };
-    default:
-      break;
-  }
-  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
-    const refName = typeNode.getTypeName().getText();
-    if (refName === "Date") return { kind: "date" };
-    if (refName === "Record" || refName === "Object") return { kind: "json" };
-    const typeRef = opts?.resolveRef?.(refName) ?? null;
-    const en = resolveEnumValues(refName, sourceFile, project);
-    if (en) {
-      const base = en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
-      return typeRef ? { ...base, typeRef } : base;
-    }
-    if (typeRef) return { kind: "unknown", typeRef };
-    return { kind: "unknown" };
-  }
-  if (import_ts_morph7.Node.isTypeLiteral(typeNode)) return { kind: "json" };
+  if (import_ts_morph5.Node.isTypeLiteral(typeNode)) return { kind: "json" };
   return { kind: "unknown" };
 }
 function enumFromDecoratorArgs(args, sourceFile, project) {
   for (const arg of args) {
-    if (import_ts_morph7.Node.isArrowFunction(arg)) {
+    if (import_ts_morph5.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph7.Node.isIdentifier(body)) {
+      if (import_ts_morph5.Node.isIdentifier(body)) {
         const en = resolveEnumValues(body.getText(), sourceFile, project);
         if (en) return en;
       }
     }
-    if (import_ts_morph7.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
       const itemsProp = arg.getProperty("items");
-      if (itemsProp && import_ts_morph7.Node.isPropertyAssignment(itemsProp)) {
+      if (itemsProp && import_ts_morph5.Node.isPropertyAssignment(itemsProp)) {
         const init = itemsProp.getInitializer();
-        if (init && import_ts_morph7.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph5.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph7.Node.isIdentifier(body)) {
+          if (import_ts_morph5.Node.isIdentifier(body)) {
             const en = resolveEnumValues(body.getText(), sourceFile, project);
             if (en) return en;
           }
@@ -2811,7 +2375,7 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
       return { kind: "string" };
     }
     for (const arg of args) {
-      if (import_ts_morph7.Node.isStringLiteral(arg)) {
+      if (import_ts_morph5.Node.isStringLiteral(arg)) {
         const raw = arg.getLiteralValue();
         const kind = classifyTypeKeyword(raw);
         if (kind) {
@@ -2819,11 +2383,11 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           return { kind };
         }
       }
-      if (import_ts_morph7.Node.isObjectLiteralExpression(arg)) {
+      if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
         const enumProp = arg.getProperty("enum");
-        if (enumProp && import_ts_morph7.Node.isPropertyAssignment(enumProp)) {
+        if (enumProp && import_ts_morph5.Node.isPropertyAssignment(enumProp)) {
           const init = enumProp.getInitializer();
-          if (init && import_ts_morph7.Node.isIdentifier(init)) {
+          if (init && import_ts_morph5.Node.isIdentifier(init)) {
             const en = resolveEnumValues(init.getText(), sourceFile, project);
             if (en) {
               return en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
@@ -2832,9 +2396,9 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           }
         }
         const typeProp = arg.getProperty("type");
-        if (typeProp && import_ts_morph7.Node.isPropertyAssignment(typeProp)) {
+        if (typeProp && import_ts_morph5.Node.isPropertyAssignment(typeProp)) {
           const init = typeProp.getInitializer();
-          if (init && import_ts_morph7.Node.isStringLiteral(init)) {
+          if (init && import_ts_morph5.Node.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
           }
@@ -2870,7 +2434,7 @@ function toFilterFieldType(name, r) {
 
 // src/discovery/filter-for.ts
 function classifyFilterForHint(typeInit) {
-  if (import_ts_morph8.Node.isStringLiteral(typeInit)) {
+  if (import_ts_morph6.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -2884,10 +2448,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (import_ts_morph8.Node.isArrayLiteralExpression(typeInit)) {
+  if (import_ts_morph6.Node.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!import_ts_morph8.Node.isStringLiteral(el)) return null;
+      if (!import_ts_morph6.Node.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -2922,11 +2486,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && import_ts_morph8.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && import_ts_morph6.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && import_ts_morph8.Node.isPropertyAssignment(typeProp)) {
+      if (typeProp && import_ts_morph6.Node.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -2949,14 +2513,14 @@ function extractApplyFilterInfo(method, sourceFile, project) {
     const args = filterDecorator.getArguments();
     if (args.length === 0) continue;
     const filterClassArg = args[0];
-    if (!filterClassArg || !import_ts_morph8.Node.isIdentifier(filterClassArg)) continue;
+    if (!filterClassArg || !import_ts_morph6.Node.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && import_ts_morph8.Node.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && import_ts_morph8.Node.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && import_ts_morph6.Node.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && import_ts_morph8.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && import_ts_morph6.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
@@ -3019,22 +2583,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (import_ts_morph8.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && import_ts_morph8.Node.isPropertyAssignment(entityProp)) {
+      if (entityProp && import_ts_morph6.Node.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && import_ts_morph8.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph6.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph8.Node.isIdentifier(body)) {
+          if (import_ts_morph6.Node.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    if (import_ts_morph8.Node.isArrowFunction(arg)) {
+    if (import_ts_morph6.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph8.Node.isIdentifier(body)) {
+      if (import_ts_morph6.Node.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -3058,11 +2622,11 @@ function extractFilterableEntityFields(filterClass, project) {
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!import_ts_morph8.Node.isObjectLiteralExpression(optionsArg)) return [];
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return [];
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph8.Node.isPropertyAssignment(entityProp)) return [];
+  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return [];
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph8.Node.isIdentifier(entityInit)) return [];
+  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return [];
   const entityName = entityInit.getText();
   const filterSourceFile = filterClass.getSourceFile();
   const resolvedEntity = findType(entityName, filterSourceFile, project);
@@ -3078,17 +2642,17 @@ function extractFilterableEntityFields(filterClass, project) {
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
     const relArgs = relationsDecorator.getArguments();
-    if (relArgs.length > 0 && import_ts_morph8.Node.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && import_ts_morph6.Node.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!import_ts_morph8.Node.isPropertyAssignment(relProp)) continue;
+        if (!import_ts_morph6.Node.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !import_ts_morph8.Node.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !import_ts_morph6.Node.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !import_ts_morph8.Node.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !import_ts_morph6.Node.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !import_ts_morph8.Node.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !import_ts_morph6.Node.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (import_ts_morph8.Node.isStringLiteral(el)) {
+          if (import_ts_morph6.Node.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -3098,267 +2662,65 @@ function extractFilterableEntityFields(filterClass, project) {
   return fields;
 }
 
-// src/discovery/contracts-fast.ts
-async function discoverContractsFast(opts) {
-  const { cwd, glob, tsconfig } = opts;
-  const tsconfigPath = tsconfig ? (0, import_node_path11.resolve)(tsconfig) : (0, import_node_path11.join)(cwd, "tsconfig.json");
-  let project;
-  try {
-    project = new import_ts_morph9.Project({
-      tsConfigFilePath: tsconfigPath,
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true
-    });
-  } catch {
-    project = new import_ts_morph9.Project({
-      skipAddingFilesFromTsConfig: true,
-      skipLoadingLibFiles: true,
-      skipFileDependencyResolution: true,
-      compilerOptions: {
-        allowJs: true,
-        resolveJsonModule: false,
-        strict: false
-      }
-    });
+// src/discovery/dto-type-resolver.ts
+var WRAPPER_TYPES = {
+  // MikroORM Ref/Reference/LoadedReference/IdentifiedReference are server-side
+  // wrappers around related entities; the wire shape is just the referenced
+  // entity. Unwrap to the type argument.
+  Ref: "unwrap",
+  Reference: "unwrap",
+  LoadedReference: "unwrap",
+  IdentifiedReference: "unwrap",
+  // MikroORM Opt<T> is a marker, Loaded<T, ...> is a wrapper; both reduce to T.
+  Opt: "unwrap",
+  Loaded: "unwrap",
+  // Promise<T> — unwrap
+  Promise: "unwrap",
+  // MikroORM Collection<T> serializes as an array of T on the wire.
+  Collection: "arrayOf",
+  // Array<T> generic form
+  Array: "arrayOf"
+};
+var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
+  "Record",
+  "Omit",
+  "Pick",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Map",
+  "Set"
+]);
+function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
+  if (depth <= 0) return "unknown";
+  if (import_ts_morph7.Node.isArrayTypeNode(typeNode)) {
+    const elementType = typeNode.getElementTypeNode();
+    return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
   }
-  const files = await (0, import_fast_glob2.default)(glob, { cwd, absolute: true, onlyFiles: true });
-  for (const f of files) {
-    project.addSourceFileAtPath(f);
+  if (import_ts_morph7.Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
   }
-  const routes = [];
-  const prevCtx = setDiscoveryContext({
-    projectRoot: cwd,
-    tsconfigPaths: loadTsconfigPaths(tsconfigPath)
-  });
-  try {
-    for (const sourceFile of project.getSourceFiles()) {
-      routes.push(...extractFromSourceFile(sourceFile, project));
-    }
-  } finally {
-    restoreDiscoveryContext(prevCtx);
+  if (import_ts_morph7.Node.isIntersectionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
   }
-  return routes;
-}
-function zodAstToTs(node) {
-  if (!import_ts_morph9.Node.isCallExpression(node)) return "unknown";
-  const expr = node.getExpression();
-  if (import_ts_morph9.Node.isPropertyAccessExpression(expr)) {
-    const methodName = expr.getName();
-    const receiver = expr.getExpression();
-    if (methodName === "optional") {
-      return `${zodAstToTs(receiver)} | undefined`;
-    }
-    if (methodName === "nullable") {
-      return `${zodAstToTs(receiver)} | null`;
-    }
-    const args = node.getArguments();
-    switch (methodName) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "unknown":
-        return "unknown";
-      case "any":
-        return "unknown";
-      case "literal": {
-        const lit = args[0];
-        if (!lit) return "unknown";
-        if (import_ts_morph9.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph9.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph9.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph9.SyntaxKind.FalseKeyword) return "false";
-        return "unknown";
-      }
-      case "enum": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        const members = arrArg.getElements().map(
-          (el) => import_ts_morph9.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
-        );
-        return members.join(" | ");
-      }
-      case "array": {
-        const inner = args[0];
-        if (!inner) return "unknown";
-        return `Array<${zodAstToTs(inner)}>`;
-      }
-      case "object": {
-        const objArg = args[0];
-        if (!objArg || !import_ts_morph9.Node.isObjectLiteralExpression(objArg)) return "unknown";
-        const lines = [];
-        for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
-          const key = prop.getName();
-          const valNode = prop.getInitializer();
-          if (!valNode) continue;
-          const tsType = zodAstToTs(valNode);
-          const isOpt = isOptionalChain(valNode);
-          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
-        }
-        return `{ ${lines.join("; ")} }`;
-      }
-      case "union": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return arrArg.getElements().map(zodAstToTs).join(" | ");
-      }
-      case "record": {
-        const valArg = args.length === 1 ? args[0] : args[1];
-        if (!valArg) return "unknown";
-        return `Record<string, ${zodAstToTs(valArg)}>`;
-      }
-      case "tuple": {
-        const arrArg = args[0];
-        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
-        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
-      }
-      default:
-        return "unknown";
-    }
-  }
-  return "unknown";
-}
-function isOptionalChain(node) {
-  if (!import_ts_morph9.Node.isCallExpression(node)) return false;
-  const expr = node.getExpression();
-  return import_ts_morph9.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
-}
-function decoratorStringArg(decoratorExpr) {
-  if (!decoratorExpr) return void 0;
-  if (import_ts_morph9.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph9.Node.isArrayLiteralExpression(decoratorExpr)) {
-    const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph9.Node.isStringLiteral(first)) return first.getLiteralValue();
-  }
-  return void 0;
-}
-function parseDefineContractCall(callExpr) {
-  if (!import_ts_morph9.Node.isCallExpression(callExpr)) return null;
-  const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph9.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph9.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
-  if (calleeName !== "defineContract") return null;
-  const args = callExpr.getArguments();
-  const optsArg = args[0];
-  if (!optsArg || !import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) return null;
-  let query = null;
-  let body = null;
-  let response = "unknown";
-  let bodyZodText = null;
-  let queryZodText = null;
-  for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
-    const propName = prop.getName();
-    const val = prop.getInitializer();
-    if (!val) continue;
-    if (propName === "query") {
-      query = zodAstToTs(val);
-      queryZodText = val.getText();
-    } else if (propName === "body") {
-      body = zodAstToTs(val);
-      bodyZodText = val.getText();
-    } else if (propName === "response") {
-      response = zodAstToTs(val);
-    }
-  }
-  return { query, body, response, bodyZodText, queryZodText };
-}
-function deriveClassSegment(className) {
-  const noSuffix = className.replace(/Controller$/, "");
-  if (!noSuffix) {
-    throw new Error(
-      `Controller class name "${className}" derives empty route segment after stripping "Controller". Add an @As(...) override at the class level.`
-    );
-  }
-  return noSuffix.charAt(0).toLowerCase() + noSuffix.slice(1);
-}
-function resolveRouteName(className, methodName, classAs, methodAs) {
-  const classPortion = classAs ?? deriveClassSegment(className);
-  const methodPortion = methodAs ?? methodName;
-  return `${classPortion}.${methodPortion}`;
-}
-function joinPaths(prefix, suffix) {
-  if (!prefix && !suffix) return "/";
-  if (!prefix) return suffix.startsWith("/") ? suffix : `/${suffix}`;
-  if (!suffix) return prefix.startsWith("/") ? prefix : `/${prefix}`;
-  const p = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-  const s = suffix.startsWith("/") ? suffix : `/${suffix}`;
-  const combined = p + s;
-  return combined === "" ? "/" : combined;
-}
-function extractParams(path) {
-  const matches = path.matchAll(/:(\w+)/g);
-  return Array.from(matches).map((m) => ({ name: m[1], source: "path" }));
-}
-function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
-  if (depth <= 0) return "unknown";
-  if (import_ts_morph9.Node.isArrayTypeNode(typeNode)) {
-    const elementType = typeNode.getElementTypeNode();
-    return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
-  }
-  if (import_ts_morph9.Node.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
-  }
-  if (import_ts_morph9.Node.isIntersectionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
-  }
-  if (import_ts_morph9.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph7.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth)})`;
   }
-  if (import_ts_morph9.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph7.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph9.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph7.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     if (name === "string" || name === "number" || name === "boolean") return name;
     if (name === "Date") return "string";
     if (name === "unknown" || name === "any" || name === "void") return "unknown";
     if (name === "StreamableFile" || name === "Observable" || name === "ReadableStream")
       return "unknown";
-    if (name === "Ref" || name === "Reference" || name === "LoadedReference" || name === "IdentifiedReference") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      return "unknown";
+    const wrapperMode = WRAPPER_TYPES[name];
+    if (wrapperMode) {
+      return unwrapFirstTypeArg(typeNode, sourceFile, project, depth, wrapperMode);
     }
-    if (name === "Collection") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return `Array<${resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth)}>`;
-      }
-      return "Array<unknown>";
-    }
-    if (name === "Opt" || name === "Loaded") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      return "unknown";
-    }
-    if (name === "Array") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return `Array<${resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth)}>`;
-      }
-      return "Array<unknown>";
-    }
-    if (["Record", "Omit", "Pick", "Partial", "Required", "Readonly", "Map", "Set"].includes(name)) {
+    if (PASSTHROUGH_UTILITY.has(name)) {
       return typeNode.getText();
     }
-    if (name === "Promise") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstTypeArg = typeArgs[0];
-      if (typeArgs.length > 0 && firstTypeArg !== void 0) {
-        return resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
-      }
-      return "unknown";
-    }
     const resolved = findType(name, sourceFile, project);
     if (resolved) {
       return expandTypeDecl(resolved, project, depth - 1);
@@ -3367,13 +2729,22 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth) {
     return "unknown";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph9.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph9.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph9.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph9.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph9.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph7.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph7.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph7.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph7.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph7.SyntaxKind.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
+function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode) {
+  const typeArgs = typeNode.getTypeArguments();
+  const firstTypeArg = typeArgs[0];
+  if (typeArgs.length > 0 && firstTypeArg !== void 0) {
+    const inner = resolveTypeNodeToString(firstTypeArg, sourceFile, project, depth);
+    return mode === "arrayOf" ? `Array<${inner}>` : inner;
+  }
+  return mode === "arrayOf" ? "Array<unknown>" : "unknown";
+}
 function expandTypeDecl(result, project, depth) {
   if (depth < 0) return "unknown";
   switch (result.kind) {
@@ -3439,7 +2810,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph9.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph7.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -3452,13 +2823,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph7.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph9.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph7.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -3478,7 +2849,7 @@ function extractResponseType(method, sourceFile, project) {
   return "unknown";
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph9.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph7.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -3525,11 +2896,11 @@ function extractDtoContract(method, sourceFile, project) {
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph7.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph9.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph7.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph9.Node.isIdentifier(val)) {
+            if (val && import_ts_morph7.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -3546,27 +2917,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,
@@ -3579,9 +2941,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
@@ -3601,6 +2960,201 @@ function resolveParamClass(method, decoratorName, sourceFile, project) {
   }
   return null;
 }
+
+// src/discovery/zod-ast-to-ts.ts
+var import_ts_morph8 = require("ts-morph");
+function zodAstToTs(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (import_ts_morph8.Node.isPropertyAccessExpression(expr)) {
+    const methodName = expr.getName();
+    const receiver = expr.getExpression();
+    if (methodName === "optional") {
+      return `${zodAstToTs(receiver)} | undefined`;
+    }
+    if (methodName === "nullable") {
+      return `${zodAstToTs(receiver)} | null`;
+    }
+    const args = node.getArguments();
+    switch (methodName) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "unknown":
+        return "unknown";
+      case "any":
+        return "unknown";
+      case "literal": {
+        const lit = args[0];
+        if (!lit) return "unknown";
+        if (import_ts_morph8.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph8.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => import_ts_morph8.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+        );
+        return members.join(" | ");
+      }
+      case "array": {
+        const inner = args[0];
+        if (!inner) return "unknown";
+        return `Array<${zodAstToTs(inner)}>`;
+      }
+      case "object": {
+        const objArg = args[0];
+        if (!objArg || !import_ts_morph8.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+          const key = prop.getName();
+          const valNode = prop.getInitializer();
+          if (!valNode) continue;
+          const tsType = zodAstToTs(valNode);
+          const isOpt = isOptionalChain(valNode);
+          lines.push(`${key}${isOpt ? "?" : ""}: ${tsType}`);
+        }
+        return `{ ${lines.join("; ")} }`;
+      }
+      case "union": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return arrArg.getElements().map(zodAstToTs).join(" | ");
+      }
+      case "record": {
+        const valArg = args.length === 1 ? args[0] : args[1];
+        if (!valArg) return "unknown";
+        return `Record<string, ${zodAstToTs(valArg)}>`;
+      }
+      case "tuple": {
+        const arrArg = args[0];
+        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!import_ts_morph8.Node.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return import_ts_morph8.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function parseDefineContractCall(callExpr) {
+  if (!import_ts_morph8.Node.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = import_ts_morph8.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph8.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
+  let query = null;
+  let body = null;
+  let response = "unknown";
+  let bodyZodText = null;
+  let queryZodText = null;
+  for (const prop of optsArg.getProperties()) {
+    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+    const propName = prop.getName();
+    const val = prop.getInitializer();
+    if (!val) continue;
+    if (propName === "query") {
+      query = zodAstToTs(val);
+      queryZodText = val.getText();
+    } else if (propName === "body") {
+      body = zodAstToTs(val);
+      bodyZodText = val.getText();
+    } else if (propName === "response") {
+      response = zodAstToTs(val);
+    }
+  }
+  return { query, body, response, bodyZodText, queryZodText };
+}
+
+// src/discovery/contracts-fast.ts
+async function discoverContractsFast(opts) {
+  const { cwd, glob, tsconfig } = opts;
+  const tsconfigPath = tsconfig ? (0, import_node_path12.resolve)(tsconfig) : (0, import_node_path12.join)(cwd, "tsconfig.json");
+  let project;
+  try {
+    project = new import_ts_morph9.Project({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true
+    });
+  } catch {
+    project = new import_ts_morph9.Project({
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true,
+      compilerOptions: {
+        allowJs: true,
+        resolveJsonModule: false,
+        strict: false
+      }
+    });
+  }
+  const files = await (0, import_fast_glob2.default)(glob, { cwd, absolute: true, onlyFiles: true });
+  for (const f of files) {
+    project.addSourceFileAtPath(f);
+  }
+  const 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_morph9.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph9.Node.isArrayLiteralExpression(decoratorExpr)) {
+    const first = decoratorExpr.getElements()[0];
+    if (first && import_ts_morph9.Node.isStringLiteral(first)) return first.getLiteralValue();
+  }
+  return void 0;
+}
+function 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",
@@ -3611,176 +3165,186 @@ var HTTP_METHOD_DECORATORS = {
   Head: "HEAD",
   All: "ALL"
 };
+function resolveVerb(method) {
+  for (const [decoratorName, verb] of Object.entries(HTTP_METHOD_DECORATORS)) {
+    const httpDecorator = method.getDecorator(decoratorName);
+    if (httpDecorator) {
+      const httpArgs = httpDecorator.getArguments();
+      const pathArg = httpArgs[0];
+      return { httpMethod: verb, handlerPath: decoratorStringArg(pathArg) ?? "" };
+    }
+  }
+  return null;
+}
+function readAsDecorator(node, label) {
+  const asDecorator = node.getDecorator("As");
+  if (!asDecorator) return void 0;
+  const asName = decoratorStringArg(asDecorator.getArguments()[0]);
+  if (!asName) {
+    throw new Error(`@As decorator on ${label} must have a non-empty string argument.`);
+  }
+  return asName;
+}
+function buildRoute(args) {
+  const {
+    className,
+    methodName,
+    resolvedMethod,
+    combinedPath,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource
+  } = args;
+  const routeName = resolveRouteName(className, methodName, classAs, methodAs);
+  const qualifiedRef = `${className}.${methodName}`;
+  const existing = seenNames.get(routeName);
+  if (existing !== void 0) {
+    throw new Error(
+      `Route name collision: "${routeName}" is used by both "${existing}" and "${qualifiedRef}". Use @As(...) to give one of them a unique name.`
+    );
+  }
+  seenNames.set(routeName, qualifiedRef);
+  return {
+    method: resolvedMethod,
+    path: combinedPath,
+    name: routeName,
+    params: extractParams(combinedPath),
+    controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
+    contract: { contractSource }
+  };
+}
+function extractContractRoute(args) {
+  const { cls, method, applyContractDecorator, verb, prefix, className, sourceFile, seenNames } = args;
+  const firstDecoratorArg = applyContractDecorator.getArguments()[0];
+  if (!firstDecoratorArg) return null;
+  let contractDef = null;
+  let bodyZodRef = null;
+  let queryZodRef = null;
+  if (import_ts_morph9.Node.isCallExpression(firstDecoratorArg)) {
+    contractDef = parseDefineContractCall(firstDecoratorArg);
+  } else if (import_ts_morph9.Node.isIdentifier(firstDecoratorArg)) {
+    const identName = firstDecoratorArg.getText();
+    const varDecl = sourceFile.getVariableDeclaration(identName);
+    if (!varDecl) {
+      console.warn(
+        `[nestjs-codegen/fast] Cannot resolve '${identName}' in ${sourceFile.getFilePath()} (cross-file imports are out-of-scope for v1) \u2014 skipping`
+      );
+      return null;
+    }
+    const initializer = varDecl.getInitializer();
+    if (!initializer) return null;
+    contractDef = parseDefineContractCall(initializer);
+    if (contractDef && varDecl.isExported()) {
+      const filePath = sourceFile.getFilePath();
+      if (contractDef.body !== null) {
+        bodyZodRef = { name: `${identName}.body`, filePath };
+      }
+      if (contractDef.query !== null) {
+        queryZodRef = { name: `${identName}.query`, filePath };
+      }
+    }
+  } else {
+    console.warn(
+      `[nestjs-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`
+    );
+    return null;
+  }
+  if (!contractDef) return null;
+  if (!verb) return null;
+  const resolvedPath = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: resolvedPath,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource: {
+      query: contractDef.query,
+      body: contractDef.body,
+      response: contractDef.response,
+      // Path A: capture both the importable ref and the raw text. The emitter
+      // prefers inlining the text (client-safe — re-exporting from a controller
+      // would drag server-only deps into the client bundle).
+      bodyZodRef,
+      bodyZodText: contractDef.bodyZodText,
+      queryZodRef,
+      queryZodText: contractDef.queryZodText
+    }
+  });
+}
+function extractDtoRoute(args) {
+  const { cls, method, verb, prefix, className, sourceFile, project, seenNames } = args;
+  if (!verb) return null;
+  const combined = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  const dtoContract = extractDtoContract(method, sourceFile, project);
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: combined,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    contractSource: {
+      query: dtoContract?.query ?? null,
+      body: dtoContract?.body ?? null,
+      response: dtoContract?.response ?? "unknown",
+      queryRef: dtoContract?.queryRef ?? null,
+      bodyRef: dtoContract?.bodyRef ?? null,
+      responseRef: dtoContract?.responseRef ?? null,
+      filterFields: dtoContract?.filterFields ?? null,
+      filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
+      filterSource: dtoContract?.filterSource ?? null,
+      formWarnings: dtoContract?.formWarnings ?? [],
+      bodySchema: dtoContract?.bodySchema ?? null,
+      querySchema: dtoContract?.querySchema ?? null
+    }
+  });
+}
 function extractFromSourceFile(sourceFile, project) {
   const routes = [];
   const seenNames = /* @__PURE__ */ new Map();
-  const classes = sourceFile.getClasses();
-  for (const cls of classes) {
+  for (const cls of sourceFile.getClasses()) {
     const controllerDecorator = cls.getDecorator("Controller");
     if (!controllerDecorator) continue;
-    const controllerArgs = controllerDecorator.getArguments();
-    const firstArg3 = controllerArgs[0];
-    const prefix = decoratorStringArg(firstArg3) ?? "";
+    const firstArg2 = controllerDecorator.getArguments()[0];
+    const prefix = decoratorStringArg(firstArg2) ?? "";
     const className = cls.getName() ?? "Unknown";
     for (const method of cls.getMethods()) {
-      let httpMethod;
-      let handlerPath = "";
-      for (const [decoratorName, verb] of Object.entries(HTTP_METHOD_DECORATORS)) {
-        const httpDecorator = method.getDecorator(decoratorName);
-        if (httpDecorator) {
-          httpMethod = verb;
-          const httpArgs = httpDecorator.getArguments();
-          const pathArg = httpArgs[0];
-          handlerPath = decoratorStringArg(pathArg) ?? "";
-          break;
-        }
-      }
+      const verb = resolveVerb(method);
       const applyContractDecorator = method.getDecorator("ApplyContract");
-      if (applyContractDecorator) {
-        const decoratorArgs = applyContractDecorator.getArguments();
-        const firstDecoratorArg = decoratorArgs[0];
-        if (!firstDecoratorArg) continue;
-        let contractDef = null;
-        let bodyZodRef = null;
-        let queryZodRef = null;
-        if (import_ts_morph9.Node.isCallExpression(firstDecoratorArg)) {
-          contractDef = parseDefineContractCall(firstDecoratorArg);
-        } else if (import_ts_morph9.Node.isIdentifier(firstDecoratorArg)) {
-          const identName = firstDecoratorArg.getText();
-          const varDecl = sourceFile.getVariableDeclaration(identName);
-          if (!varDecl) {
-            console.warn(
-              `[nestjs-codegen/fast] Cannot resolve '${identName}' in ${sourceFile.getFilePath()} (cross-file imports are out-of-scope for v1) \u2014 skipping`
-            );
-            continue;
-          }
-          const initializer = varDecl.getInitializer();
-          if (!initializer) continue;
-          contractDef = parseDefineContractCall(initializer);
-          if (contractDef && varDecl.isExported()) {
-            const filePath = sourceFile.getFilePath();
-            if (contractDef.body !== null) {
-              bodyZodRef = { name: `${identName}.body`, filePath };
-            }
-            if (contractDef.query !== null) {
-              queryZodRef = { name: `${identName}.query`, filePath };
-            }
-          }
-        } else {
-          console.warn(
-            `[nestjs-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`
-          );
-          continue;
-        }
-        if (!contractDef) continue;
-        if (!httpMethod) continue;
-        const resolvedMethod = httpMethod;
-        const resolvedPath = joinPaths(prefix, handlerPath);
-        const combined = resolvedPath;
-        const params = extractParams(combined);
-        const methodName = method.getName();
-        const classAsDecorator = cls.getDecorator("As");
-        let classAs;
-        if (classAsDecorator) {
-          const classAsArgs = classAsDecorator.getArguments();
-          const classAsName = decoratorStringArg(classAsArgs[0]);
-          if (!classAsName) {
-            throw new Error(
-              `@As decorator on class ${className} must have a non-empty string argument.`
-            );
-          }
-          classAs = classAsName;
-        }
-        const methodAsDecorator = method.getDecorator("As");
-        let methodAs;
-        if (methodAsDecorator) {
-          const methodAsArgs = methodAsDecorator.getArguments();
-          const methodAsName = decoratorStringArg(methodAsArgs[0]);
-          if (!methodAsName) {
-            throw new Error(
-              `@As decorator on ${className}.${methodName} must have a non-empty string argument.`
-            );
-          }
-          methodAs = methodAsName;
-        }
-        const routeName = resolveRouteName(className, methodName, classAs, methodAs);
-        const qualifiedRef = `${className}.${methodName}`;
-        const existing = seenNames.get(routeName);
-        if (existing !== void 0) {
-          throw new Error(
-            `Route name collision: "${routeName}" is used by both "${existing}" and "${qualifiedRef}". Use @As(...) to give one of them a unique name.`
-          );
-        }
-        seenNames.set(routeName, qualifiedRef);
-        routes.push({
-          method: resolvedMethod,
-          path: combined,
-          name: routeName,
-          params,
-          controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
-          contract: {
-            contractSource: {
-              query: contractDef.query,
-              body: contractDef.body,
-              response: contractDef.response,
-              // Path A: capture both the importable ref and the raw text. The
-              // emitter prefers inlining the text (client-safe — re-exporting from
-              // a controller would drag server-only deps into the client bundle).
-              bodyZodRef,
-              bodyZodText: contractDef.bodyZodText,
-              queryZodRef,
-              queryZodText: contractDef.queryZodText
-            }
-          }
-        });
-      } else {
-        if (!httpMethod) continue;
-        const combined = joinPaths(prefix, handlerPath);
-        const params = extractParams(combined);
-        const methodName = method.getName();
-        const classAsDecorator = cls.getDecorator("As");
-        let classAs;
-        if (classAsDecorator) {
-          const classAsArgs = classAsDecorator.getArguments();
-          const classAsName = decoratorStringArg(classAsArgs[0]);
-          if (classAsName) classAs = classAsName;
-        }
-        const methodAsDecorator = method.getDecorator("As");
-        let methodAs;
-        if (methodAsDecorator) {
-          const methodAsArgs = methodAsDecorator.getArguments();
-          const methodAsName = decoratorStringArg(methodAsArgs[0]);
-          if (methodAsName) methodAs = methodAsName;
-        }
-        const routeName = resolveRouteName(className, methodName, classAs, methodAs);
-        const dtoContract = extractDtoContract(method, sourceFile, project);
-        routes.push({
-          method: httpMethod,
-          path: combined,
-          name: routeName,
-          params,
-          controllerRef: { className, methodName, filePath: sourceFile.getFilePath() },
-          contract: {
-            contractSource: {
-              query: dtoContract?.query ?? null,
-              body: dtoContract?.body ?? null,
-              response: dtoContract?.response ?? "unknown",
-              queryRef: dtoContract?.queryRef ?? null,
-              bodyRef: dtoContract?.bodyRef ?? null,
-              responseRef: dtoContract?.responseRef ?? null,
-              filterFields: dtoContract?.filterFields ?? null,
-              filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
-              filterSource: dtoContract?.filterSource ?? null,
-              bodyZodText: dtoContract?.bodyZodText ?? null,
-              queryZodText: dtoContract?.queryZodText ?? null,
-              formNestedSchemas: dtoContract?.formNestedSchemas ?? null,
-              formWarnings: dtoContract?.formWarnings ?? [],
-              bodySchema: dtoContract?.bodySchema ?? null,
-              querySchema: dtoContract?.querySchema ?? null
-            }
-          }
-        });
-      }
+      const route = applyContractDecorator ? extractContractRoute({
+        cls,
+        method,
+        applyContractDecorator,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        seenNames
+      }) : extractDtoRoute({
+        cls,
+        method,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        project,
+        seenNames
+      });
+      if (route) routes.push(route);
     }
   }
   return routes;
@@ -3789,7 +3353,7 @@ function extractFromSourceFile(sourceFile, project) {
 // src/watch/lock-file.ts
 var import_promises10 = require("fs/promises");
 var import_promises11 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var LOCK_FILE = ".watcher.lock";
 function isProcessAlive(pid) {
   try {
@@ -3801,7 +3365,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");
@@ -3841,7 +3405,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 {
@@ -3869,7 +3433,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 }
@@ -3895,7 +3459,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 }
@@ -3925,7 +3489,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 }
@@ -3951,8 +3515,57 @@ async function watch(config, onChange) {
   };
 }
 
+// src/ir/render-ts-type.ts
+function tsKey(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function renderTsType(node, ctx) {
+  switch (node.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "unknown":
+      return "unknown";
+    case "instanceof":
+      return node.ctor;
+    case "enum":
+      return node.literals.join(" | ");
+    case "literal":
+      return node.raw;
+    case "union":
+      return node.options.map((o) => renderTsType(o, ctx)).join(" | ");
+    case "array":
+      return `Array<${renderTsType(node.element, ctx)}>`;
+    case "optional":
+      return `${renderTsType(node.inner, ctx)} | undefined`;
+    case "annotated":
+      return renderTsType(node.inner, ctx);
+    case "object": {
+      if (node.fields.length === 0) return node.passthrough ? "Record<string, unknown>" : "{}";
+      const inner = node.fields.map((f) => {
+        if (f.value.kind === "optional") {
+          return `${tsKey(f.key)}?: ${renderTsType(f.value.inner, ctx)}`;
+        }
+        return `${tsKey(f.key)}: ${renderTsType(f.value, ctx)}`;
+      }).join("; ");
+      return `{ ${inner} }`;
+    }
+    case "ref":
+    case "lazyRef": {
+      if (ctx.recursive.has(node.name)) return ctx.typeNameFor(node.name);
+      const target = ctx.named.get(node.name);
+      return target ? renderTsType(target, ctx) : "unknown";
+    }
+  }
+}
+
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.4.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CodegenError,
@@ -3967,9 +3580,9 @@ var VERSION = "0.2.1";
   extractSchemaFromDto,
   generate,
   loadConfig,
+  renderTsType,
   resolveAdapter,
   resolveConfig,
-  watch,
-  zodAdapter
+  watch
 });
 //# sourceMappingURL=index.cjs.map