@dudousxd/nestjs-codegen 0.2.0

package/dist/nest/index.js

@@ -0,0 +1,3919 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/nest/module.ts
+import { Inject, Injectable, Logger, Module } from "@nestjs/common";
+
+// src/config/load-config.ts
+import { access } from "fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "path";
+import { pathToFileURL } from "url";
+
+// src/exceptions.ts
+var ConfigError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigError";
+  }
+};
+var CodegenError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodegenError";
+  }
+};
+
+// 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(
+    `Validation adapter "${option}" is not bundled in core. Install ${pkg} and pass the adapter instance instead of the string:
+
+  import { ${named} } from '${pkg}';
+  defineConfig({ validation: ${named} });`
+  );
+}
+
+// src/config/load-config.ts
+function resolveAbsolute(cwd, p) {
+  if (isAbsolute(p)) return p;
+  return resolve(cwd, p);
+}
+function assertInsideCwd(cwd, resolvedPath, fieldName) {
+  const rel = relative(cwd, resolvedPath);
+  if (rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) {
+    throw new ConfigError(
+      `\`${fieldName}\` must be inside the project cwd.
+  Resolved to: ${resolvedPath}
+  Project cwd: ${cwd}
+If this is intentional, move the file inside your project directory.`
+    );
+  }
+}
+function resolveConfig(userConfig, cwd) {
+  return applyDefaults(userConfig, cwd ?? process.cwd());
+}
+function applyDefaults(userConfig, cwd) {
+  const outDir = userConfig.codegen?.outDir ? resolveAbsolute(cwd, userConfig.codegen.outDir) : join(cwd, ".nestjs-inertia");
+  const resolvedCwd = userConfig.codegen?.cwd ? resolveAbsolute(cwd, userConfig.codegen.cwd) : cwd;
+  let app = null;
+  if (userConfig.app) {
+    const resolvedEntry = resolveAbsolute(cwd, userConfig.app.moduleEntry);
+    assertInsideCwd(cwd, resolvedEntry, "app.moduleEntry");
+    let resolvedTsconfig = null;
+    if (userConfig.app.tsconfig) {
+      resolvedTsconfig = resolveAbsolute(cwd, userConfig.app.tsconfig);
+      assertInsideCwd(cwd, resolvedTsconfig, "app.tsconfig");
+    }
+    app = {
+      moduleEntry: resolvedEntry,
+      tsconfig: resolvedTsconfig
+    };
+  }
+  return {
+    extensions: userConfig.extensions ?? [],
+    validation: resolveAdapter(userConfig.validation ?? "zod"),
+    pages: userConfig.pages ? {
+      glob: userConfig.pages.glob,
+      propsExport: userConfig.pages.propsExport ?? "ComponentProps",
+      componentNameStrategy: userConfig.pages.componentNameStrategy ?? "relative-no-ext"
+    } : null,
+    contracts: {
+      glob: userConfig.contracts?.glob ?? "src/**/*.controller.ts",
+      debounceMs: userConfig.contracts?.debounceMs ?? 500
+    },
+    scopes: userConfig.scopes ?? {},
+    codegen: {
+      outDir,
+      cwd: resolvedCwd
+    },
+    app,
+    fetcher: userConfig.fetcher ?? null,
+    forms: {
+      enabled: userConfig.forms?.enabled ?? true,
+      watch: userConfig.forms?.watch ?? "src/**/*.dto.ts",
+      zodImport: userConfig.forms?.zodImport ?? "zod"
+    }
+  };
+}
+
+// src/watch/watcher.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join12 } from "path";
+import chokidar from "chokidar";
+
+// src/discovery/contracts-fast.ts
+import { join as join2, resolve as resolve3 } from "path";
+import fg from "fast-glob";
+import {
+  Node as Node6,
+  Project,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+
+// src/discovery/dto-to-ir.ts
+import {
+  Node as Node2
+} from "ts-morph";
+
+// src/discovery/type-ref-resolution.ts
+import { readFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import {
+  Node
+} from "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;
+}
+function _tsconfigPaths() {
+  return _ctx.tsconfigPaths;
+}
+var _debug = process.env.NESTJS_INERTIA_DEBUG === "1";
+function dbg(...args) {
+  if (_debug) console.log("[codegen:debug]", ...args);
+}
+function loadTsconfigPaths(tsconfigPath) {
+  try {
+    const raw = readFileSync(tsconfigPath, "utf8");
+    const stripped = raw.replace(/\/\/.*$/gm, "");
+    const parsed = JSON.parse(stripped);
+    return parsed.compilerOptions?.paths ?? null;
+  } catch {
+    return null;
+  }
+}
+function findTypeInFile(name, file) {
+  const cls = file.getClass(name);
+  if (cls) return { kind: "class", decl: cls, file };
+  const iface = file.getInterface(name);
+  if (iface) return { kind: "interface", decl: iface, file };
+  const alias = file.getTypeAlias(name);
+  if (alias) {
+    const typeNode = alias.getTypeNode();
+    return {
+      kind: "typeAlias",
+      typeNode,
+      file,
+      text: typeNode ? typeNode.getText() : "unknown"
+    };
+  }
+  const enumDecl = file.getEnum(name);
+  if (enumDecl) {
+    const members = enumDecl.getMembers().map((m) => {
+      const val = m.getValue();
+      if (typeof val === "string" || typeof val === "number") return JSON.stringify(val);
+      return JSON.stringify(m.getName());
+    });
+    return { kind: "enum", members };
+  }
+  return null;
+}
+function resolveModuleSpecifier(moduleSpecifier, sourceFile, _project) {
+  if (moduleSpecifier.startsWith(".")) {
+    const dir = dirname(sourceFile.getFilePath());
+    const noExt = moduleSpecifier.replace(/\.(js|ts)$/, "");
+    return [
+      resolve2(dir, `${noExt}.ts`),
+      resolve2(dir, `${moduleSpecifier}.ts`),
+      resolve2(dir, moduleSpecifier, "index.ts")
+    ];
+  }
+  const baseUrl = _projectRoot();
+  const tsconfigPaths = _tsconfigPaths();
+  dbg(
+    "resolveModuleSpecifier",
+    moduleSpecifier,
+    "paths:",
+    JSON.stringify(tsconfigPaths),
+    "baseUrl:",
+    baseUrl
+  );
+  if (tsconfigPaths) {
+    for (const [pattern, mappings] of Object.entries(tsconfigPaths)) {
+      const prefix = pattern.replace("*", "");
+      if (moduleSpecifier.startsWith(prefix)) {
+        const rest = moduleSpecifier.slice(prefix.length);
+        const candidates = [];
+        for (const mapping of mappings) {
+          const resolved = resolve2(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, resolve2(resolved, "index.ts"));
+        }
+        dbg("  resolved candidates:", candidates);
+        return candidates;
+      }
+    }
+  }
+  return [];
+}
+function resolveImportedType(name, sourceFile, project) {
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const namedImport = importDecl.getNamedImports().find((n) => n.getName() === name);
+    if (!namedImport) continue;
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    const candidates = resolveModuleSpecifier(moduleSpecifier, sourceFile, project);
+    if (candidates.length === 0) continue;
+    for (const candidate of candidates) {
+      let importedFile = project.getSourceFile(candidate);
+      if (!importedFile) {
+        try {
+          importedFile = project.addSourceFileAtPath(candidate);
+        } catch {
+          continue;
+        }
+      }
+      const result = findTypeInFile(name, importedFile);
+      if (result) return result;
+      const viaReExport = resolveReExportedType(name, importedFile, project, /* @__PURE__ */ new Set());
+      if (viaReExport) return viaReExport;
+    }
+  }
+  return resolveReExportedType(name, sourceFile, project, /* @__PURE__ */ new Set());
+}
+function resolveReExportedType(name, file, project, seen) {
+  const filePath = file.getFilePath();
+  if (seen.has(filePath)) return null;
+  seen.add(filePath);
+  for (const exportDecl of file.getExportDeclarations()) {
+    const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+    const namedExports = exportDecl.getNamedExports();
+    if (moduleSpecifier) {
+      const hasStar = namedExports.length === 0;
+      const reExportsName2 = namedExports.some(
+        (n) => (n.getAliasNode()?.getText() ?? n.getName()) === name
+      );
+      if (!hasStar && !reExportsName2) continue;
+      const sourceName2 = hasStar ? name : namedExports.find((n) => (n.getAliasNode()?.getText() ?? n.getName()) === name)?.getName() ?? name;
+      const target = followModuleForType(sourceName2, moduleSpecifier, file, project, seen);
+      if (target) return target;
+      continue;
+    }
+    const reExportsName = namedExports.some(
+      (n) => (n.getAliasNode()?.getText() ?? n.getName()) === name
+    );
+    if (!reExportsName) continue;
+    const sourceName = namedExports.find((n) => (n.getAliasNode()?.getText() ?? n.getName()) === name)?.getName() ?? name;
+    const local = findTypeInFile(sourceName, file);
+    if (local) return local;
+    const imported = resolveImportedType(sourceName, file, project);
+    if (imported) return imported;
+  }
+  return null;
+}
+function followModuleForType(name, moduleSpecifier, fromFile, project, seen) {
+  const candidates = resolveModuleSpecifier(moduleSpecifier, fromFile, project);
+  for (const candidate of candidates) {
+    let importedFile = project.getSourceFile(candidate);
+    if (!importedFile) {
+      try {
+        importedFile = project.addSourceFileAtPath(candidate);
+      } catch {
+        continue;
+      }
+    }
+    const result = findTypeInFile(name, importedFile);
+    if (result) return result;
+    const viaReExport = resolveReExportedType(name, importedFile, project, seen);
+    if (viaReExport) return viaReExport;
+  }
+  return null;
+}
+function findType(name, sourceFile, project) {
+  const local = findTypeInFile(name, sourceFile);
+  if (local) return local;
+  return resolveImportedType(name, sourceFile, project);
+}
+var _NON_REF_NAMES = /* @__PURE__ */ new Set(["string", "number", "boolean", "void", "unknown", "any", "Date"]);
+function _localDeclForKinds(name, file, kinds) {
+  if (kinds.includes("class") && file.getClass(name)?.isExported()) return true;
+  if (kinds.includes("interface") && file.getInterface(name)?.isExported()) return true;
+  if (kinds.includes("typeAlias") && file.getTypeAlias(name)?.isExported()) return true;
+  if (kinds.includes("enum") && file.getEnum(name)?.isExported()) return true;
+  return false;
+}
+function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
+  let name;
+  if (typeof nodeOrName === "string") {
+    name = nodeOrName;
+  } else {
+    const typeNode = nodeOrName;
+    if (opts.unwrapContainers && Node.isArrayTypeNode(typeNode)) {
+      const inner = resolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project, opts);
+      return inner ? { ...inner, isArray: true } : null;
+    }
+    if (!Node.isTypeReference(typeNode)) return null;
+    const typeName = typeNode.getTypeName();
+    const refName = Node.isIdentifier(typeName) ? typeName.getText() : null;
+    if (!refName) return null;
+    if (opts.unwrapContainers && refName === "Promise") {
+      const first = typeNode.getTypeArguments()[0];
+      return first ? resolveTypeRef(first, sourceFile, project, opts) : null;
+    }
+    if (opts.unwrapContainers && refName === "Array") {
+      const first = typeNode.getTypeArguments()[0];
+      if (!first) return null;
+      const inner = resolveTypeRef(first, sourceFile, project, opts);
+      return inner ? { ...inner, isArray: true } : null;
+    }
+    if (_NON_REF_NAMES.has(refName)) return null;
+    name = refName;
+  }
+  if (_localDeclForKinds(name, sourceFile, opts.kinds)) {
+    return { name, filePath: sourceFile.getFilePath() };
+  }
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const namedImport = importDecl.getNamedImports().find((n) => n.getName() === name);
+    if (!namedImport) continue;
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (opts.allowBareSpecifier && !moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
+      const tsconfigPaths = _tsconfigPaths();
+      const isAlias = tsconfigPaths != null && Object.keys(tsconfigPaths).some((p) => {
+        const prefix = p.replace("*", "");
+        return moduleSpecifier.startsWith(prefix);
+      });
+      if (!isAlias) {
+        return { name, filePath: moduleSpecifier };
+      }
+    }
+    const candidates = resolveModuleSpecifier(moduleSpecifier, sourceFile, project);
+    for (const candidate of candidates) {
+      let importedFile = project.getSourceFile(candidate);
+      if (!importedFile) {
+        try {
+          importedFile = project.addSourceFileAtPath(candidate);
+        } catch {
+          continue;
+        }
+      }
+      if (_localDeclForKinds(name, importedFile, opts.kinds)) {
+        return { name, filePath: importedFile.getFilePath() };
+      }
+    }
+  }
+  return null;
+}
+
+// src/discovery/dto-to-ir.ts
+var KNOWN_DECORATORS = /* @__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 extractSchemaFromDto(classDecl, sourceFile, project) {
+  const ctx = {
+    sourceFile,
+    project,
+    named: /* @__PURE__ */ new Map(),
+    warnings: [],
+    warnedDecorators: /* @__PURE__ */ new Set(),
+    emittedClasses: /* @__PURE__ */ new Map(),
+    visiting: /* @__PURE__ */ new Set(),
+    recursiveSchemas: /* @__PURE__ */ new Set(),
+    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 };
+}
+function buildObject(classDecl, classFile, ctx) {
+  const props = classDecl.getProperties();
+  if (props.length === 0) {
+    return { kind: "object", fields: [], passthrough: true };
+  }
+  const fields = [];
+  for (const prop of props) {
+    fields.push({ key: prop.getName(), value: buildProperty(prop, classFile, ctx) });
+  }
+  return { kind: "object", fields, passthrough: false };
+}
+function buildProperty(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 typeRefName = resolveTypeFactoryName(dec("Type"));
+  if (has("ValidateNested") || typeRefName) {
+    const childName = typeRefName ?? singularClassName(typeText);
+    if (childName) {
+      const childNode = buildNestedReference(childName, classFile, ctx);
+      const wrapArray = has("IsArray") || isArrayType;
+      const node2 = wrapArray ? { kind: "array", element: childNode } : childNode;
+      return applyPresence(node2, decorators);
+    }
+  }
+  let base = baseFromType(typeText, isArrayType);
+  const stringChecks = [];
+  const numberChecks = [];
+  if (has("IsString")) base = { kind: "string", checks: stringChecks };
+  if (has("IsBoolean")) base = { kind: "boolean" };
+  if (has("IsDate")) base = { kind: "date" };
+  if (has("IsNumber")) base = { kind: "number", checks: numberChecks };
+  if (has("IsInt")) {
+    base = { kind: "number", checks: numberChecks };
+    numberChecks.push({ check: "int" });
+  }
+  if (has("IsObject") && !has("ValidateNested")) {
+    base = { kind: "object", fields: [], passthrough: true };
+  }
+  if (has("Allow")) base = { kind: "unknown" };
+  const ensureString = () => {
+    if (base.kind !== "string") base = { kind: "string", checks: stringChecks };
+  };
+  if (has("IsEmail")) {
+    ensureString();
+    const m = messageRaw(dec("IsEmail"));
+    stringChecks.push(m === void 0 ? { check: "email" } : { check: "email", messageRaw: m });
+  }
+  if (has("IsUrl")) {
+    ensureString();
+    const m = messageRaw(dec("IsUrl"));
+    stringChecks.push(m === void 0 ? { check: "url" } : { check: "url", messageRaw: m });
+  }
+  if (has("IsUUID")) {
+    ensureString();
+    const m = messageRaw(dec("IsUUID"));
+    stringChecks.push(m === void 0 ? { check: "uuid" } : { check: "uuid", messageRaw: m });
+  }
+  if (has("Matches")) {
+    const re = firstArgText(dec("Matches"));
+    if (re) {
+      ensureString();
+      stringChecks.push({ check: "regex", pattern: re });
+    }
+  }
+  if (has("MinLength")) {
+    const n = numericArg(dec("MinLength"));
+    if (n !== null) stringChecks.push({ check: "min", value: n });
+  }
+  if (has("MaxLength")) {
+    const n = numericArg(dec("MaxLength"));
+    if (n !== null) stringChecks.push({ check: "max", value: n });
+  }
+  if (has("Length")) {
+    const [min, max] = numericArgs(dec("Length"));
+    if (min !== null) stringChecks.push({ check: "min", value: min });
+    if (max !== null) stringChecks.push({ check: "max", value: max });
+  }
+  if (has("Min")) {
+    const n = numericArg(dec("Min"));
+    if (n !== null) numberChecks.push({ check: "min", value: n });
+  }
+  if (has("Max")) {
+    const n = numericArg(dec("Max"));
+    if (n !== null) numberChecks.push({ check: "max", value: n });
+  }
+  if (has("IsPositive")) numberChecks.push({ check: "positive" });
+  if (has("IsNegative")) numberChecks.push({ check: "negative" });
+  if (has("IsNotEmpty") && base.kind === "string") stringChecks.push({ check: "min", value: "1" });
+  if (has("IsEnum")) {
+    const enumNode = enumSchemaFromDecorator(dec("IsEnum"), classFile, ctx);
+    if (enumNode) base = enumNode;
+  }
+  if (has("IsIn")) {
+    const inNode = inSchemaFromDecorator(dec("IsIn"));
+    if (inNode) base = inNode;
+  }
+  const unmappable = [];
+  for (const name of decorators.keys()) {
+    if (!KNOWN_DECORATORS.has(name)) {
+      unmappable.push(name);
+      if (!ctx.warnedDecorators.has(name)) {
+        ctx.warnedDecorators.add(name);
+        const msg = `@${name} is not translatable to a client validation schema and was skipped (server-only validation).`;
+        ctx.warnings.push(msg);
+        console.warn(`[nestjs-codegen] ${msg}`);
+      }
+    }
+  }
+  if (base.kind === "string") base = { kind: "string", checks: stringChecks };
+  else if (base.kind === "number") base = { kind: "number", checks: numberChecks };
+  let node = base;
+  if (isArrayType && node.kind !== "array") {
+    node = { kind: "array", element: node };
+  }
+  node = applyPresence(node, decorators);
+  if (unmappable.length > 0) {
+    node = { kind: "annotated", inner: node, unmappable };
+  }
+  return node;
+}
+function applyPresence(node, decorators) {
+  if (decorators.has("IsDefined")) return node;
+  if (decorators.has("IsOptional")) return { kind: "optional", inner: node };
+  return node;
+}
+function baseFromType(typeText, isArrayType) {
+  const inner = isArrayType ? typeText.slice(0, -2).trim() : typeText;
+  switch (inner) {
+    case "string":
+      return { kind: "string", checks: [] };
+    case "number":
+      return { kind: "number", checks: [] };
+    case "boolean":
+      return { kind: "boolean" };
+    case "Date":
+      return { kind: "date" };
+    case "File":
+    case "Express.Multer.File":
+      return { kind: "instanceof", ctor: "File" };
+    default:
+      return { kind: "unknown" };
+  }
+}
+function buildNestedReference(className, fromFile, ctx) {
+  if (ctx.visiting.has(className) || ctx.depth >= 8) {
+    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.`;
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen] ${msg}`);
+    }
+    return { kind: "lazyRef", name: reserved };
+  }
+  const existing = ctx.emittedClasses.get(className);
+  if (existing) return { kind: "ref", name: existing };
+  const schemaName = aliasFor(className, ctx);
+  const resolved = findType(className, fromFile, ctx.project);
+  if (!resolved || resolved.kind !== "class") {
+    return { kind: "object", fields: [], passthrough: true };
+  }
+  ctx.emittedClasses.set(className, schemaName);
+  ctx.visiting.add(className);
+  ctx.depth += 1;
+  const childNode = buildObject(resolved.decl, resolved.file, ctx);
+  ctx.depth -= 1;
+  ctx.visiting.delete(className);
+  ctx.named.set(schemaName, childNode);
+  return { kind: "ref", name: schemaName };
+}
+function aliasFor(className, ctx) {
+  const baseName = `${className}Schema`;
+  let candidate = baseName;
+  let i = 1;
+  const used = new Set(ctx.named.keys());
+  for (const v of ctx.emittedClasses.values()) used.add(v);
+  while (used.has(candidate)) {
+    candidate = `${baseName}_${i}`;
+    i += 1;
+  }
+  return candidate;
+}
+function firstArg(decorator) {
+  return decorator?.getArguments()[0];
+}
+function firstArgText(decorator) {
+  const arg = firstArg(decorator);
+  return arg ? arg.getText() : null;
+}
+function numericArg(decorator) {
+  const arg = firstArg(decorator);
+  if (arg && Node2.isNumericLiteral(arg)) return arg.getText();
+  return null;
+}
+function numericArgs(decorator) {
+  const args = decorator?.getArguments() ?? [];
+  const num = (n) => n && Node2.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 (Node2.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.getProperties()) {
+        if (Node2.isPropertyAssignment(prop) && prop.getName() === "message") {
+          const init = prop.getInitializer();
+          if (init && Node2.isStringLiteral(init)) return init.getText();
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function resolveTypeFactoryName(decorator) {
+  const arg = firstArg(decorator);
+  if (!arg) return null;
+  if (Node2.isArrowFunction(arg)) {
+    const body = arg.getBody();
+    if (Node2.isIdentifier(body)) return body.getText();
+  }
+  return null;
+}
+function singularClassName(typeText) {
+  const inner = typeText.endsWith("[]") ? typeText.slice(0, -2).trim() : typeText;
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(inner) ? inner : null;
+}
+function enumSchemaFromDecorator(decorator, classFile, ctx) {
+  const arg = firstArg(decorator);
+  if (!arg) return null;
+  if (Node2.isIdentifier(arg)) {
+    const name = arg.getText();
+    const resolved = findType(name, classFile, ctx.project);
+    if (resolved && resolved.kind === "enum") {
+      return { kind: "enum", literals: resolved.members };
+    }
+    const msg = `@IsEnum(${name}): enum could not be resolved to literal members and is not importable into the generated schema; falling back to unknown.`;
+    if (!ctx.warnedDecorators.has(`IsEnum:${name}`)) {
+      ctx.warnedDecorators.add(`IsEnum:${name}`);
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen] ${msg}`);
+    }
+    return { kind: "unknown", note: `@IsEnum(${name}): enum not resolvable to literals` };
+  }
+  if (Node2.isObjectLiteralExpression(arg)) {
+    const values = [];
+    for (const p of arg.getProperties()) {
+      if (!Node2.isPropertyAssignment(p)) continue;
+      const init = p.getInitializer();
+      if (init && Node2.isStringLiteral(init)) values.push(init.getText());
+    }
+    if (values.length > 0) return { kind: "enum", literals: values };
+  }
+  return null;
+}
+function inSchemaFromDecorator(decorator) {
+  const arg = firstArg(decorator);
+  if (arg && Node2.isArrayLiteralExpression(arg)) {
+    const elements = arg.getElements();
+    const allStrings = elements.every((e) => Node2.isStringLiteral(e));
+    if (allStrings && elements.length > 0) {
+      return { kind: "enum", literals: elements.map((e) => e.getText()) };
+    }
+    if (elements.length > 0) {
+      return {
+        kind: "union",
+        options: elements.map((e) => ({ kind: "literal", raw: e.getText() }))
+      };
+    }
+  }
+  return null;
+}
+
+// src/discovery/dto-to-zod.ts
+import {
+  Node as Node3
+} from "ts-morph";
+var KNOWN_DECORATORS2 = /* @__PURE__ */ new Set([
+  "IsString",
+  "IsNumber",
+  "IsInt",
+  "IsBoolean",
+  "IsDate",
+  "IsEmail",
+  "IsUrl",
+  "IsUUID",
+  "MinLength",
+  "MaxLength",
+  "Length",
+  "Min",
+  "Max",
+  "IsPositive",
+  "IsNegative",
+  "Matches",
+  "IsEnum",
+  "IsIn",
+  "IsOptional",
+  "IsNotEmpty",
+  "IsArray",
+  "ValidateNested",
+  "Type",
+  "IsObject",
+  "Allow",
+  "IsDefined"
+]);
+function extractZodFromDto(classDecl, sourceFile, project) {
+  const ctx = {
+    sourceFile,
+    project,
+    namedNestedSchemas: /* @__PURE__ */ new Map(),
+    warnings: [],
+    warnedDecorators: /* @__PURE__ */ new Set(),
+    emittedClasses: /* @__PURE__ */ new Map(),
+    visiting: /* @__PURE__ */ new Set(),
+    recursiveSchemas: /* @__PURE__ */ new Set(),
+    depth: 0
+  };
+  const schemaText = buildObjectSchema(classDecl, sourceFile, ctx);
+  for (const schemaName of ctx.recursiveSchemas) {
+    ctx.namedNestedSchemas.set(schemaName, "z.unknown() /* recursive type \u2014 not expanded */");
+  }
+  return {
+    schemaText,
+    namedNestedSchemas: ctx.namedNestedSchemas,
+    warnings: ctx.warnings
+  };
+}
+function buildObjectSchema(classDecl, classFile, ctx) {
+  const props = classDecl.getProperties();
+  if (props.length === 0) {
+    return "z.object({}).passthrough()";
+  }
+  const fields = [];
+  for (const prop of props) {
+    const name = prop.getName();
+    const expr = buildPropertySchema(prop, classFile, ctx);
+    fields.push(`${toObjectKey2(name)}: ${expr}`);
+  }
+  return `z.object({ ${fields.join(", ")} })`;
+}
+function toObjectKey2(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function buildPropertySchema(prop, classFile, ctx) {
+  const decorators = /* @__PURE__ */ new Map();
+  for (const d of prop.getDecorators()) decorators.set(d.getName(), d);
+  const has = (n) => decorators.has(n);
+  const dec = (n) => decorators.get(n);
+  const typeNode = prop.getTypeNode();
+  const typeText = typeNode?.getText() ?? "unknown";
+  const isArrayType = !!typeNode && typeNode.getText().endsWith("[]");
+  const comments = [];
+  const typeRefName = resolveTypeFactoryName2(dec("Type"));
+  if (has("ValidateNested") || typeRefName) {
+    const childName = typeRefName ?? singularClassName2(typeText);
+    if (childName) {
+      const childExpr = buildNestedReference2(childName, classFile, ctx);
+      const wrapArray = has("IsArray") || isArrayType;
+      let expr2 = wrapArray ? `z.array(${childExpr})` : childExpr;
+      expr2 = applyPresence2(expr2, decorators);
+      return expr2;
+    }
+  }
+  let base = baseFromType2(typeText, isArrayType, ctx, classFile);
+  const refinements = [];
+  if (has("IsString")) base = "z.string()";
+  if (has("IsBoolean")) base = "z.boolean()";
+  if (has("IsDate")) base = "z.coerce.date()";
+  if (has("IsNumber")) base = "z.number()";
+  if (has("IsInt")) base = "z.number().int()";
+  if (has("IsObject") && !has("ValidateNested")) base = "z.object({}).passthrough()";
+  if (has("Allow")) base = "z.unknown()";
+  if (has("IsEmail")) {
+    base = ensureStringBase(base);
+    refinements.push(`.email(${messageArg(dec("IsEmail"))})`);
+  }
+  if (has("IsUrl")) {
+    base = ensureStringBase(base);
+    refinements.push(`.url(${messageArg(dec("IsUrl"))})`);
+  }
+  if (has("IsUUID")) {
+    base = ensureStringBase(base);
+    refinements.push(`.uuid(${messageArg(dec("IsUUID"))})`);
+  }
+  if (has("Matches")) {
+    const re = firstArgText2(dec("Matches"));
+    if (re) {
+      base = ensureStringBase(base);
+      refinements.push(`.regex(${re})`);
+    }
+  }
+  if (has("MinLength")) {
+    const n = numericArg2(dec("MinLength"));
+    if (n !== null) refinements.push(`.min(${n})`);
+  }
+  if (has("MaxLength")) {
+    const n = numericArg2(dec("MaxLength"));
+    if (n !== null) refinements.push(`.max(${n})`);
+  }
+  if (has("Length")) {
+    const [min, max] = numericArgs2(dec("Length"));
+    if (min !== null) refinements.push(`.min(${min})`);
+    if (max !== null) refinements.push(`.max(${max})`);
+  }
+  if (has("Min")) {
+    const n = numericArg2(dec("Min"));
+    if (n !== null) refinements.push(`.min(${n})`);
+  }
+  if (has("Max")) {
+    const n = numericArg2(dec("Max"));
+    if (n !== null) refinements.push(`.max(${n})`);
+  }
+  if (has("IsPositive")) refinements.push(".positive()");
+  if (has("IsNegative")) refinements.push(".negative()");
+  if (has("IsNotEmpty") && isStringBase(base)) refinements.push(".min(1)");
+  if (has("IsEnum")) {
+    const enumExpr = enumSchemaFromDecorator2(dec("IsEnum"), classFile, ctx);
+    if (enumExpr) base = enumExpr;
+  }
+  if (has("IsIn")) {
+    const inExpr = inSchemaFromDecorator2(dec("IsIn"));
+    if (inExpr) base = inExpr;
+  }
+  for (const name of decorators.keys()) {
+    if (!KNOWN_DECORATORS2.has(name)) {
+      comments.push(`/* @${name}: not translatable to zod (server-only) */`);
+      if (!ctx.warnedDecorators.has(name)) {
+        ctx.warnedDecorators.add(name);
+        const msg = `@${name} is not translatable to zod and was skipped (server-only validation).`;
+        ctx.warnings.push(msg);
+        console.warn(`[nestjs-codegen/forms] ${msg}`);
+      }
+    }
+  }
+  let expr = base + refinements.join("");
+  if (isArrayType && !expr.startsWith("z.array(")) {
+    expr = `z.array(${expr})`;
+  }
+  expr = applyPresence2(expr, decorators);
+  if (comments.length > 0) {
+    expr = `${expr} ${comments.join(" ")}`;
+  }
+  return expr;
+}
+function applyPresence2(expr, decorators) {
+  if (decorators.has("IsDefined")) return expr;
+  if (decorators.has("IsOptional")) return `${expr}.optional()`;
+  return expr;
+}
+function baseFromType2(typeText, isArrayType, ctx, classFile) {
+  const inner = isArrayType ? typeText.slice(0, -2).trim() : typeText;
+  switch (inner) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "Date":
+      return "z.coerce.date()";
+    case "File":
+    case "Express.Multer.File":
+      return "z.instanceof(File)";
+    default:
+      return "z.unknown()";
+  }
+}
+function ensureStringBase(base) {
+  return isStringBase(base) ? base : "z.string()";
+}
+function isStringBase(base) {
+  return base.startsWith("z.string(");
+}
+function buildNestedReference2(className, fromFile, ctx) {
+  if (ctx.visiting.has(className) || ctx.depth >= 8) {
+    const reserved = ctx.emittedClasses.get(className) ?? aliasFor2(className, ctx);
+    ctx.emittedClasses.set(className, reserved);
+    ctx.recursiveSchemas.add(reserved);
+    if (!ctx.warnedDecorators.has(`recursive:${reserved}`)) {
+      ctx.warnedDecorators.add(`recursive:${reserved}`);
+      const msg = `${className} is a recursive type and was not expanded; the generated form schema uses z.unknown() for it.`;
+      ctx.warnings.push(msg);
+      console.warn(`[nestjs-codegen/forms] ${msg}`);
+    }
+    return `z.lazy(() => ${reserved})`;
+  }
+  const existing = ctx.emittedClasses.get(className);
+  if (existing) return existing;
+  const schemaName = aliasFor2(className, ctx);
+  const resolved = findType(className, fromFile, ctx.project);
+  if (!resolved || resolved.kind !== "class") {
+    return "z.object({}).passthrough()";
+  }
+  ctx.emittedClasses.set(className, schemaName);
+  ctx.visiting.add(className);
+  ctx.depth += 1;
+  const childText = buildObjectSchema(resolved.decl, resolved.file, ctx);
+  ctx.depth -= 1;
+  ctx.visiting.delete(className);
+  ctx.namedNestedSchemas.set(schemaName, childText);
+  return schemaName;
+}
+function aliasFor2(className, ctx) {
+  const baseName = `${className}Schema`;
+  let candidate = baseName;
+  let i = 1;
+  const used = new Set(ctx.namedNestedSchemas.keys());
+  for (const v of ctx.emittedClasses.values()) used.add(v);
+  while (used.has(candidate)) {
+    candidate = `${baseName}_${i}`;
+    i += 1;
+  }
+  return candidate;
+}
+function firstArg2(decorator) {
+  return decorator?.getArguments()[0];
+}
+function firstArgText2(decorator) {
+  const arg = firstArg2(decorator);
+  return arg ? arg.getText() : null;
+}
+function numericArg2(decorator) {
+  const arg = firstArg2(decorator);
+  if (arg && Node3.isNumericLiteral(arg)) return arg.getText();
+  return null;
+}
+function numericArgs2(decorator) {
+  const args = decorator?.getArguments() ?? [];
+  const num = (n) => n && Node3.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 (Node3.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.getProperties()) {
+        if (Node3.isPropertyAssignment(prop) && prop.getName() === "message") {
+          const init = prop.getInitializer();
+          if (init && Node3.isStringLiteral(init)) {
+            return `{ message: ${init.getText()} }`;
+          }
+        }
+      }
+    }
+  }
+  return "";
+}
+function resolveTypeFactoryName2(decorator) {
+  const arg = firstArg2(decorator);
+  if (!arg) return null;
+  if (Node3.isArrowFunction(arg)) {
+    const body = arg.getBody();
+    if (Node3.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 (Node3.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 (Node3.isObjectLiteralExpression(arg)) {
+    const values = [];
+    for (const p of arg.getProperties()) {
+      if (!Node3.isPropertyAssignment(p)) continue;
+      const init = p.getInitializer();
+      if (init && Node3.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 && Node3.isArrayLiteralExpression(arg)) {
+    const elements = arg.getElements();
+    const allStrings = elements.every((e) => Node3.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
+import {
+  Node as Node5
+} from "ts-morph";
+
+// src/discovery/filter-field-types.ts
+import {
+  Node as Node4,
+  SyntaxKind
+} from "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 (Node4.isUnionTypeNode(typeNode)) {
+    let nullable = false;
+    const stringLits = [];
+    const numberLits = [];
+    const others = [];
+    for (const member of typeNode.getTypeNodes()) {
+      const kind = member.getKind();
+      if (kind === SyntaxKind.NullKeyword || kind === SyntaxKind.UndefinedKeyword) {
+        nullable = true;
+        continue;
+      }
+      if (Node4.isLiteralTypeNode(member)) {
+        const lit = member.getLiteral();
+        if (Node4.isStringLiteral(lit)) {
+          stringLits.push(lit.getLiteralValue());
+          continue;
+        }
+        if (Node4.isNumericLiteral(lit)) {
+          numberLits.push(lit.getText());
+          continue;
+        }
+        if (lit.getKind() === 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 SyntaxKind.StringKeyword:
+      return { kind: "string" };
+    case SyntaxKind.NumberKeyword:
+      return { kind: "number" };
+    case SyntaxKind.BooleanKeyword:
+      return { kind: "boolean" };
+    case SyntaxKind.AnyKeyword:
+    case SyntaxKind.UnknownKeyword:
+      return { kind: "unknown" };
+    default:
+      break;
+  }
+  if (Node4.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 (Node4.isTypeLiteral(typeNode)) return { kind: "json" };
+  return { kind: "unknown" };
+}
+function enumFromDecoratorArgs(args, sourceFile, project) {
+  for (const arg of args) {
+    if (Node4.isArrowFunction(arg)) {
+      const body = arg.getBody();
+      if (Node4.isIdentifier(body)) {
+        const en = resolveEnumValues(body.getText(), sourceFile, project);
+        if (en) return en;
+      }
+    }
+    if (Node4.isObjectLiteralExpression(arg)) {
+      const itemsProp = arg.getProperty("items");
+      if (itemsProp && Node4.isPropertyAssignment(itemsProp)) {
+        const init = itemsProp.getInitializer();
+        if (init && Node4.isArrowFunction(init)) {
+          const body = init.getBody();
+          if (Node4.isIdentifier(body)) {
+            const en = resolveEnumValues(body.getText(), sourceFile, project);
+            if (en) return en;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function classifyFromColumnDecorator(prop, sourceFile, project) {
+  for (const dec of prop.getDecorators()) {
+    const decName = dec.getName();
+    if (decName !== "Column" && decName !== "Property" && decName !== "Enum") continue;
+    const args = dec.getArguments();
+    if (decName === "Enum") {
+      const en = enumFromDecoratorArgs(args, sourceFile, project);
+      if (en) {
+        return en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
+      }
+      return { kind: "string" };
+    }
+    for (const arg of args) {
+      if (Node4.isStringLiteral(arg)) {
+        const raw = arg.getLiteralValue();
+        const kind = classifyTypeKeyword(raw);
+        if (kind) {
+          if (kind === "string" && raw.toLowerCase().includes("enum")) continue;
+          return { kind };
+        }
+      }
+      if (Node4.isObjectLiteralExpression(arg)) {
+        const enumProp = arg.getProperty("enum");
+        if (enumProp && Node4.isPropertyAssignment(enumProp)) {
+          const init = enumProp.getInitializer();
+          if (init && Node4.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 };
+            }
+            return { kind: "string" };
+          }
+        }
+        const typeProp = arg.getProperty("type");
+        if (typeProp && Node4.isPropertyAssignment(typeProp)) {
+          const init = typeProp.getInitializer();
+          if (init && Node4.isStringLiteral(init)) {
+            const kind = classifyTypeKeyword(init.getLiteralValue());
+            if (kind) return { kind };
+          }
+        }
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function classifyFieldType(prop, sourceFile, project) {
+  let nullable = prop.hasQuestionToken();
+  const typeNode = prop.getTypeNode();
+  if (typeNode) {
+    const r = classifyTypeNode(typeNode, sourceFile, project);
+    if (r.nullable) nullable = true;
+    if (r.kind !== "unknown") return markNullable(r, nullable);
+  }
+  const fromDecorator = classifyFromColumnDecorator(prop, sourceFile, project);
+  if (fromDecorator) {
+    return markNullable(fromDecorator, nullable || fromDecorator.nullable === true);
+  }
+  return markNullable({ kind: "unknown" }, nullable);
+}
+function toFilterFieldType(name, r) {
+  const ft = { name, kind: r.kind };
+  if (r.enumValues && r.enumValues.length > 0) ft.enumValues = r.enumValues;
+  if (r.nullable) ft.nullable = true;
+  if (r.numericEnum) ft.numericEnum = true;
+  if (r.typeRef) ft.typeRef = r.typeRef;
+  return ft;
+}
+
+// src/discovery/filter-for.ts
+function classifyFilterForHint(typeInit) {
+  if (Node5.isStringLiteral(typeInit)) {
+    switch (typeInit.getLiteralValue()) {
+      case "string":
+        return { kind: "string" };
+      case "number":
+        return { kind: "number" };
+      case "boolean":
+        return { kind: "boolean" };
+      case "Date":
+        return { kind: "date" };
+      default:
+        return null;
+    }
+  }
+  if (Node5.isArrayLiteralExpression(typeInit)) {
+    const values = [];
+    for (const el of typeInit.getElements()) {
+      if (!Node5.isStringLiteral(el)) return null;
+      values.push(el.getLiteralValue());
+    }
+    if (values.length === 0) return null;
+    return { kind: "string", enumValues: values };
+  }
+  return null;
+}
+function classifyFilterForParam(method, sourceFile, project) {
+  const param = method.getParameters()[0];
+  if (!param) return null;
+  const typeNode = param.getTypeNode();
+  if (!typeNode) return null;
+  const wellKnown = ["string", "number", "boolean", "Date", "any", "unknown"];
+  const result = classifyTypeNode(typeNode, sourceFile, project, {
+    resolveRef: (refName) => {
+      if (wellKnown.includes(refName)) return null;
+      if (!findType(refName, sourceFile, project)) return null;
+      return resolveTypeRef(refName, sourceFile, project, {
+        kinds: ["class", "interface", "typeAlias", "enum"],
+        allowBareSpecifier: true
+      });
+    }
+  });
+  if (result.typeRef) return result;
+  return result.kind === "unknown" ? null : result;
+}
+function extractFilterForHints(classDecl, project) {
+  const hints = /* @__PURE__ */ new Map();
+  const sourceFile = classDecl.getSourceFile();
+  for (const method of classDecl.getMethods()) {
+    const filterForDec = method.getDecorators().find((d) => d.getName() === "FilterFor");
+    if (!filterForDec) continue;
+    const args = filterForDec.getArguments();
+    const keyArg = args[0];
+    const inputKey = keyArg && Node5.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const optsArg = args[1];
+    if (optsArg && Node5.isObjectLiteralExpression(optsArg)) {
+      const typeProp = optsArg.getProperty("type");
+      if (typeProp && Node5.isPropertyAssignment(typeProp)) {
+        const typeInit = typeProp.getInitializer();
+        if (typeInit) {
+          const classified = classifyFilterForHint(typeInit);
+          if (classified) {
+            hints.set(inputKey, classified);
+            continue;
+          }
+        }
+      }
+    }
+    const fromParam = classifyFilterForParam(method, sourceFile, project);
+    if (fromParam) hints.set(inputKey, fromParam);
+  }
+  return hints;
+}
+function extractApplyFilterInfo(method, sourceFile, project) {
+  for (const param of method.getParameters()) {
+    const filterDecorator = param.getDecorators().find((d) => d.getName() === "ApplyFilter");
+    if (!filterDecorator) continue;
+    const args = filterDecorator.getArguments();
+    if (args.length === 0) continue;
+    const filterClassArg = args[0];
+    if (!filterClassArg || !Node5.isIdentifier(filterClassArg)) continue;
+    let source = "query";
+    const optionsArg = args[1];
+    if (optionsArg && Node5.isObjectLiteralExpression(optionsArg)) {
+      const sourceProp = optionsArg.getProperty("source");
+      if (sourceProp && Node5.isPropertyAssignment(sourceProp)) {
+        const init = sourceProp.getInitializer();
+        if (init && Node5.isStringLiteral(init) && init.getLiteralValue() === "body") {
+          source = "body";
+        }
+      }
+    }
+    const filterClassName = filterClassArg.getText();
+    const resolved = findType(filterClassName, sourceFile, project);
+    if (resolved && resolved.kind === "class") {
+      const classDecl = resolved.decl;
+      let fieldTypes = extractClassPropertyTypes(classDecl, project);
+      if (fieldTypes.length === 0) {
+        fieldTypes = extractFilterableEntityFields(classDecl, project);
+      }
+      const filterForHints = extractFilterForHints(classDecl, project);
+      if (filterForHints.size > 0) {
+        const byName = new Map(fieldTypes.map((f) => [f.name, f]));
+        for (const [key, classified] of filterForHints) {
+          byName.set(key, toFilterFieldType(key, classified));
+        }
+        fieldTypes = [...byName.values()];
+      }
+      if (fieldTypes.length === 0) return null;
+      const fieldNames = fieldTypes.map((f) => f.name);
+      return {
+        fieldNames,
+        fieldTypes,
+        source
+      };
+    }
+  }
+  return null;
+}
+var RELATION_DECORATORS = /* @__PURE__ */ new Set(["OneToMany", "ManyToOne", "ManyToMany", "OneToOne"]);
+function collectEntityFields(entityDecl, sourceFile, project, prefix, visited) {
+  const entityName = entityDecl.getName() ?? "";
+  if (visited.has(entityName)) return [];
+  visited.add(entityName);
+  const fields = [];
+  for (const prop of entityDecl.getProperties()) {
+    const name = prop.getName();
+    if (name.startsWith("$") || name.startsWith("_") || name.startsWith("[")) continue;
+    if (prop.isStatic()) continue;
+    const fullName = prefix ? `${prefix}.${name}` : name;
+    const isRelation = prop.getDecorators().some((d) => RELATION_DECORATORS.has(d.getName()));
+    if (isRelation) {
+      const relEntity = resolveRelationEntity(prop, sourceFile, project);
+      if (relEntity) {
+        fields.push(
+          ...collectEntityFields(relEntity, relEntity.getSourceFile(), project, fullName, visited)
+        );
+      }
+    } else {
+      fields.push(toFilterFieldType(fullName, classifyFieldType(prop, sourceFile, project)));
+    }
+  }
+  return fields;
+}
+function resolveRelationEntity(prop, sourceFile, project) {
+  for (const dec of prop.getDecorators()) {
+    if (!RELATION_DECORATORS.has(dec.getName())) continue;
+    const args = dec.getArguments();
+    if (args.length === 0) continue;
+    const arg = args[0];
+    if (Node5.isObjectLiteralExpression(arg)) {
+      const entityProp = arg.getProperty("entity");
+      if (entityProp && Node5.isPropertyAssignment(entityProp)) {
+        const init = entityProp.getInitializer();
+        if (init && Node5.isArrowFunction(init)) {
+          const body = init.getBody();
+          if (Node5.isIdentifier(body)) {
+            const resolved = findType(body.getText(), prop.getSourceFile(), project);
+            if (resolved?.kind === "class") return resolved.decl;
+          }
+        }
+      }
+    }
+    if (Node5.isArrowFunction(arg)) {
+      const body = arg.getBody();
+      if (Node5.isIdentifier(body)) {
+        const resolved = findType(body.getText(), prop.getSourceFile(), project);
+        if (resolved?.kind === "class") return resolved.decl;
+      }
+    }
+  }
+  return null;
+}
+function extractClassPropertyTypes(classDecl, project) {
+  const sourceFile = classDecl.getSourceFile();
+  const fields = [];
+  for (const prop of classDecl.getProperties()) {
+    const name = prop.getName();
+    if (name.startsWith("$") || name.startsWith("_")) continue;
+    fields.push(toFilterFieldType(name, classifyFieldType(prop, sourceFile, project)));
+  }
+  return fields;
+}
+function extractFilterableEntityFields(filterClass, project) {
+  const filterableDecorator = filterClass.getDecorators().find((d) => d.getName() === "Filterable");
+  if (!filterableDecorator) return [];
+  const args = filterableDecorator.getArguments();
+  if (args.length === 0) return [];
+  const optionsArg = args[0];
+  if (!Node5.isObjectLiteralExpression(optionsArg)) return [];
+  const entityProp = optionsArg.getProperty("entity");
+  if (!entityProp || !Node5.isPropertyAssignment(entityProp)) return [];
+  const entityInit = entityProp.getInitializer();
+  if (!entityInit || !Node5.isIdentifier(entityInit)) return [];
+  const entityName = entityInit.getText();
+  const filterSourceFile = filterClass.getSourceFile();
+  const resolvedEntity = findType(entityName, filterSourceFile, project);
+  if (!resolvedEntity || resolvedEntity.kind !== "class") return [];
+  const entityDecl = resolvedEntity.decl;
+  const fields = collectEntityFields(
+    entityDecl,
+    entityDecl.getSourceFile(),
+    project,
+    "",
+    /* @__PURE__ */ new Set()
+  );
+  const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
+  if (relationsDecorator) {
+    const relArgs = relationsDecorator.getArguments();
+    if (relArgs.length > 0 && Node5.isObjectLiteralExpression(relArgs[0])) {
+      for (const relProp of relArgs[0].getProperties()) {
+        if (!Node5.isPropertyAssignment(relProp)) continue;
+        const relInit = relProp.getInitializer();
+        if (!relInit || !Node5.isObjectLiteralExpression(relInit)) continue;
+        const keysProp = relInit.getProperty("keys");
+        if (!keysProp || !Node5.isPropertyAssignment(keysProp)) continue;
+        const keysInit = keysProp.getInitializer();
+        if (!keysInit || !Node5.isArrayLiteralExpression(keysInit)) continue;
+        for (const el of keysInit.getElements()) {
+          if (Node5.isStringLiteral(el)) {
+            fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
+          }
+        }
+      }
+    }
+  }
+  return fields;
+}
+
+// src/discovery/contracts-fast.ts
+async function discoverContractsFast(opts) {
+  const { cwd, glob, tsconfig } = opts;
+  const tsconfigPath = tsconfig ? resolve3(tsconfig) : join2(cwd, "tsconfig.json");
+  let project;
+  try {
+    project = new Project({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true
+    });
+  } catch {
+    project = new Project({
+      skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      skipFileDependencyResolution: true,
+      compilerOptions: {
+        allowJs: true,
+        resolveJsonModule: false,
+        strict: false
+      }
+    });
+  }
+  const files = await fg(glob, { cwd, absolute: true, onlyFiles: true });
+  for (const f of files) {
+    project.addSourceFileAtPath(f);
+  }
+  const routes = [];
+  const prevCtx = setDiscoveryContext({
+    projectRoot: cwd,
+    tsconfigPaths: loadTsconfigPaths(tsconfigPath)
+  });
+  try {
+    for (const sourceFile of project.getSourceFiles()) {
+      routes.push(...extractFromSourceFile(sourceFile, project));
+    }
+  } finally {
+    restoreDiscoveryContext(prevCtx);
+  }
+  return routes;
+}
+function zodAstToTs(node) {
+  if (!Node6.isCallExpression(node)) return "unknown";
+  const expr = node.getExpression();
+  if (Node6.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 (Node6.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (Node6.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === SyntaxKind2.TrueKeyword) return "true";
+        if (lit.getKind() === SyntaxKind2.FalseKeyword) return "false";
+        return "unknown";
+      }
+      case "enum": {
+        const arrArg = args[0];
+        if (!arrArg || !Node6.isArrayLiteralExpression(arrArg)) return "unknown";
+        const members = arrArg.getElements().map(
+          (el) => Node6.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 || !Node6.isObjectLiteralExpression(objArg)) return "unknown";
+        const lines = [];
+        for (const prop of objArg.getProperties()) {
+          if (!Node6.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 || !Node6.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 || !Node6.isArrayLiteralExpression(arrArg)) return "unknown";
+        return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
+      }
+      default:
+        return "unknown";
+    }
+  }
+  return "unknown";
+}
+function isOptionalChain(node) {
+  if (!Node6.isCallExpression(node)) return false;
+  const expr = node.getExpression();
+  return Node6.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+}
+function decoratorStringArg(decoratorExpr) {
+  if (!decoratorExpr) return void 0;
+  if (Node6.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (Node6.isArrayLiteralExpression(decoratorExpr)) {
+    const first = decoratorExpr.getElements()[0];
+    if (first && Node6.isStringLiteral(first)) return first.getLiteralValue();
+  }
+  return void 0;
+}
+function parseDefineContractCall(callExpr) {
+  if (!Node6.isCallExpression(callExpr)) return null;
+  const callee = callExpr.getExpression();
+  const calleeName = Node6.isIdentifier(callee) ? callee.getText() : Node6.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  if (calleeName !== "defineContract") return null;
+  const args = callExpr.getArguments();
+  const optsArg = args[0];
+  if (!optsArg || !Node6.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 (!Node6.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 (Node6.isArrayTypeNode(typeNode)) {
+    const elementType = typeNode.getElementTypeNode();
+    return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth)}>`;
+  }
+  if (Node6.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" | ");
+  }
+  if (Node6.isIntersectionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth)).join(" & ");
+  }
+  if (Node6.isParenthesizedTypeNode(typeNode)) {
+    return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth)})`;
+  }
+  if (Node6.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    const name = Node6.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";
+    }
+    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)) {
+      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);
+    }
+    dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
+    return "unknown";
+  }
+  const kind = typeNode.getKind();
+  if (kind === SyntaxKind2.StringKeyword) return "string";
+  if (kind === SyntaxKind2.NumberKeyword) return "number";
+  if (kind === SyntaxKind2.BooleanKeyword) return "boolean";
+  if (kind === SyntaxKind2.UnknownKeyword) return "unknown";
+  if (kind === SyntaxKind2.AnyKeyword) return "unknown";
+  return typeNode.getText();
+}
+function expandTypeDecl(result, project, depth) {
+  if (depth < 0) return "unknown";
+  switch (result.kind) {
+    case "class":
+      return resolvePropertied(result.decl, result.file, project, depth);
+    case "interface":
+      return resolvePropertied(result.decl, result.file, project, depth);
+    case "typeAlias":
+      if (result.typeNode) {
+        return resolveTypeNodeToString(result.typeNode, result.file, project, depth);
+      }
+      return result.text;
+    case "enum":
+      return result.members.join(" | ");
+  }
+}
+function resolvePropertied(decl, sourceFile, project, depth) {
+  if (depth < 0) return "unknown";
+  const lines = [];
+  for (const prop of decl.getProperties()) {
+    const propName = prop.getName();
+    const isOptional = prop.hasQuestionToken();
+    const propTypeNode = prop.getTypeNode();
+    let propType = "unknown";
+    if (propTypeNode) {
+      propType = resolveTypeNodeToString(propTypeNode, sourceFile, project, depth);
+    }
+    lines.push(`${propName}${isOptional ? "?" : ""}: ${propType}`);
+  }
+  return `{ ${lines.join("; ")} }`;
+}
+function extractBodyType(method, sourceFile, project) {
+  for (const param of method.getParameters()) {
+    const bodyDecorator = param.getDecorators().find((d) => d.getName() === "Body");
+    if (!bodyDecorator) continue;
+    const bodyArgs = bodyDecorator.getArguments();
+    if (bodyArgs.length > 0) continue;
+    const typeNode = param.getTypeNode();
+    if (typeNode) {
+      return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
+    }
+  }
+  return null;
+}
+function extractQueryType(method, sourceFile, project) {
+  for (const param of method.getParameters()) {
+    const queryDecorator = param.getDecorators().find((d) => d.getName() === "Query");
+    if (!queryDecorator) continue;
+    const queryArgs = queryDecorator.getArguments();
+    if (queryArgs.length > 0) continue;
+    const typeNode = param.getTypeNode();
+    if (typeNode) {
+      return resolveTypeNodeToString(typeNode, sourceFile, project, 3);
+    }
+  }
+  return null;
+}
+function extractParamsType(method, sourceFile, project) {
+  const entries = [];
+  for (const param of method.getParameters()) {
+    const paramDecorator = param.getDecorators().find((d) => d.getName() === "Param");
+    if (!paramDecorator) continue;
+    const paramArgs = paramDecorator.getArguments();
+    if (paramArgs.length === 0) continue;
+    const nameArg = paramArgs[0];
+    if (!Node6.isStringLiteral(nameArg)) continue;
+    const paramName = nameArg.getLiteralValue();
+    const typeNode = param.getTypeNode();
+    const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
+    entries.push(`${paramName}: ${paramType}`);
+  }
+  return entries.length > 0 ? `{ ${entries.join("; ")} }` : null;
+}
+function extractResponseType(method, sourceFile, project) {
+  const apiResponseDecorator = method.getDecorator("ApiResponse");
+  if (apiResponseDecorator) {
+    const args = apiResponseDecorator.getArguments();
+    const optsArg = args[0];
+    if (optsArg && Node6.isObjectLiteralExpression(optsArg)) {
+      for (const prop of optsArg.getProperties()) {
+        if (!Node6.isPropertyAssignment(prop)) continue;
+        if (prop.getName() !== "type") continue;
+        const val = prop.getInitializer();
+        if (!val) continue;
+        if (Node6.isArrayLiteralExpression(val)) {
+          const elements = val.getElements();
+          const firstEl = elements[0];
+          if (elements.length > 0 && firstEl !== void 0) {
+            const innerType = resolveIdentifierToClassType(firstEl, sourceFile, project, 3);
+            return `Array<${innerType}>`;
+          }
+          return "Array<unknown>";
+        }
+        return resolveIdentifierToClassType(val, sourceFile, project, 3);
+      }
+    }
+  }
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    return resolveTypeNodeToString(returnTypeNode, sourceFile, project, 3);
+  }
+  return "unknown";
+}
+function resolveIdentifierToClassType(node, sourceFile, project, depth) {
+  if (!Node6.isIdentifier(node)) return "unknown";
+  const name = node.getText();
+  const resolved = findType(name, sourceFile, project);
+  if (resolved) {
+    return expandTypeDecl(resolved, project, depth - 1);
+  }
+  return name;
+}
+function resolveBodyQueryResponseRef(typeNode, sourceFile, project) {
+  return resolveTypeRef(typeNode, sourceFile, project, {
+    kinds: ["class", "interface"],
+    unwrapContainers: true
+  });
+}
+function extractDtoContract(method, sourceFile, project) {
+  let body = extractBodyType(method, sourceFile, project);
+  const filterInfo = extractApplyFilterInfo(method, sourceFile, project);
+  const query = extractQueryType(method, sourceFile, project);
+  if (filterInfo && filterInfo.source === "body") {
+    const bodyType = "import('@dudousxd/nestjs-filter-client').FilterQueryResult";
+    body = body ?? bodyType;
+  }
+  const paramsType = extractParamsType(method, sourceFile, project);
+  const response = extractResponseType(method, sourceFile, project);
+  if (body === null && query === null && paramsType === null && response === "unknown" && filterInfo === null) {
+    return null;
+  }
+  let bodyRef = null;
+  let queryRef = null;
+  let responseRef = null;
+  for (const param of method.getParameters()) {
+    if (param.getDecorators().some((d) => d.getName() === "Body") && param.getTypeNode()) {
+      bodyRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
+    }
+    if (param.getDecorators().some((d) => d.getName() === "Query") && param.getTypeNode()) {
+      queryRef = resolveBodyQueryResponseRef(param.getTypeNode(), sourceFile, project);
+    }
+  }
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    responseRef = resolveBodyQueryResponseRef(returnTypeNode, sourceFile, project);
+  }
+  if (!responseRef) {
+    const apiResp = method.getDecorator("ApiResponse");
+    if (apiResp) {
+      const args = apiResp.getArguments();
+      const optsArg = args[0];
+      if (optsArg && Node6.isObjectLiteralExpression(optsArg)) {
+        for (const prop of optsArg.getProperties()) {
+          if (Node6.isPropertyAssignment(prop) && prop.getName() === "type") {
+            const val = prop.getInitializer();
+            if (val && Node6.isIdentifier(val)) {
+              const name = val.getText();
+              const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
+              if (localDecl?.isExported()) {
+                responseRef = { name, filePath: sourceFile.getFilePath() };
+              } else {
+                const resolved = resolveImportedType(name, sourceFile, project);
+                if (resolved && (resolved.kind === "class" || resolved.kind === "interface") && resolved.decl.isExported()) {
+                  responseRef = { name, filePath: resolved.file.getFilePath() };
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  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);
+  }
+  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);
+  }
+  return {
+    query,
+    body,
+    response,
+    params: paramsType,
+    queryRef,
+    bodyRef,
+    responseRef,
+    filterFields: filterInfo?.fieldNames ?? null,
+    filterFieldTypes: filterInfo?.fieldTypes ?? null,
+    filterSource: filterInfo?.source ?? null,
+    bodyZodText,
+    queryZodText,
+    formNestedSchemas: Object.keys(formNested).length > 0 ? formNested : null,
+    formWarnings,
+    bodySchema,
+    querySchema
+  };
+}
+function resolveParamClass(method, decoratorName, sourceFile, project) {
+  for (const param of method.getParameters()) {
+    if (!param.getDecorators().some((d) => d.getName() === decoratorName)) continue;
+    const typeNode = param.getTypeNode();
+    if (!typeNode) continue;
+    const text = typeNode.getText().replace(/\[\]$/, "");
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(text)) continue;
+    const resolved = findType(text, sourceFile, project);
+    if (resolved && resolved.kind === "class") {
+      return { decl: resolved.decl, file: resolved.file };
+    }
+  }
+  return null;
+}
+var HTTP_METHOD_DECORATORS = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Patch: "PATCH",
+  Delete: "DELETE",
+  Options: "OPTIONS",
+  Head: "HEAD",
+  All: "ALL"
+};
+function extractFromSourceFile(sourceFile, project) {
+  const routes = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  const classes = sourceFile.getClasses();
+  for (const cls of classes) {
+    const controllerDecorator = cls.getDecorator("Controller");
+    if (!controllerDecorator) continue;
+    const controllerArgs = controllerDecorator.getArguments();
+    const firstArg3 = controllerArgs[0];
+    const prefix = decoratorStringArg(firstArg3) ?? "";
+    const className = cls.getName() ?? "Unknown";
+    for (const method of cls.getMethods()) {
+      let httpMethod;
+      let handlerPath = "";
+      for (const [decoratorName, verb] of Object.entries(HTTP_METHOD_DECORATORS)) {
+        const httpDecorator = method.getDecorator(decoratorName);
+        if (httpDecorator) {
+          httpMethod = verb;
+          const httpArgs = httpDecorator.getArguments();
+          const pathArg = httpArgs[0];
+          handlerPath = decoratorStringArg(pathArg) ?? "";
+          break;
+        }
+      }
+      const applyContractDecorator = method.getDecorator("ApplyContract");
+      if (applyContractDecorator) {
+        const decoratorArgs = applyContractDecorator.getArguments();
+        const firstDecoratorArg = decoratorArgs[0];
+        if (!firstDecoratorArg) continue;
+        let contractDef = null;
+        let bodyZodRef = null;
+        let queryZodRef = null;
+        if (Node6.isCallExpression(firstDecoratorArg)) {
+          contractDef = parseDefineContractCall(firstDecoratorArg);
+        } else if (Node6.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
+            }
+          }
+        });
+      }
+    }
+  }
+  return routes;
+}
+
+// src/generate.ts
+import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname3, join as join10 } from "path";
+import { Project as Project3 } from "ts-morph";
+
+// src/discovery/pages.ts
+import { readFile } from "fs/promises";
+import { join as join3, relative as relative2 } from "path";
+import fg2 from "fast-glob";
+var NON_PAGE_FILE_RE = /\.(?:test|spec|stories|story)\.(?:tsx?|jsx?|vue|svelte)$/i;
+async function discoverPages(opts) {
+  const allFiles = await fg2(opts.glob, { cwd: opts.cwd, absolute: true });
+  const files = allFiles.filter((f) => !NON_PAGE_FILE_RE.test(f));
+  files.sort();
+  const globStatic = opts.glob.split("*")[0]?.replace(/\/$/, "") ?? "";
+  const pagesBase = join3(opts.cwd, globStatic);
+  const out = [];
+  for (const file of files) {
+    const rel = relative2(opts.cwd, file);
+    const nameRel = relative2(pagesBase, file);
+    const name = computeName(nameRel, opts.componentNameStrategy);
+    const source = await readFile(file, "utf8");
+    const propsSource = extractPropsSource(source, opts.propsExport);
+    out.push({ name, absolutePath: file, relativePath: rel, propsSource });
+  }
+  return out;
+}
+function computeName(rel, strat) {
+  if (typeof strat === "function") return strat(rel);
+  const noExt = rel.replace(/\.(tsx?|vue|svelte)$/, "");
+  if (strat === "kebab") return noExt.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  return noExt;
+}
+function extractPropsSource(source, exportName) {
+  const re = new RegExp(`export\\s+type\\s+${exportName}\\s*=\\s*`, "m");
+  const m = source.match(re);
+  if (!m) return null;
+  const start = m.index + m[0].length;
+  let i = start;
+  let depth = 0;
+  let started = false;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "{") {
+      depth++;
+      started = true;
+    } else if (c === "}") {
+      depth--;
+      if (started && depth === 0) {
+        return source.slice(start, i + 1);
+      }
+    } else if (c === ";" && !started) return source.slice(start, i);
+    i++;
+  }
+  return source.slice(start);
+}
+
+// src/discovery/shared-props.ts
+import { Node as Node7, SyntaxKind as SyntaxKind3 } from "ts-morph";
+function discoverSharedProps(project, moduleEntry) {
+  try {
+    let sourceFile = project.getSourceFile(moduleEntry);
+    if (!sourceFile) {
+      try {
+        sourceFile = project.addSourceFileAtPath(moduleEntry);
+      } catch {
+        return null;
+      }
+    }
+    const forRootCall = findForRootCall(sourceFile);
+    if (!forRootCall) return null;
+    const initializer = findShareInitializer(forRootCall);
+    if (!initializer) return null;
+    return extractShareType(initializer, sourceFile, project);
+  } catch {
+    return null;
+  }
+}
+function findForRootCall(sourceFile) {
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression);
+  for (const call of callExpressions) {
+    const expr = call.getExpression();
+    if (!Node7.isPropertyAccessExpression(expr)) continue;
+    const methodName = expr.getName();
+    const objectExpr = expr.getExpression();
+    if (methodName === "forRoot" && Node7.isIdentifier(objectExpr)) {
+      const name = objectExpr.getText();
+      if (name === "InertiaModule") {
+        return call;
+      }
+    }
+  }
+  return null;
+}
+function findShareInitializer(forRootCall) {
+  if (!Node7.isCallExpression(forRootCall)) return null;
+  const args = forRootCall.getArguments();
+  const firstArg3 = args[0];
+  if (!firstArg3 || !Node7.isObjectLiteralExpression(firstArg3)) return null;
+  for (const prop of firstArg3.getProperties()) {
+    if (Node7.isPropertyAssignment(prop) && prop.getName() === "share") {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function extractShareType(node, sourceFile, project) {
+  if (Node7.isIdentifier(node)) {
+    const ref = resolveIdentifierToImportRef(node, sourceFile, project);
+    if (ref) {
+      return {
+        typeString: `Awaited<ReturnType<typeof import('${ref.importPath}').${ref.exportName}>>`,
+        properties: null,
+        isImportRef: true
+      };
+    }
+  }
+  if (Node7.isArrowFunction(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (Node7.isFunctionExpression(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (Node7.isObjectLiteralExpression(node)) {
+    const result = extractFromObjectLiteral(node);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  return null;
+}
+function resolveIdentifierToImportRef(id, sourceFile, project) {
+  if (!Node7.isIdentifier(id)) return null;
+  const name = id.getText();
+  const localFunc = sourceFile.getFunction(name);
+  if (localFunc?.isExported()) {
+    const filePath = sourceFile.getFilePath().replace(/\.ts$/, "");
+    return { importPath: filePath, exportName: name };
+  }
+  const localVar = sourceFile.getVariableDeclaration(name);
+  if (localVar?.isExported()) {
+    const filePath = sourceFile.getFilePath().replace(/\.ts$/, "");
+    return { importPath: filePath, exportName: name };
+  }
+  for (const imp of sourceFile.getImportDeclarations()) {
+    for (const named of imp.getNamedImports()) {
+      const importedName = named.getAliasNode()?.getText() ?? named.getName();
+      if (importedName !== name) continue;
+      const resolvedSource = imp.getModuleSpecifierSourceFile();
+      if (!resolvedSource) continue;
+      const originalName = named.getName();
+      const fn = resolvedSource.getFunction(originalName);
+      if (fn?.isExported()) {
+        const filePath = resolvedSource.getFilePath().replace(/\.ts$/, "");
+        return { importPath: filePath, exportName: originalName };
+      }
+      const v = resolvedSource.getVariableDeclaration(originalName);
+      if (v?.isExported()) {
+        const filePath = resolvedSource.getFilePath().replace(/\.ts$/, "");
+        return { importPath: filePath, exportName: originalName };
+      }
+    }
+  }
+  return null;
+}
+function extractFromFunctionLike(node, _sourceFile) {
+  const returnTypeNode = Node7.isArrowFunction(node) || Node7.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  if (returnTypeNode) {
+    return extractFromReturnTypeAnnotation(returnTypeNode);
+  }
+  if (Node7.isArrowFunction(node)) {
+    const body = node.getBody();
+    if (Node7.isParenthesizedExpression(body)) {
+      const inner = body.getExpression();
+      if (Node7.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    if (Node7.isObjectLiteralExpression(body)) {
+      return extractFromObjectLiteral(body);
+    }
+    if (Node7.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  if (Node7.isFunctionExpression(node)) {
+    const body = node.getBody();
+    if (Node7.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  return null;
+}
+function extractFromReturnTypeAnnotation(typeNode) {
+  if (Node7.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    if (Node7.isIdentifier(typeName) && typeName.getText() === "Promise") {
+      const typeArgs = typeNode.getTypeArguments();
+      const firstArg3 = typeArgs[0];
+      if (firstArg3) {
+        return extractFromReturnTypeAnnotation(firstArg3);
+      }
+      return null;
+    }
+  }
+  if (Node7.isTypeLiteral(typeNode)) {
+    const properties = [];
+    for (const member of typeNode.getMembers()) {
+      if (Node7.isPropertySignature(member)) {
+        const name = member.getName();
+        const memberTypeNode = member.getTypeNode();
+        const type = memberTypeNode ? memberTypeNode.getText() : "unknown";
+        properties.push({ name, type });
+      }
+    }
+    if (properties.length === 0) return null;
+    const typeString = `{ ${properties.map((p) => `${p.name}: ${p.type}`).join("; ")} }`;
+    return { typeString, properties, isImportRef: false };
+  }
+  return null;
+}
+function extractFromBlockReturn(block) {
+  if (!Node7.isBlock(block)) return null;
+  const statements = block.getStatements();
+  for (let i = statements.length - 1; i >= 0; i--) {
+    const stmt = statements[i];
+    if (!Node7.isReturnStatement(stmt)) continue;
+    const expr = stmt.getExpression();
+    if (!expr) continue;
+    if (Node7.isObjectLiteralExpression(expr)) {
+      return extractFromObjectLiteral(expr);
+    }
+    if (Node7.isParenthesizedExpression(expr)) {
+      const inner = expr.getExpression();
+      if (Node7.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    break;
+  }
+  return null;
+}
+function extractFromObjectLiteral(objLiteral) {
+  if (!Node7.isObjectLiteralExpression(objLiteral)) return null;
+  const properties = [];
+  for (const prop of objLiteral.getProperties()) {
+    if (!Node7.isPropertyAssignment(prop)) continue;
+    const name = prop.getName();
+    const initializer = prop.getInitializer();
+    if (!initializer) continue;
+    const type = inferExpressionType(initializer);
+    properties.push({ name, type });
+  }
+  if (properties.length === 0) return null;
+  const typeString = `{ ${properties.map((p) => `${p.name}: ${p.type}`).join("; ")} }`;
+  return { typeString, properties, isImportRef: false };
+}
+function inferExpressionType(node) {
+  if (Node7.isStringLiteral(node)) return "string";
+  if (Node7.isTemplateExpression(node) || Node7.isNoSubstitutionTemplateLiteral(node))
+    return "string";
+  if (Node7.isNumericLiteral(node)) return "number";
+  if (node.getKind() === SyntaxKind3.TrueKeyword || node.getKind() === SyntaxKind3.FalseKeyword) {
+    return "boolean";
+  }
+  if (node.getKind() === SyntaxKind3.NullKeyword) return "null";
+  if (Node7.isIdentifier(node) && node.getText() === "undefined") return "undefined";
+  if (Node7.isObjectLiteralExpression(node)) {
+    const props = node.getProperties();
+    if (props.length === 0) return "Record<string, unknown>";
+    const entries = [];
+    for (const prop of props) {
+      if (!Node7.isPropertyAssignment(prop)) continue;
+      const key = prop.getName();
+      const init = prop.getInitializer();
+      if (!init) continue;
+      entries.push(`${key}: ${inferExpressionType(init)}`);
+    }
+    if (entries.length === 0) return "Record<string, unknown>";
+    return `{ ${entries.join("; ")} }`;
+  }
+  if (Node7.isArrayLiteralExpression(node)) {
+    const elements = node.getElements();
+    if (elements.length === 0) return "Array<unknown>";
+    const first = elements[0];
+    if (first) return `Array<${inferExpressionType(first)}>`;
+    return "Array<unknown>";
+  }
+  if (Node7.isConditionalExpression(node)) {
+    const whenTrue = inferExpressionType(node.getWhenTrue());
+    const whenFalse = inferExpressionType(node.getWhenFalse());
+    if (whenTrue === whenFalse) return whenTrue;
+    return `${whenTrue} | ${whenFalse}`;
+  }
+  if (Node7.isParenthesizedExpression(node)) {
+    return inferExpressionType(node.getExpression());
+  }
+  if (Node7.isAsExpression(node)) {
+    const typeNode = node.getTypeNode();
+    if (typeNode) return typeNode.getText();
+  }
+  return "unknown";
+}
+
+// src/emit/emit-api.ts
+import { mkdir, writeFile } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join4, relative as relative3 } from "path";
+
+// src/extension/registry.ts
+import { Project as Project2 } from "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(
+          `api client layer claimed by both "${layerOwner}" and "${ext.name}" \u2014 only one extension may set apiClientLayer.`
+        );
+      }
+      layer = ext.apiClientLayer;
+      layerOwner = ext.name;
+    }
+  }
+  return {
+    ...transport ? { transport } : {},
+    ...layer ? { layer } : {}
+  };
+}
+var CORE_FILES = /* @__PURE__ */ new Set(["routes.ts", "api.ts", "forms.ts", "index.d.ts", "pages.d.ts"]);
+function createExtensionContext(config, getRoutes) {
+  let project;
+  return {
+    cwd: config.codegen.cwd,
+    outDir: config.codegen.outDir,
+    config,
+    get routes() {
+      return getRoutes();
+    },
+    project() {
+      if (!project) {
+        project = new Project2({
+          skipAddingFilesFromTsConfig: true,
+          skipLoadingLibFiles: true,
+          skipFileDependencyResolution: true,
+          compilerOptions: { allowJs: true, strict: false }
+        });
+      }
+      return project;
+    }
+  };
+}
+async function applyTransformRoutes(routes, extensions, ctx) {
+  let current = routes;
+  for (const ext of extensions) {
+    if (!ext.transformRoutes) continue;
+    const result = await ext.transformRoutes(current, ctx);
+    if (Array.isArray(result)) current = result;
+  }
+  return current;
+}
+async function collectEmittedFiles(extensions, ctx) {
+  const files = [];
+  const owners = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (!ext.emitFiles) continue;
+    const emitted = await ext.emitFiles(ctx);
+    for (const file of emitted) {
+      const key = file.path.replace(/\\/g, "/").replace(/^\.\//, "");
+      if (CORE_FILES.has(key)) {
+        throw new CodegenError(
+          `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);
+      files.push(file);
+    }
+  }
+  return files;
+}
+
+// src/emit/emit-api.ts
+async function emitApi(routes, outDir, opts = {}) {
+  await mkdir(outDir, { recursive: true });
+  const content = buildApiFile(routes, outDir, opts);
+  await writeFile(join4(outDir, "api.ts"), content, "utf8");
+}
+function splitName(name) {
+  return name.split(".");
+}
+function toObjectKey3(segment) {
+  if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment)) {
+    return segment;
+  }
+  return JSON.stringify(segment);
+}
+function toCamelCase(s) {
+  return s.split(/[^a-zA-Z0-9]+/).filter(Boolean).map(
+    (word, i) => i === 0 ? word.charAt(0).toLowerCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  ).join("");
+}
+function validateNameSegment(seg, fullName) {
+  if (!/^[a-z][a-zA-Z0-9]*$/.test(seg)) {
+    const suggested = toCamelCase(seg);
+    throw new Error(
+      `Contract name "${fullName}" has invalid segment "${seg}". Use camelCase identifiers only (lowercase letter then alphanumeric). Suggested: "${suggested}"`
+    );
+  }
+}
+function insertIntoTree(tree, segments, leaf, fullName) {
+  const head = segments[0];
+  const rest = segments.slice(1);
+  if (rest.length === 0) {
+    const existing = tree.get(head);
+    if (existing !== void 0 && existing.kind === "branch") {
+      throw new Error(
+        `Contract name conflict: "${fullName}" cannot have both a direct entry and child entries`
+      );
+    }
+    tree.set(head, leaf);
+  } else {
+    const existing = tree.get(head);
+    if (existing !== void 0 && existing.kind === "leaf") {
+      const prefixName = fullName.split(".").slice(0, segments.length - rest.length).join(".");
+      throw new Error(
+        `Contract name conflict: "${prefixName}" cannot have both a direct entry and child entries`
+      );
+    }
+    let branch;
+    if (existing === void 0) {
+      branch = { kind: "branch", children: /* @__PURE__ */ new Map() };
+      tree.set(head, branch);
+    } else {
+      branch = existing;
+    }
+    insertIntoTree(branch.children, rest, leaf, fullName);
+  }
+}
+function buildParamsType(params) {
+  const pathParams = params.filter((p) => p.source === "path");
+  if (pathParams.length === 0) return "never";
+  return `{ ${pathParams.map((p) => `${p.name}: string`).join("; ")} }`;
+}
+function hasPathParams(params) {
+  return params.some((p) => p.source === "path");
+}
+function kindToTs(kind, enumValues, numericEnum) {
+  if (enumValues && enumValues.length > 0) {
+    return enumValues.map((v) => numericEnum ? v : JSON.stringify(v)).join(" | ");
+  }
+  switch (kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "json":
+      return "Record<string, unknown>";
+    default:
+      return "unknown";
+  }
+}
+function emitFieldTypesLiteral(fts) {
+  const entries = fts.map((f) => {
+    let t = f.typeRef ? f.typeRef.name : kindToTs(f.kind, f.enumValues, f.numericEnum);
+    if (f.nullable) t = `${t} | null`;
+    return `${JSON.stringify(f.name)}: ${t}`;
+  });
+  return `{ ${entries.join("; ")} }`;
+}
+function emitFilterQueryTypeArgs(c) {
+  const fieldsUnion = (c.contractSource.filterFields ?? []).map((f) => JSON.stringify(f)).join(" | ");
+  const fts = c.contractSource.filterFieldTypes;
+  return fts?.length ? `${fieldsUnion}, ${emitFieldTypesLiteral(fts)}` : fieldsUnion;
+}
+function emitFilterQueryType(c) {
+  return `import('@dudousxd/nestjs-filter-client').TypedFilterQuery<${emitFilterQueryTypeArgs(c)}>`;
+}
+function buildResponseType(c, outDir) {
+  if (c.controllerRef) {
+    let relPath = relative3(outDir, c.controllerRef.filePath).replace(/\.ts$/, "");
+    if (!relPath.startsWith(".")) relPath = `./${relPath}`;
+    return `Awaited<ReturnType<import('${relPath}').${c.controllerRef.className}['${c.controllerRef.methodName}']>>`;
+  }
+  const respRef = c.contractSource.responseRef;
+  if (respRef) {
+    return respRef.isArray ? `Array<${respRef.name}>` : respRef.name;
+  }
+  return c.contractSource.response;
+}
+function emitRouterTypeBlock(tree, indent, outDir) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, node] of tree) {
+    const objKey = toObjectKey3(key);
+    if (node.kind === "leaf") {
+      const c = node;
+      const method = c.method.toUpperCase();
+      const queryRef = c.contractSource.queryRef;
+      const isFilterQuery = c.contractSource.filterSource === "query" && !!c.contractSource.filterFields?.length;
+      const query = queryRef ? queryRef.isArray ? `Array<${queryRef.name}>` : queryRef.name : isFilterQuery ? emitFilterQueryType(c) : c.contractSource.query ?? "never";
+      const bodyRef = c.contractSource.bodyRef;
+      const body = method === "GET" ? "never" : bodyRef ? bodyRef.isArray ? `Array<${bodyRef.name}>` : bodyRef.name : c.contractSource.body ?? "never";
+      const response = buildResponseType(c, outDir);
+      const params = buildParamsType(c.params);
+      const safeMethod = JSON.stringify(method);
+      const safeUrl = JSON.stringify(c.path);
+      const filterFields = c.contractSource.filterFields?.length ? c.contractSource.filterFields.map((f) => JSON.stringify(f)).join(" | ") : "never";
+      lines.push(
+        `${pad}${objKey}: { method: ${safeMethod}; url: ${safeUrl}; params: ${params}; query: ${query}; body: ${body}; response: ${response}; filterFields: ${filterFields} };`
+      );
+    } else {
+      lines.push(`${pad}${objKey}: {`);
+      lines.push(...emitRouterTypeBlock(node.children, indent + 2, outDir));
+      lines.push(`${pad}};`);
+    }
+  }
+  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 fields = [];
+  if (withParams) fields.push(`params: ${TA}['params']`);
+  if (hasQuery) fields.push(`query?: ${TA}['query']`);
+  if (hasBody) fields.push(`body?: ${TA}['body']`);
+  const inputType = fields.length ? `{ ${fields.join("; ")} }` : "Record<string, never>";
+  const urlExpr = withParams ? `route(${flat} as never, input?.params as never) || ${path}` : `route(${flat} as never) || ${path}`;
+  const optsParts = [];
+  if (hasQuery) optsParts.push("query: input?.query as Record<string, unknown> | undefined");
+  if (hasBody) optsParts.push("body: input?.body");
+  const optsExpr = optsParts.length ? `{ ${optsParts.join(", ")} }` : "{}";
+  return {
+    routeName: c.name,
+    method: m,
+    isGet,
+    isQuery,
+    hasParams: withParams,
+    hasBody,
+    inputType,
+    urlExpr,
+    optsExpr,
+    responseType: `${TA}['response']`,
+    bodyType: `${TA}['body']`,
+    queryKeyExpr: `[${flat}, input] as const`
+  };
+}
+function renderFetcherRequest(req) {
+  return `fetcher.${req.method}<${req.responseType}>(${req.urlExpr}, ${req.optsExpr})`;
+}
+function emitReqHelper() {
+  return [
+    "/** Awaitable request handle. `await api.x.y({...})` runs the fetch; extensions add query/mutation helpers. */",
+    "type __Req<R> = {",
+    "  then<T1 = R, T2 = never>(",
+    "    onfulfilled?: ((value: R) => T1 | PromiseLike<T1>) | null,",
+    "    onrejected?: ((reason: unknown) => T2 | PromiseLike<T2>) | null,",
+    "  ): Promise<T1 | T2>;",
+    "  catch<T = never>(onrejected?: ((reason: unknown) => T | PromiseLike<T>) | null): Promise<R | T>;",
+    "  finally(onfinally?: (() => void) | null): Promise<R>;",
+    "  fetch(): Promise<R>;",
+    "};",
+    "function __req<R>(run: () => Promise<R>): __Req<R> {",
+    "  let __p: Promise<R> | undefined;",
+    "  const __promise = () => {",
+    "    __p ??= run();",
+    "    return __p;",
+    "  };",
+    "  return {",
+    "    then: (onfulfilled, onrejected) => __promise().then(onfulfilled, onrejected),",
+    "    catch: (onrejected) => __promise().catch(onrejected),",
+    "    finally: (onfinally) => __promise().finally(onfinally),",
+    "    fetch: run,",
+    "  };",
+    "}",
+    ""
+  ];
+}
+function renderLeaf(pad, objKey, req, requestExpr, members) {
+  const lines = [`${pad}${objKey}: (input?: ${req.inputType}) => ({`];
+  lines.push(`${pad}  ...__req<${req.responseType}>(() => ${requestExpr}),`);
+  for (const [name, value] of Object.entries(members)) {
+    lines.push(`${pad}  ${name}: ${value},`);
+  }
+  lines.push(`${pad}}),`);
+  return lines;
+}
+function emitApiObjectBlock(tree, indent, p) {
+  const pad = " ".repeat(indent);
+  const lines = [];
+  for (const [key, node] of tree) {
+    const objKey = toObjectKey3(key);
+    if (node.kind === "branch") {
+      lines.push(`${pad}${objKey}: {`);
+      lines.push(...emitApiObjectBlock(node.children, indent + 2, p));
+      lines.push(`${pad}},`);
+      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, 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));
+    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;
+      }
+    }
+    lines.push(...renderLeaf(pad, objKey, req, leaf.requestExpr, members));
+  }
+  return lines;
+}
+function buildRouterTypeAccess(name) {
+  const segments = splitName(name);
+  return `ApiRouter${segments.map((s) => `[${JSON.stringify(s)}]`).join("")}`;
+}
+function buildApiFile(routes, outDir, opts = {}) {
+  const fetcherImportPath = opts.fetcherImportPath;
+  const extensions = opts.extensions ?? [];
+  const { transport, layer } = resolveApiSlots(extensions);
+  const memberExts = extensions.filter((e) => e.apiMembers);
+  const headerExts = extensions.filter((e) => e.apiHeader);
+  const contracted = routes.filter((r) => r.contract);
+  const ctx = opts.ctx ?? {
+    cwd: outDir ?? "",
+    outDir: outDir ?? "",
+    routes,
+    config: {},
+    project: () => {
+      throw new Error("ExtensionContext.project() is unavailable in standalone emitApi.");
+    }
+  };
+  const importsByFile = /* @__PURE__ */ new Map();
+  for (const r of contracted) {
+    const cs = r.contract?.contractSource;
+    if (!cs) continue;
+    const refs = r.controllerRef ? [cs.queryRef, cs.bodyRef] : [cs.queryRef, cs.bodyRef, cs.responseRef];
+    for (const ref of refs) {
+      if (!ref) continue;
+      let names = importsByFile.get(ref.filePath);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        importsByFile.set(ref.filePath, names);
+      }
+      names.add(ref.name);
+    }
+    for (const ft of cs.filterFieldTypes ?? []) {
+      if (!ft.typeRef) continue;
+      let names = importsByFile.get(ft.typeRef.filePath);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        importsByFile.set(ft.typeRef.filePath, names);
+      }
+      names.add(ft.typeRef.name);
+    }
+  }
+  const lines = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ""];
+  const extImports = [];
+  const seenImports = /* @__PURE__ */ new Set();
+  const pushImport = (imp) => {
+    if (seenImports.has(imp)) return;
+    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);
+  }
+  lines.push(...extImports);
+  lines.push(
+    "import { route, ROUTES, type RouteName, type ExtractParams, type RouteParams } from './routes.js';"
+  );
+  const runtimeImport = fetcherImportPath ?? "@dudousxd/nestjs-client";
+  lines.push(`import type { Fetcher } from '${runtimeImport}';`);
+  if (importsByFile.size > 0 && outDir) {
+    lines.push("");
+    const emittedNames = /* @__PURE__ */ new Set();
+    for (const [filePath, names] of importsByFile) {
+      let relPath;
+      if (isAbsolute2(filePath)) {
+        relPath = relative3(outDir, filePath).replace(/\.ts$/, "");
+        if (!relPath.startsWith(".")) relPath = `./${relPath}`;
+      } else {
+        relPath = filePath;
+      }
+      const specifiers = [];
+      for (const name of [...names].sort()) {
+        if (emittedNames.has(name)) {
+          const alias = `${name}_${emittedNames.size}`;
+          specifiers.push(`${name} as ${alias}`);
+          emittedNames.add(alias);
+        } else {
+          specifiers.push(name);
+          emittedNames.add(name);
+        }
+      }
+      lines.push(`import type { ${specifiers.join(", ")} } from '${relPath}';`);
+    }
+  }
+  lines.push("");
+  if (contracted.length === 0) {
+    lines.push("export type ApiRouter = Record<string, never>;");
+    lines.push("");
+    lines.push("export function createApi(_fetcher: Fetcher): Record<string, never> {");
+    lines.push("  return {};");
+    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("");
+    return lines.join("\n");
+  }
+  const tree = /* @__PURE__ */ new Map();
+  for (const r of contracted) {
+    const c = r.contract;
+    const name = r.name;
+    const segments = splitName(name);
+    for (const seg of segments) {
+      validateNameSegment(seg, name);
+    }
+    const leaf = {
+      kind: "leaf",
+      method: r.method,
+      name,
+      path: r.path,
+      params: r.params,
+      controllerRef: r.controllerRef,
+      contractSource: c.contractSource
+    };
+    insertIntoTree(tree, segments, leaf, name);
+  }
+  lines.push("export type ApiRouter = {");
+  lines.push(...emitRouterTypeBlock(tree, 2, outDir ?? ""));
+  lines.push("};");
+  lines.push("");
+  lines.push(...emitReqHelper());
+  lines.push("export function createApi(fetcher: Fetcher) {");
+  lines.push("  return {");
+  lines.push(
+    ...emitApiObjectBlock(tree, 4, {
+      ...transport ? { transport } : {},
+      ...layer ? { layer } : {},
+      memberExts,
+      ctx
+    })
+  );
+  lines.push("  };");
+  lines.push("}");
+  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("");
+  for (const ext of headerExts) {
+    const statements = ext.apiHeader?.(ctx)?.statements;
+    if (statements?.length) {
+      lines.push(...statements, "");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/emit/emit-cache.ts
+import { mkdir as mkdir2, stat, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+async function emitCache(pages, outDir) {
+  await mkdir2(outDir, { recursive: true });
+  const entries = await Promise.all(
+    pages.map(async (p) => {
+      const s = await stat(p.absolutePath);
+      return {
+        name: p.name,
+        relativePath: p.relativePath,
+        mtime: s.mtime.toISOString()
+      };
+    })
+  );
+  const cache = { pages: entries };
+  await writeFile2(join5(outDir, "components.json"), `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+}
+
+// src/emit/emit-forms.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { join as join6, relative as relative4 } from "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 mkdir3(outDir, { recursive: true });
+    await writeFile3(join6(outDir, "forms.ts"), content2, "utf8");
+    return true;
+  }
+  const entries = collectFormEntries(routes);
+  if (entries.length === 0) return false;
+  await mkdir3(outDir, { recursive: true });
+  const content = buildFormsFile(entries, outDir, config);
+  await writeFile3(join6(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("");
+}
+function deriveBaseName(routeName) {
+  const segments = routeName.split(".");
+  const method = pascal(segments[segments.length - 1] ?? 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 = relative4(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 applyRenames(text, renames) {
+  if (!renames || renames.size === 0) return text;
+  let out = text;
+  for (const [from, to] of renames) {
+    if (from === to) continue;
+    out = out.replace(new RegExp(`\\b${escapeRegExp(from)}\\b`, "g"), to);
+  }
+  return out;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isSelfReferential(name, text) {
+  return new RegExp(`\\b${escapeRegExp(name)}\\b`).test(text);
+}
+function planNestedSchemas(entries) {
+  const globalSchemas = /* @__PURE__ */ new Map();
+  const renamesByEntry = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.nestedSchemas) continue;
+    const local = Object.entries(entry.nestedSchemas);
+    if (local.length === 0) continue;
+    const rename = /* @__PURE__ */ new Map();
+    for (const [name] of local) rename.set(name, name);
+    const textFor = (name) => {
+      const raw = entry.nestedSchemas?.[name] ?? "";
+      return applyRenames(raw, rename);
+    };
+    let changed = true;
+    let guard = 0;
+    while (changed && guard < local.length + 2) {
+      changed = false;
+      guard += 1;
+      for (const [name] of local) {
+        const finalName = rename.get(name) ?? name;
+        const text = textFor(name);
+        const existing = globalSchemas.get(finalName);
+        if (existing === void 0) continue;
+        if (existing === text) continue;
+        let i = 2;
+        let candidate = `${name}_${i}`;
+        while (globalSchemas.has(candidate) && globalSchemas.get(candidate) !== textFor(name) || [...rename.values()].includes(candidate)) {
+          i += 1;
+          candidate = `${name}_${i}`;
+        }
+        rename.set(name, candidate);
+        changed = true;
+      }
+    }
+    for (const [name] of local) {
+      const finalName = rename.get(name) ?? name;
+      let text = textFor(name);
+      if (isSelfReferential(finalName, text)) {
+        text = "z.unknown() /* recursive type \u2014 not expanded */";
+      }
+      const existing = globalSchemas.get(finalName);
+      if (existing === void 0) {
+        globalSchemas.set(finalName, text);
+      }
+    }
+    renamesByEntry.set(entry, rename);
+  }
+  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
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
+async function emitIndex(outDir, hasContracts = false, hasForms = false) {
+  await mkdir4(outDir, { recursive: true });
+  const exports = ["export * from './pages.js';", "export * from './routes.js';"];
+  if (hasContracts) {
+    exports.push("export * from './api.js';");
+  }
+  if (hasForms) {
+    exports.push("export * from './forms.js';");
+  }
+  const content = ["// Generated by @dudousxd/nestjs-codegen. Do not edit.", ...exports, ""].join(
+    "\n"
+  );
+  await writeFile4(join7(outDir, "index.d.ts"), content, "utf8");
+}
+
+// src/emit/emit-pages.ts
+import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
+import { join as join8, relative as relative5 } from "path";
+async function emitPages(pages, outDir, _options = {}) {
+  await mkdir5(outDir, { recursive: true });
+  const pageNameUnion = pages.length > 0 ? pages.map((p) => JSON.stringify(p.name)).join(" | ") : "never";
+  const augBody = pages.map((p) => {
+    const key = needsQuotes(p.name) ? JSON.stringify(p.name) : p.name;
+    const valueType = buildAugmentationType(p, outDir);
+    return `    ${key}: ${valueType};`;
+  }).join("\n");
+  const propsHelper = "\nexport type InertiaProps<K extends InertiaPageName> = import('@dudousxd/nestjs-inertia').InertiaPages[K];\n";
+  const sharedPropsBlock = buildSharedPropsBlock(_options.sharedProps ?? null);
+  const content = `// Generated by @dudousxd/nestjs-codegen. Do not edit.
+
+export type InertiaPageName = ${pageNameUnion};
+${propsHelper}
+declare module '@dudousxd/nestjs-inertia' {
+  interface InertiaPages {
+${augBody}
+  }
+${sharedPropsBlock}}
+`;
+  await writeFile5(join8(outDir, "pages.d.ts"), content, "utf8");
+}
+function buildSharedPropsBlock(sharedProps) {
+  if (!sharedProps) return "";
+  if (sharedProps.isImportRef) {
+    return `
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface InertiaSharedProps extends ${sharedProps.typeString} {}
+`;
+  }
+  if (!sharedProps.properties || sharedProps.properties.length === 0) return "";
+  const propsBody = sharedProps.properties.map((p) => `    ${p.name}: ${p.type};`).join("\n");
+  return `
+  interface InertiaSharedProps {
+${propsBody}
+  }
+`;
+}
+function buildAugmentationType(page, outDir) {
+  let importPath = relative5(outDir, page.absolutePath).replace(/\.(tsx?|vue|svelte)$/, "");
+  if (!importPath.startsWith(".")) {
+    importPath = `./${importPath}`;
+  }
+  return `Parameters<typeof import('${importPath}').default>[0]`;
+}
+function needsQuotes(name) {
+  return !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+
+// src/emit/emit-routes.ts
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import { join as join9 } from "path";
+async function emitRoutes(routes, outDir) {
+  await mkdir6(outDir, { recursive: true });
+  const content = buildRoutesFile(routes);
+  await writeFile6(join9(outDir, "routes.ts"), content, "utf8");
+}
+function buildRoutesFile(routes) {
+  if (routes.length === 0) {
+    return buildEmpty();
+  }
+  const entries = routes.map((r) => `  ${JSON.stringify(r.name)}: ${JSON.stringify(r.path)},`).join("\n");
+  const routeNameUnion = routes.map((r) => `  | ${JSON.stringify(r.name)}`).join("\n");
+  const lines = [
+    "// Generated by @dudousxd/nestjs-codegen. Do not edit.",
+    "",
+    "/** Map of route name \u2192 path pattern. */",
+    "export const ROUTES = {",
+    entries,
+    "} as const;",
+    "",
+    "/** Union of all known route names. */",
+    "export type RouteName =",
+    `${routeNameUnion};`,
+    "",
+    "/**",
+    " * Extracts path-parameter names from a route path string.",
+    ' * `ExtractParams<"/users/:id">` \u2192 `"id"`',
+    " */",
+    "export type ExtractParams<Path extends string> =",
+    "  Path extends `${string}:${infer Param}/${infer Rest}`",
+    "    ? Param | ExtractParams<`/${Rest}`>",
+    "    : Path extends `${string}:${infer Param}`",
+    "      ? Param",
+    "      : never;",
+    "",
+    "/**",
+    " * Mapped type: given a `RouteName`, returns an object with each path param as `string`.",
+    ' * `RouteParams<"UsersController.show">` \u2192 `{ id: string }`',
+    ' * `RouteParams<"UsersController.list">` \u2192 `Record<string, never>`',
+    " */",
+    "export type RouteParams<K extends RouteName> =",
+    "  ExtractParams<(typeof ROUTES)[K]> extends never",
+    "    ? Record<string, never>",
+    "    : { [P in ExtractParams<(typeof ROUTES)[K]>]: string };",
+    "",
+    "/**",
+    " * Map of every route name to its resolved params object.",
+    " * Use this for `InertiaRegistry` module augmentation.",
+    " */",
+    "export type RouteParamsMap = { [K in RouteName]: RouteParams<K> };",
+    "",
+    "/**",
+    " * Build a URL from a named route, interpolating path params and appending query string.",
+    " *",
+    " * @example",
+    " * route('UsersController.show', { id: '42' }) // \u2192 '/users/42'",
+    " * route('UsersController.list')                // \u2192 '/users'",
+    " * route('users.list', undefined, { active: true }) // \u2192 '/api/users?active=true'",
+    " */",
+    "export function route<K extends RouteName>(",
+    "  name: K,",
+    "  ...args: ExtractParams<(typeof ROUTES)[K]> extends never",
+    "    ? [params?: undefined, query?: Record<string, unknown>]",
+    "    : [params: RouteParams<K>, query?: Record<string, unknown>]",
+    "): string {",
+    "  const [params, query] = args as [Record<string, string> | undefined, Record<string, unknown> | undefined];",
+    "  const path: string | undefined = ROUTES[name as RouteName];",
+    "  if (path === undefined) {",
+    "    const available = Object.keys(ROUTES).join(', ');",
+    "    throw new Error(",
+    '      `[nestjs-codegen] Route "${String(name)}" does not exist.\\n\\n` +',
+    "      `Available routes: ${available}\\n\\n` +",
+    "      `This usually means:\\n` +",
+    "      `  - The route name has a typo\\n` +",
+    "      `  - The controller hasn't been scanned by codegen yet (run: nestjs-codegen codegen)\\n` +",
+    "      `  - The @As() decorator changed the route name\\n`",
+    "    );",
+    "  }",
+    "  let resolvedPath: string = path;",
+    "  if (params) {",
+    "    resolvedPath = resolvedPath.replace(/:([^/]+)/g, (_, key) => {",
+    "      const val = params[key];",
+    "      if (val === undefined) throw new Error(`Missing route param: ${key}`);",
+    "      return encodeURIComponent(val);",
+    "    });",
+    "  }",
+    "  if (query && Object.keys(query).length > 0) {",
+    "    const qs = new URLSearchParams();",
+    "    for (const [k, v] of Object.entries(query)) {",
+    "      if (v !== undefined && v !== null) qs.append(k, String(v));",
+    "    }",
+    "    const qStr = qs.toString();",
+    "    if (qStr) {",
+    "      const sep = resolvedPath.includes('?') ? '&' : '?';",
+    "      resolvedPath = `${resolvedPath}${sep}${qStr}`;",
+    "    }",
+    "  }",
+    "  return resolvedPath;",
+    "}",
+    ""
+  ];
+  return lines.join("\n");
+}
+function buildEmpty() {
+  return [
+    "// Generated by @dudousxd/nestjs-codegen. Do not edit.",
+    "",
+    "export const ROUTES = {} as const;",
+    "export type RouteName = never;",
+    "export type ExtractParams<_Path extends string> = never;",
+    "export type RouteParams<_K extends RouteName> = Record<string, never>;",
+    'export function route(_name: never, _params?: undefined, _query?: Record<string, unknown>): string { return ""; }',
+    ""
+  ].join("\n");
+}
+
+// src/generate.ts
+async function generate(config, inputRoutes = []) {
+  const extensions = config.extensions ?? [];
+  let routes = inputRoutes;
+  const ctx = createExtensionContext(config, () => routes);
+  if (extensions.length > 0) {
+    routes = await applyTransformRoutes(routes, extensions, ctx);
+  }
+  if (config.pages) {
+    const pagesConfig = config.pages;
+    const pages = await discoverPages({
+      glob: pagesConfig.glob,
+      cwd: config.codegen.cwd,
+      propsExport: pagesConfig.propsExport,
+      componentNameStrategy: pagesConfig.componentNameStrategy
+    });
+    let sharedProps = null;
+    if (config.app?.moduleEntry) {
+      try {
+        const tsconfigPath = config.app.tsconfig ?? join10(config.codegen.cwd, "tsconfig.json");
+        let project;
+        try {
+          project = new Project3({
+            tsConfigFilePath: tsconfigPath,
+            skipAddingFilesFromTsConfig: true,
+            skipLoadingLibFiles: true,
+            skipFileDependencyResolution: true
+          });
+        } catch {
+          project = new Project3({
+            skipAddingFilesFromTsConfig: true,
+            skipLoadingLibFiles: true,
+            skipFileDependencyResolution: true,
+            compilerOptions: { allowJs: true, strict: false }
+          });
+        }
+        sharedProps = discoverSharedProps(project, config.app.moduleEntry);
+      } catch {
+      }
+    }
+    await emitPages(pages, config.codegen.outDir, {
+      propsExport: pagesConfig.propsExport,
+      sharedProps
+    });
+    await emitCache(pages, config.codegen.outDir);
+  }
+  const hasRoutes = routes.length > 0;
+  const hasContracts = routes.some((r) => r.contract);
+  if (hasRoutes) {
+    await emitRoutes(routes, config.codegen.outDir);
+  }
+  if (hasContracts) {
+    await emitApi(routes, config.codegen.outDir, {
+      ...config.fetcher?.importPath ? { fetcherImportPath: config.fetcher.importPath } : {},
+      extensions,
+      ctx
+    });
+  }
+  const hasForms = await emitForms(routes, config.codegen.outDir, config.forms, config.validation);
+  await emitIndex(config.codegen.outDir, hasContracts, hasForms);
+  if (extensions.length > 0) {
+    const extraFiles = await collectEmittedFiles(extensions, ctx);
+    for (const file of extraFiles) {
+      const dest = join10(config.codegen.outDir, file.path);
+      await mkdir7(dirname3(dest), { recursive: true });
+      await writeFile7(dest, file.contents, "utf8");
+    }
+  }
+}
+
+// src/watch/lock-file.ts
+import { open } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile2, unlink } from "fs/promises";
+import { join as join11 } from "path";
+var LOCK_FILE = ".watcher.lock";
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(outDir) {
+  await mkdir8(outDir, { recursive: true });
+  const lockPath = join11(outDir, LOCK_FILE);
+  const lockData = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  try {
+    const fd = await open(lockPath, "wx");
+    await fd.writeFile(`${JSON.stringify(lockData, null, 2)}
+`, "utf8");
+    await fd.close();
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      try {
+        const raw = await readFile2(lockPath, "utf8");
+        const existing = JSON.parse(raw);
+        if (isProcessAlive(existing.pid)) return null;
+        await unlink(lockPath);
+        return acquireLock(outDir);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return {
+    release: async () => {
+      try {
+        await unlink(lockPath);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/watch/watcher.ts
+var PAGES_DEBOUNCE_MS = 150;
+var NO_OP_WATCHER = { close: async () => {
+} };
+async function watch(config, onChange) {
+  const lock = await acquireLock(config.codegen.outDir);
+  if (lock === null) {
+    let holderPid = "unknown";
+    try {
+      const raw = await readFile3(join12(config.codegen.outDir, ".watcher.lock"), "utf8");
+      const data = JSON.parse(raw);
+      if (data.pid !== void 0) holderPid = String(data.pid);
+    } catch {
+    }
+    console.warn(
+      `[nestjs-codegen] auto-watch skipped \u2014 another process (PID ${holderPid}) is already running the watcher in ${config.codegen.outDir}. Files will continue to regenerate from that process. To take over, stop the other watcher.`
+    );
+    return NO_OP_WATCHER;
+  }
+  try {
+    const initialRoutes = await discoverContractsFast({
+      cwd: config.codegen.cwd,
+      glob: config.contracts.glob,
+      ...config.app?.tsconfig ? { tsconfig: config.app.tsconfig } : {}
+    });
+    await generate(config, initialRoutes);
+  } catch (err) {
+    console.warn(
+      `[nestjs-codegen] Initial route discovery failed, falling back to pages-only: ${err instanceof Error ? err.message : String(err)}`
+    );
+    try {
+      await generate(config);
+    } catch {
+    }
+  }
+  let pagesDebounceTimer;
+  const pagesGlob = config.pages?.glob ?? ".nestjs-codegen-no-pages";
+  const pagesWatcher = chokidar.watch(join12(config.codegen.cwd, pagesGlob), {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
+  });
+  function schedulePagesRegenerate() {
+    if (pagesDebounceTimer !== void 0) {
+      clearTimeout(pagesDebounceTimer);
+    }
+    pagesDebounceTimer = setTimeout(async () => {
+      pagesDebounceTimer = void 0;
+      try {
+        await generate(config);
+      } catch (err) {
+        console.error(
+          "[nestjs-codegen] Pages generation failed:",
+          err instanceof Error ? err.message : err
+        );
+      }
+      onChange?.();
+    }, PAGES_DEBOUNCE_MS);
+  }
+  pagesWatcher.on("add", schedulePagesRegenerate);
+  pagesWatcher.on("change", schedulePagesRegenerate);
+  pagesWatcher.on("unlink", schedulePagesRegenerate);
+  let contractsDebounceTimer;
+  const contractsWatcher = chokidar.watch(join12(config.codegen.cwd, config.contracts.glob), {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
+  });
+  function scheduleContractsRegenerate() {
+    if (contractsDebounceTimer !== void 0) {
+      clearTimeout(contractsDebounceTimer);
+    }
+    contractsDebounceTimer = setTimeout(async () => {
+      contractsDebounceTimer = void 0;
+      try {
+        const routes = await discoverContractsFast({
+          cwd: config.codegen.cwd,
+          glob: config.contracts.glob,
+          ...config.app?.tsconfig ? { tsconfig: config.app.tsconfig } : {}
+        });
+        await generate(config, routes);
+      } catch (err) {
+        console.error(
+          "[nestjs-codegen] Contracts generation failed:",
+          err instanceof Error ? err.message : err
+        );
+      }
+      onChange?.();
+    }, config.contracts.debounceMs);
+  }
+  contractsWatcher.on("add", scheduleContractsRegenerate);
+  contractsWatcher.on("change", scheduleContractsRegenerate);
+  contractsWatcher.on("unlink", scheduleContractsRegenerate);
+  const formsWatcher = chokidar.watch(join12(config.codegen.cwd, config.forms.watch), {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
+  });
+  formsWatcher.on("add", scheduleContractsRegenerate);
+  formsWatcher.on("change", scheduleContractsRegenerate);
+  formsWatcher.on("unlink", scheduleContractsRegenerate);
+  return {
+    close: async () => {
+      if (pagesDebounceTimer !== void 0) {
+        clearTimeout(pagesDebounceTimer);
+        pagesDebounceTimer = void 0;
+      }
+      if (contractsDebounceTimer !== void 0) {
+        clearTimeout(contractsDebounceTimer);
+        contractsDebounceTimer = void 0;
+      }
+      await pagesWatcher.close();
+      await contractsWatcher.close();
+      await formsWatcher.close();
+      await lock.release();
+    }
+  };
+}
+
+// src/nest/module.ts
+var CODEGEN_MODULE_OPTIONS = Symbol("NESTJS_CODEGEN_MODULE_OPTIONS");
+function shouldRun(options, env) {
+  if (options.enabled !== void 0) return options.enabled;
+  return env !== "production";
+}
+var NestjsCodegenService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  logger = new Logger("NestjsCodegen");
+  watcher = null;
+  async onApplicationBootstrap() {
+    if (!shouldRun(this.options, process.env.NODE_ENV)) return;
+    const { enabled: _enabled, cwd, ...userConfig } = this.options;
+    try {
+      const config = resolveConfig(userConfig, cwd ?? process.cwd());
+      this.watcher = await watch(config);
+      this.logger.log(`Watching ${config.contracts.glob} \u2192 ${config.codegen.outDir}`);
+    } catch (err) {
+      this.logger.warn(
+        `Codegen watcher failed to start: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async onModuleDestroy() {
+    await this.watcher?.close();
+    this.watcher = null;
+  }
+};
+NestjsCodegenService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(CODEGEN_MODULE_OPTIONS))
+], NestjsCodegenService);
+var NestjsCodegenModule = class {
+  static forRoot(options = {}) {
+    return {
+      module: NestjsCodegenModule,
+      providers: [{ provide: CODEGEN_MODULE_OPTIONS, useValue: options }, NestjsCodegenService]
+    };
+  }
+};
+NestjsCodegenModule = __decorateClass([
+  Module({})
+], NestjsCodegenModule);
+export {
+  CODEGEN_MODULE_OPTIONS,
+  NestjsCodegenModule,
+  NestjsCodegenService,
+  shouldRun
+};
+//# sourceMappingURL=index.js.map