@dudousxd/nestjs-codegen 0.29.0 → 0.30.0

package/dist/cli/main.js

@@ -100,11 +100,6 @@ function validateUserConfig(userConfig) {
       );
     }
   }
-  if (userConfig.scopes && Object.keys(userConfig.scopes).length > 0) {
-    console.warn(
-      "[nestjs-codegen] The top-level `scopes` option has no effect and is deprecated. For several Inertia apps use `pages.scopes` (one entry per InertiaModule.forFeature scope); for several controller sets use one `contracts.glob` (e.g. a brace glob)."
-    );
-  }
 }
 function isGlobInput(value) {
   if (typeof value === "string") return true;
@@ -152,7 +147,6 @@ function applyDefaults(userConfig, cwd) {
       glob: userConfig.contracts?.glob ?? "src/**/*.controller.ts",
       debounceMs: userConfig.contracts?.debounceMs ?? 500
     },
-    scopes: userConfig.scopes ?? {},
     codegen: {
       outDir,
       cwd: resolvedCwd
@@ -247,7 +241,7 @@ async function discoverPages(opts) {
       const rel = relative2(opts.cwd, file);
       const nameRel = relative2(pagesBase, file).split(sep2).join("/");
       const name = `${prefix}${computeName(nameRel, opts.componentNameStrategy)}`;
-      const source = await readFile(file, "utf8");
+      const source = await (opts.read ? opts.read(file) : readFile(file, "utf8"));
       const propsSource = extractPropsSource(source, opts.propsExport);
       out.push({ name, absolutePath: file, relativePath: rel, propsSource, scope });
     }
@@ -255,10 +249,14 @@ async function discoverPages(opts) {
   assertUniqueNames(out);
   return out;
 }
-async function discoverPageScopes(config) {
+async function discoverPageScopes(config, read) {
   const pages = config.pages;
   if (!pages) return [];
-  const common = { cwd: config.codegen.cwd, propsExport: pages.propsExport };
+  const common = {
+    cwd: config.codegen.cwd,
+    propsExport: pages.propsExport,
+    ...read ? { read } : {}
+  };
   const out = await discoverPages({
     ...common,
     glob: pages.glob,
@@ -329,305 +327,69 @@ function extractPropsSource(source, exportName) {
 }
 
 // src/discovery/shared-props.ts
-import { join as join3 } from "path";
-import { Node, Project, SyntaxKind } from "ts-morph";
-function discoverSharedProps(project, moduleEntry) {
-  try {
-    let sourceFile = project.getSourceFile(moduleEntry);
-    if (!sourceFile) {
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { Node as Node11, Project as Project4, SyntaxKind as SyntaxKind4 } from "ts-morph";
+
+// src/discovery/contracts-fast.ts
+import { existsSync } from "fs";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+import fg2 from "fast-glob";
+import {
+  FileSystemRefreshResult as FileSystemRefreshResult3,
+  Node as Node10,
+  Project as Project3,
+  ts as ts4
+} from "ts-morph";
+
+// src/discovery/disk-fingerprints.ts
+import { readFileSync, statSync } from "fs";
+var DiskFingerprints = class {
+  stats = /* @__PURE__ */ new Map();
+  /** The paths whose disk content differs from `text`, or that no longer exist. */
+  changed(files) {
+    const changed = [];
+    for (const { path, text } of files) {
+      let key;
       try {
-        sourceFile = project.addSourceFileAtPath(moduleEntry);
+        const stat2 = statSync(path);
+        key = `${stat2.mtimeMs}:${stat2.size}`;
       } 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 discoverSharedPropsFromConfig(config) {
-  if (!config.app?.moduleEntry) return null;
-  try {
-    const tsconfigPath = config.app.tsconfig ?? join3(config.codegen.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, strict: false }
-      });
-    }
-    return discoverSharedProps(project, config.app.moduleEntry);
-  } catch {
-    return null;
-  }
-}
-function findForRootCall(sourceFile) {
-  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
-  for (const call of callExpressions) {
-    const expr = call.getExpression();
-    if (!Node.isPropertyAccessExpression(expr)) continue;
-    const methodName = expr.getName();
-    const objectExpr = expr.getExpression();
-    if (methodName === "forRoot" && Node.isIdentifier(objectExpr)) {
-      const name = objectExpr.getText();
-      if (name === "InertiaModule") {
-        return call;
-      }
-    }
-  }
-  return null;
-}
-function findShareInitializer(forRootCall) {
-  if (!Node.isCallExpression(forRootCall)) return null;
-  const args = forRootCall.getArguments();
-  const firstArg2 = args[0];
-  if (!firstArg2 || !Node.isObjectLiteralExpression(firstArg2)) return null;
-  for (const prop of firstArg2.getProperties()) {
-    if (Node.isPropertyAssignment(prop) && prop.getName() === "share") {
-      return prop.getInitializer() ?? null;
-    }
-  }
-  return null;
-}
-function extractShareType(node, sourceFile, project) {
-  if (Node.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 (Node.isArrowFunction(node)) {
-    const result = extractFromFunctionLike(node, sourceFile);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  if (Node.isFunctionExpression(node)) {
-    const result = extractFromFunctionLike(node, sourceFile);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  if (Node.isObjectLiteralExpression(node)) {
-    const result = extractFromObjectLiteral(node);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  return null;
-}
-function resolveIdentifierToImportRef(id, sourceFile, project) {
-  if (!Node.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 = Node.isArrowFunction(node) || Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
-  if (returnTypeNode) {
-    return extractFromReturnTypeAnnotation(returnTypeNode);
-  }
-  if (Node.isArrowFunction(node)) {
-    const body = node.getBody();
-    if (Node.isParenthesizedExpression(body)) {
-      const inner = body.getExpression();
-      if (Node.isObjectLiteralExpression(inner)) {
-        return extractFromObjectLiteral(inner);
-      }
-    }
-    if (Node.isObjectLiteralExpression(body)) {
-      return extractFromObjectLiteral(body);
-    }
-    if (Node.isBlock(body)) {
-      return extractFromBlockReturn(body);
-    }
-  }
-  if (Node.isFunctionExpression(node)) {
-    const body = node.getBody();
-    if (Node.isBlock(body)) {
-      return extractFromBlockReturn(body);
-    }
-  }
-  return null;
-}
-function extractFromReturnTypeAnnotation(typeNode) {
-  if (Node.isTypeReference(typeNode)) {
-    const typeName = typeNode.getTypeName();
-    if (Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
-      const typeArgs = typeNode.getTypeArguments();
-      const firstArg2 = typeArgs[0];
-      if (firstArg2) {
-        return extractFromReturnTypeAnnotation(firstArg2);
+        this.stats.delete(path);
+        changed.push(path);
+        continue;
       }
-      return null;
-    }
-  }
-  if (Node.isTypeLiteral(typeNode)) {
-    const properties = [];
-    for (const member of typeNode.getMembers()) {
-      if (Node.isPropertySignature(member)) {
-        const name = member.getName();
-        const memberTypeNode = member.getTypeNode();
-        const type = memberTypeNode ? memberTypeNode.getText() : "unknown";
-        properties.push({ name, type });
+      if (this.stats.get(path) === key) continue;
+      let disk;
+      try {
+        disk = readFileSync(path, "utf-8");
+      } catch {
+        disk = void 0;
       }
-    }
-    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 (!Node.isBlock(block)) return null;
-  const statements = block.getStatements();
-  for (let i = statements.length - 1; i >= 0; i--) {
-    const stmt = statements[i];
-    if (!Node.isReturnStatement(stmt)) continue;
-    const expr = stmt.getExpression();
-    if (!expr) continue;
-    if (Node.isObjectLiteralExpression(expr)) {
-      return extractFromObjectLiteral(expr);
-    }
-    if (Node.isParenthesizedExpression(expr)) {
-      const inner = expr.getExpression();
-      if (Node.isObjectLiteralExpression(inner)) {
-        return extractFromObjectLiteral(inner);
+      if (disk === text) {
+        this.stats.set(path, key);
+      } else {
+        this.stats.delete(path);
+        changed.push(path);
       }
     }
-    break;
-  }
-  return null;
-}
-function extractFromObjectLiteral(objLiteral) {
-  if (!Node.isObjectLiteralExpression(objLiteral)) return null;
-  const properties = [];
-  for (const prop of objLiteral.getProperties()) {
-    if (!Node.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 (Node.isStringLiteral(node)) return "string";
-  if (Node.isTemplateExpression(node) || Node.isNoSubstitutionTemplateLiteral(node))
-    return "string";
-  if (Node.isNumericLiteral(node)) return "number";
-  if (node.getKind() === SyntaxKind.TrueKeyword || node.getKind() === SyntaxKind.FalseKeyword) {
-    return "boolean";
-  }
-  if (node.getKind() === SyntaxKind.NullKeyword) return "null";
-  if (Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
-  if (Node.isObjectLiteralExpression(node)) {
-    const props = node.getProperties();
-    if (props.length === 0) return "Record<string, unknown>";
-    const entries = [];
-    for (const prop of props) {
-      if (!Node.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("; ")} }`;
+    return changed;
   }
-  if (Node.isArrayLiteralExpression(node)) {
-    const elements = node.getElements();
-    if (elements.length === 0) return "Array<unknown>";
-    const first = elements[0];
-    if (first) return `Array<${inferExpressionType(first)}>`;
-    return "Array<unknown>";
-  }
-  if (Node.isConditionalExpression(node)) {
-    const whenTrue = inferExpressionType(node.getWhenTrue());
-    const whenFalse = inferExpressionType(node.getWhenFalse());
-    if (whenTrue === whenFalse) return whenTrue;
-    return `${whenTrue} | ${whenFalse}`;
-  }
-  if (Node.isParenthesizedExpression(node)) {
-    return inferExpressionType(node.getExpression());
-  }
-  if (Node.isAsExpression(node)) {
-    const typeNode = node.getTypeNode();
-    if (typeNode) return typeNode.getText();
+  /** Forget `path`, so its next check compares content again. */
+  forget(path) {
+    this.stats.delete(path);
   }
-  return "unknown";
-}
-
-// src/emit/emit-api.ts
-import { mkdir, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5, relative as relative4 } from "path";
-
-// src/extension/registry.ts
-import { relative as relative3, resolve as resolve4 } from "path";
-import { Project as Project5 } from "ts-morph";
-
-// src/discovery/contracts-fast.ts
-import { existsSync } from "fs";
-import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
-import fg2 from "fast-glob";
-import {
-  Node as Node11,
-  Project as Project4,
-  ts as ts3
-} from "ts-morph";
+};
 
 // src/discovery/dto-type-resolver.ts
 import {
-  Node as Node10,
-  SyntaxKind as SyntaxKind4
+  Node as Node9,
+  SyntaxKind as SyntaxKind3
 } from "ts-morph";
 
 // src/discovery/dto-to-ir.ts
 import {
-  Node as Node3
+  Node as Node2
 } from "ts-morph";
 
 // src/util/debug-log.ts
@@ -642,7 +404,7 @@ function debugWarn(message) {
 // src/discovery/type-ref-resolution.ts
 import { dirname, resolve as resolve2 } from "path";
 import {
-  Node as Node2
+  Node
 } from "ts-morph";
 var _EMPTY_CTX = { projectRoot: "", tsconfigPaths: null };
 var _ctxByProject = /* @__PURE__ */ new WeakMap();
@@ -908,13 +670,13 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     name = nodeOrName;
   } else {
     const typeNode = nodeOrName;
-    if (opts.unwrapContainers && Node2.isArrayTypeNode(typeNode)) {
+    if (opts.unwrapContainers && Node.isArrayTypeNode(typeNode)) {
       const inner = resolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project, opts);
       return inner ? { ...inner, isArray: true } : null;
     }
-    if (!Node2.isTypeReference(typeNode)) return null;
+    if (!Node.isTypeReference(typeNode)) return null;
     const typeName = typeNode.getTypeName();
-    const refName = Node2.isIdentifier(typeName) ? typeName.getText() : null;
+    const refName = Node.isIdentifier(typeName) ? typeName.getText() : null;
     if (!refName) return null;
     if (opts.unwrapContainers && refName === "Promise") {
       const first = typeNode.getTypeArguments()[0];
@@ -1048,7 +810,7 @@ function buildProperty(prop, classFile, ctx) {
   const dec = (n) => decorators.get(n);
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && Node3.isArrayTypeNode(typeNode);
+  const isArrayType = !!typeNode && Node2.isArrayTypeNode(typeNode);
   const asField = (child) => applyPresence(
     has("IsArray") || isArrayType ? { kind: "array", element: child } : child,
     decorators
@@ -1262,22 +1024,22 @@ function firstArgText(decorator) {
 }
 function numericArg(decorator) {
   const arg = firstArg(decorator);
-  if (arg && Node3.isNumericLiteral(arg)) return arg.getText();
+  if (arg && Node2.isNumericLiteral(arg)) return arg.getText();
   return null;
 }
 function numericArgs(decorator) {
   const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && Node3.isNumericLiteral(n) ? n.getText() : null;
+  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 (Node3.isObjectLiteralExpression(arg)) {
+    if (Node2.isObjectLiteralExpression(arg)) {
       for (const prop of arg.getProperties()) {
-        if (Node3.isPropertyAssignment(prop) && prop.getName() === "message") {
+        if (Node2.isPropertyAssignment(prop) && prop.getName() === "message") {
           const init = prop.getInitializer();
-          if (init && Node3.isStringLiteral(init)) return init.getText();
+          if (init && Node2.isStringLiteral(init)) return init.getText();
         }
       }
     }
@@ -1286,30 +1048,30 @@ function messageRaw(decorator) {
 }
 function resolveDiscriminator(decorator) {
   const optsArg = decorator?.getArguments()[1];
-  if (!optsArg || !Node3.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node2.isObjectLiteralExpression(optsArg)) return null;
   let discProp;
   for (const prop of optsArg.getProperties()) {
-    if (Node3.isPropertyAssignment(prop) && prop.getName() === "discriminator") {
+    if (Node2.isPropertyAssignment(prop) && prop.getName() === "discriminator") {
       discProp = prop.getInitializer();
     }
   }
-  if (!discProp || !Node3.isObjectLiteralExpression(discProp)) return null;
+  if (!discProp || !Node2.isObjectLiteralExpression(discProp)) return null;
   let property = null;
   const subTypes = [];
   for (const prop of discProp.getProperties()) {
-    if (!Node3.isPropertyAssignment(prop)) continue;
+    if (!Node2.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
     const init = prop.getInitializer();
     if (!init) continue;
-    if (name === "property" && Node3.isStringLiteral(init)) {
+    if (name === "property" && Node2.isStringLiteral(init)) {
       property = init.getLiteralValue();
-    } else if (name === "subTypes" && Node3.isArrayLiteralExpression(init)) {
+    } else if (name === "subTypes" && Node2.isArrayLiteralExpression(init)) {
       for (const el of init.getElements()) {
-        if (!Node3.isObjectLiteralExpression(el)) continue;
+        if (!Node2.isObjectLiteralExpression(el)) continue;
         for (const p of el.getProperties()) {
-          if (!Node3.isPropertyAssignment(p) || p.getName() !== "name") continue;
+          if (!Node2.isPropertyAssignment(p) || p.getName() !== "name") continue;
           const nameInit = p.getInitializer();
-          if (nameInit && Node3.isIdentifier(nameInit)) subTypes.push(nameInit.getText());
+          if (nameInit && Node2.isIdentifier(nameInit)) subTypes.push(nameInit.getText());
         }
       }
     }
@@ -1320,9 +1082,9 @@ function resolveDiscriminator(decorator) {
 function resolveTypeFactoryName(decorator) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (Node3.isArrowFunction(arg)) {
+  if (Node2.isArrowFunction(arg)) {
     const body = arg.getBody();
-    if (Node3.isIdentifier(body)) return body.getText();
+    if (Node2.isIdentifier(body)) return body.getText();
   }
   return null;
 }
@@ -1331,12 +1093,12 @@ function singularClassName(typeText) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(inner) ? inner : null;
 }
 function genericTypeArgNames(typeNode) {
-  if (!typeNode || !Node3.isTypeReference(typeNode)) return [];
+  if (!typeNode || !Node2.isTypeReference(typeNode)) return [];
   const names = [];
   for (const arg of typeNode.getTypeArguments()) {
-    if (!Node3.isTypeReference(arg)) return [];
+    if (!Node2.isTypeReference(arg)) return [];
     const tn = arg.getTypeName();
-    if (!Node3.isIdentifier(tn)) return [];
+    if (!Node2.isIdentifier(tn)) return [];
     names.push(tn.getText());
   }
   return names;
@@ -1344,7 +1106,7 @@ function genericTypeArgNames(typeNode) {
 function enumSchemaFromDecorator(decorator, classFile, ctx) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (Node3.isIdentifier(arg)) {
+  if (Node2.isIdentifier(arg)) {
     const name = arg.getText();
     const resolved = findType(name, classFile, ctx.project);
     if (resolved && resolved.kind === "enum") {
@@ -1358,12 +1120,12 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
     }
     return { kind: "unknown", note: `@IsEnum(${name}): enum not resolvable to literals` };
   }
-  if (Node3.isObjectLiteralExpression(arg)) {
+  if (Node2.isObjectLiteralExpression(arg)) {
     const values = [];
     for (const p of arg.getProperties()) {
-      if (!Node3.isPropertyAssignment(p)) continue;
+      if (!Node2.isPropertyAssignment(p)) continue;
       const init = p.getInitializer();
-      if (init && Node3.isStringLiteral(init)) values.push(init.getText());
+      if (init && Node2.isStringLiteral(init)) values.push(init.getText());
     }
     if (values.length > 0) return { kind: "enum", literals: values };
   }
@@ -1371,9 +1133,9 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
 }
 function inSchemaFromDecorator(decorator) {
   const arg = firstArg(decorator);
-  if (arg && Node3.isArrayLiteralExpression(arg)) {
+  if (arg && Node2.isArrayLiteralExpression(arg)) {
     const elements = arg.getElements();
-    const allStrings = elements.every((e) => Node3.isStringLiteral(e));
+    const allStrings = elements.every((e) => Node2.isStringLiteral(e));
     if (allStrings && elements.length > 0) {
       return { kind: "enum", literals: elements.map((e) => e.getText()) };
     }
@@ -1389,13 +1151,13 @@ function inSchemaFromDecorator(decorator) {
 
 // src/discovery/filter-for.ts
 import {
-  Node as Node6
+  Node as Node5
 } from "ts-morph";
 
 // src/discovery/filter-field-types.ts
 import {
-  Node as Node4,
-  SyntaxKind as SyntaxKind2
+  Node as Node3,
+  SyntaxKind
 } from "ts-morph";
 
 // src/discovery/enum-resolution.ts
@@ -1449,28 +1211,28 @@ function markNullable(r, nullable) {
 }
 var TRANSPARENT_TYPE_BRANDS = /* @__PURE__ */ new Set(["Opt", "Hidden"]);
 function classifyTypeNode(typeNode, sourceFile, project, opts) {
-  if (Node4.isUnionTypeNode(typeNode)) {
+  if (Node3.isUnionTypeNode(typeNode)) {
     let nullable = false;
     const stringLits = [];
     const numberLits = [];
     const others = [];
     for (const member of typeNode.getTypeNodes()) {
       const kind = member.getKind();
-      if (kind === SyntaxKind2.NullKeyword || kind === SyntaxKind2.UndefinedKeyword) {
+      if (kind === SyntaxKind.NullKeyword || kind === SyntaxKind.UndefinedKeyword) {
         nullable = true;
         continue;
       }
-      if (Node4.isLiteralTypeNode(member)) {
+      if (Node3.isLiteralTypeNode(member)) {
         const lit = member.getLiteral();
-        if (Node4.isStringLiteral(lit)) {
+        if (Node3.isStringLiteral(lit)) {
           stringLits.push(lit.getLiteralValue());
           continue;
         }
-        if (Node4.isNumericLiteral(lit)) {
+        if (Node3.isNumericLiteral(lit)) {
           numberLits.push(lit.getText());
           continue;
         }
-        if (lit.getKind() === SyntaxKind2.NullKeyword) {
+        if (lit.getKind() === SyntaxKind.NullKeyword) {
           nullable = true;
           continue;
         }
@@ -1490,19 +1252,19 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     return markNullable({ kind: "unknown" }, nullable);
   }
   switch (typeNode.getKind()) {
-    case SyntaxKind2.StringKeyword:
+    case SyntaxKind.StringKeyword:
       return { kind: "string" };
-    case SyntaxKind2.NumberKeyword:
+    case SyntaxKind.NumberKeyword:
       return { kind: "number" };
-    case SyntaxKind2.BooleanKeyword:
+    case SyntaxKind.BooleanKeyword:
       return { kind: "boolean" };
-    case SyntaxKind2.AnyKeyword:
-    case SyntaxKind2.UnknownKeyword:
+    case SyntaxKind.AnyKeyword:
+    case SyntaxKind.UnknownKeyword:
       return { kind: "unknown" };
     default:
       break;
   }
-  if (Node4.isTypeReference(typeNode)) {
+  if (Node3.isTypeReference(typeNode)) {
     const refName = typeNode.getTypeName().getText();
     if (refName === "Date") return { kind: "date" };
     if (refName === "Record" || refName === "Object") return { kind: "json" };
@@ -1520,25 +1282,25 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     if (typeRef) return { kind: "unknown", typeRef };
     return { kind: "unknown" };
   }
-  if (Node4.isTypeLiteral(typeNode)) return { kind: "json" };
+  if (Node3.isTypeLiteral(typeNode)) return { kind: "json" };
   return { kind: "unknown" };
 }
 function enumFromDecoratorArgs(args, sourceFile, project) {
   for (const arg of args) {
-    if (Node4.isArrowFunction(arg)) {
+    if (Node3.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (Node4.isIdentifier(body)) {
+      if (Node3.isIdentifier(body)) {
         const en = resolveEnumValues(body.getText(), sourceFile, project);
         if (en) return en;
       }
     }
-    if (Node4.isObjectLiteralExpression(arg)) {
+    if (Node3.isObjectLiteralExpression(arg)) {
       const itemsProp = arg.getProperty("items");
-      if (itemsProp && Node4.isPropertyAssignment(itemsProp)) {
+      if (itemsProp && Node3.isPropertyAssignment(itemsProp)) {
         const init = itemsProp.getInitializer();
-        if (init && Node4.isArrowFunction(init)) {
+        if (init && Node3.isArrowFunction(init)) {
           const body = init.getBody();
-          if (Node4.isIdentifier(body)) {
+          if (Node3.isIdentifier(body)) {
             const en = resolveEnumValues(body.getText(), sourceFile, project);
             if (en) return en;
           }
@@ -1561,7 +1323,7 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
       return { kind: "string" };
     }
     for (const arg of args) {
-      if (Node4.isStringLiteral(arg)) {
+      if (Node3.isStringLiteral(arg)) {
         const raw = arg.getLiteralValue();
         const kind = classifyTypeKeyword(raw);
         if (kind) {
@@ -1569,11 +1331,11 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           return { kind };
         }
       }
-      if (Node4.isObjectLiteralExpression(arg)) {
+      if (Node3.isObjectLiteralExpression(arg)) {
         const enumProp = arg.getProperty("enum");
-        if (enumProp && Node4.isPropertyAssignment(enumProp)) {
+        if (enumProp && Node3.isPropertyAssignment(enumProp)) {
           const init = enumProp.getInitializer();
-          if (init && Node4.isIdentifier(init)) {
+          if (init && Node3.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 };
@@ -1583,15 +1345,15 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
         }
         for (const key of ["columnType", "type"]) {
           const typeProp = arg.getProperty(key);
-          if (!typeProp || !Node4.isPropertyAssignment(typeProp)) continue;
+          if (!typeProp || !Node3.isPropertyAssignment(typeProp)) continue;
           const init = typeProp.getInitializer();
           if (!init) continue;
-          if (Node4.isStringLiteral(init)) {
+          if (Node3.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
             continue;
           }
-          if (Node4.isIdentifier(init)) {
+          if (Node3.isIdentifier(init)) {
             const kind = classifyTypeKeyword(init.getText());
             if (kind) return { kind };
           }
@@ -1633,23 +1395,70 @@ function toFilterFieldType(name, r) {
 }
 
 // src/discovery/heritage.ts
-import { Node as Node5, Project as Project2 } from "ts-morph";
+import {
+  FileSystemRefreshResult,
+  Node as Node4,
+  Project
+} from "ts-morph";
+
+// src/discovery/unresolved-imports.ts
+import { ts } from "ts-morph";
+var UnresolvedImports = class {
+  read;
+  /**
+   * The files with an import that failed to resolve in `program` and now resolves
+   * to a TypeScript file the program does not hold.
+   */
+  nowResolving(program) {
+    if (this.read?.program !== program) {
+      this.read = { program, imports: failedImports(program) };
+    }
+    const options = program.getCompilerOptions();
+    const files = /* @__PURE__ */ new Set();
+    for (const { specifier, from } of this.read.imports) {
+      const file = ts.resolveModuleName(specifier, from, options, ts.sys).resolvedModule?.resolvedFileName;
+      if (file !== void 0 && /\.(m|c)?tsx?$/.test(file) && !program.getSourceFile(file)) {
+        files.add(from);
+      }
+    }
+    return [...files];
+  }
+};
+function failedImports(program) {
+  const checker = program.getTypeChecker();
+  const imports = [];
+  for (const file of program.getSourceFiles()) {
+    if (program.isSourceFileDefaultLibrary(file) || file.isDeclarationFile) continue;
+    if (program.isSourceFileFromExternalLibrary(file)) continue;
+    for (const statement of file.statements) {
+      if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement)) continue;
+      const specifier = statement.moduleSpecifier;
+      if (!specifier || !ts.isStringLiteral(specifier)) continue;
+      if (!checker.getSymbolAtLocation(specifier)) {
+        imports.push({ specifier: specifier.text, from: file.fileName });
+      }
+    }
+  }
+  return imports;
+}
+
+// src/discovery/heritage.ts
 function resolveHeritageCall(node) {
   if (!node) return void 0;
   const expr = unwrapExpression(node);
-  if (Node5.isCallExpression(expr)) return expr;
-  if (!Node5.isIdentifier(expr)) return void 0;
+  if (Node4.isCallExpression(expr)) return expr;
+  if (!Node4.isIdentifier(expr)) return void 0;
   const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find(
-    (n) => n !== void 0 && Node5.isVariableDeclaration(n)
+    (n) => n !== void 0 && Node4.isVariableDeclaration(n)
   );
   const init = decl?.getInitializer();
   if (!init) return void 0;
   const unwrapped = unwrapExpression(init);
-  return Node5.isCallExpression(unwrapped) ? unwrapped : void 0;
+  return Node4.isCallExpression(unwrapped) ? unwrapped : void 0;
 }
 function unwrapExpression(node) {
   let current = node;
-  while (Node5.isAsExpression(current) || Node5.isSatisfiesExpression(current) || Node5.isParenthesizedExpression(current) || Node5.isTypeAssertion(current)) {
+  while (Node4.isAsExpression(current) || Node4.isSatisfiesExpression(current) || Node4.isParenthesizedExpression(current) || Node4.isTypeAssertion(current)) {
     current = current.getExpression();
   }
   return current;
@@ -1657,17 +1466,17 @@ function unwrapExpression(node) {
 function resolveReturnedClass(factoryDecl) {
   const body = factoryDecl.getBody();
   if (!body) return void 0;
-  const returns = body.getDescendants().filter((n) => Node5.isReturnStatement(n));
+  const returns = body.getDescendants().filter((n) => Node4.isReturnStatement(n));
   for (const ret of returns) {
     const expr = ret.getExpression();
     if (!expr) continue;
     const inner = unwrapExpression(expr);
-    if (Node5.isClassExpression(inner)) {
+    if (Node4.isClassExpression(inner)) {
       return inner;
     }
-    if (Node5.isIdentifier(inner)) {
+    if (Node4.isIdentifier(inner)) {
       const name = inner.getText();
-      const decl = body.getDescendants().find((n) => Node5.isClassDeclaration(n) && n.getName() === name);
+      const decl = body.getDescendants().find((n) => Node4.isClassDeclaration(n) && n.getName() === name);
       if (decl) return decl;
     }
   }
@@ -1675,10 +1484,10 @@ function resolveReturnedClass(factoryDecl) {
 }
 function factoryCalleeName(call) {
   const callee = unwrapExpression(call.getExpression());
-  if (Node5.isIdentifier(callee)) return callee;
-  if (Node5.isPropertyAccessExpression(callee)) {
+  if (Node4.isIdentifier(callee)) return callee;
+  if (Node4.isPropertyAccessExpression(callee)) {
     const name = callee.getNameNode();
-    return Node5.isIdentifier(name) ? name : void 0;
+    return Node4.isIdentifier(name) ? name : void 0;
   }
   return void 0;
 }
@@ -1691,19 +1500,19 @@ function resolveFactoryFromName(name, seen) {
   seen.add(name);
   const decls = name.getDefinitions().map((d) => d.getDeclarationNode()).filter((n) => n !== void 0);
   for (const decl of decls) {
-    if (Node5.isFunctionDeclaration(decl) || Node5.isMethodDeclaration(decl)) return decl;
-    if (Node5.isPropertyAssignment(decl)) {
+    if (Node4.isFunctionDeclaration(decl) || Node4.isMethodDeclaration(decl)) return decl;
+    if (Node4.isPropertyAssignment(decl)) {
       const init = decl.getInitializer();
       const inner = init ? unwrapExpression(init) : void 0;
-      if (inner && Node5.isIdentifier(inner)) {
+      if (inner && Node4.isIdentifier(inner)) {
         const resolved = resolveFactoryFromName(inner, seen);
         if (resolved) return resolved;
       }
       continue;
     }
-    if (Node5.isShorthandPropertyAssignment(decl)) {
+    if (Node4.isShorthandPropertyAssignment(decl)) {
       const nameNode = decl.getNameNode();
-      const resolved = Node5.isIdentifier(nameNode) ? resolveFactoryFromName(nameNode, seen) : void 0;
+      const resolved = Node4.isIdentifier(nameNode) ? resolveFactoryFromName(nameNode, seen) : void 0;
       if (resolved) return resolved;
     }
   }
@@ -1715,7 +1524,7 @@ function warnUnresolvedFactory(cls, calleeText, reason) {
   );
 }
 function resolveFactoryStaticClass(node) {
-  if (!Node5.isPropertyAccessExpression(node)) return void 0;
+  if (!Node4.isPropertyAccessExpression(node)) return void 0;
   const call = resolveHeritageCall(node.getExpression());
   if (!call) return void 0;
   const factoryDecl = resolveFactoryDeclaration(call);
@@ -1723,13 +1532,13 @@ function resolveFactoryStaticClass(node) {
   const returnedClass = resolveReturnedClass(factoryDecl);
   if (!returnedClass) return void 0;
   const staticProp = returnedClass.getStaticProperties().find((p) => p.getName() === node.getName());
-  if (!staticProp || !Node5.isPropertyDeclaration(staticProp)) return void 0;
+  if (!staticProp || !Node4.isPropertyDeclaration(staticProp)) return void 0;
   const init = staticProp.getInitializer();
   if (!init) return void 0;
   const inner = unwrapExpression(init);
-  if (Node5.isClassExpression(inner)) return inner;
-  if (!Node5.isIdentifier(inner)) return void 0;
-  return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node5.isClassDeclaration(n));
+  if (Node4.isClassExpression(inner)) return inner;
+  if (!Node4.isIdentifier(inner)) return void 0;
+  return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node4.isClassDeclaration(n));
 }
 function resolveBaseClass(cls) {
   const heritage = cls.getExtends()?.getExpression();
@@ -1740,8 +1549,8 @@ function resolveBaseClass(cls) {
     return factoryDecl ? resolveReturnedClass(factoryDecl) : void 0;
   }
   const expr = unwrapExpression(heritage);
-  if (!Node5.isIdentifier(expr)) return void 0;
-  return expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node5.isClassDeclaration(n));
+  if (!Node4.isIdentifier(expr)) return void 0;
+  return expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node4.isClassDeclaration(n));
 }
 function collectMethodsThroughChain(returnedClass) {
   const byName = /* @__PURE__ */ new Map();
@@ -1788,7 +1597,7 @@ function resolveInheritedMethods(cls) {
       classArgs.push(positional);
       continue;
     }
-    if (!Node5.isObjectLiteralExpression(arg)) continue;
+    if (!Node4.isObjectLiteralExpression(arg)) continue;
     for (const prop of arg.getProperties()) {
       const named = resolvePropertyClassReference(prop);
       if (!named) continue;
@@ -1810,8 +1619,8 @@ function resolveInheritedMethods(cls) {
 }
 function resolveClassReference(node) {
   const expr = unwrapExpression(node);
-  if (!Node5.isIdentifier(expr)) return void 0;
-  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node5.isClassDeclaration(n));
+  if (!Node4.isIdentifier(expr)) return void 0;
+  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node4.isClassDeclaration(n));
   if (!decl) return void 0;
   return {
     name: decl.getName() ?? expr.getText(),
@@ -1819,29 +1628,56 @@ function resolveClassReference(node) {
   };
 }
 function resolvePropertyClassReference(prop) {
-  if (Node5.isShorthandPropertyAssignment(prop)) {
+  if (Node4.isShorthandPropertyAssignment(prop)) {
     const ref2 = resolveClassReference(prop.getNameNode());
     return ref2 ? { key: prop.getName(), ref: ref2 } : void 0;
   }
-  if (!Node5.isPropertyAssignment(prop)) return void 0;
+  if (!Node4.isPropertyAssignment(prop)) return void 0;
   const init = prop.getInitializer();
   if (!init) return void 0;
   const ref = resolveClassReference(init);
   if (!ref) return void 0;
   const nameNode = prop.getNameNode();
-  const key = Node5.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName();
+  const key = Node4.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName();
   return { key, ref };
 }
 var mixinTypeProject;
+var mixinFiles = new DiskFingerprints();
+var mixinStale = false;
+var mixinUnresolved = new UnresolvedImports();
 function getMixinTypeProject() {
-  mixinTypeProject ??= new Project2({
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: { strict: true }
-  });
+  if (mixinTypeProject && mixinStale && !refreshMixinTypeProject(mixinTypeProject)) {
+    mixinTypeProject = void 0;
+  }
+  mixinStale = false;
+  if (!mixinTypeProject) {
+    mixinTypeProject = new Project({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: { strict: true }
+    });
+    mixinFiles = new DiskFingerprints();
+    mixinUnresolved = new UnresolvedImports();
+  }
   return mixinTypeProject;
 }
 function clearMixinTypeProject() {
   mixinTypeProject = void 0;
+  mixinStale = false;
+}
+function invalidateMixinTypeProject() {
+  mixinStale = true;
+}
+function refreshMixinTypeProject(project) {
+  const program = project.getProgram().compilerObject;
+  const files = program.getSourceFiles().filter((file) => !program.isSourceFileDefaultLibrary(file)).map((file) => ({ path: file.fileName, text: file.text }));
+  const changed = mixinFiles.changed(files);
+  if (changed.length === 0) return mixinUnresolved.nowResolving(program).length === 0;
+  for (const path of changed) {
+    const sf = project.getSourceFile(path);
+    if (sf?.refreshFromFileSystemSync() !== FileSystemRefreshResult.Updated) return false;
+  }
+  project.resolveSourceFileDependencies();
+  return true;
 }
 function resolveInstantiatedReturnType(cls, methodName) {
   const filePath = cls.getSourceFile().getFilePath();
@@ -1872,7 +1708,7 @@ function resolveClassRef(ref, project) {
   return file?.getClass(ref.name);
 }
 function classifyFilterForHint(typeInit) {
-  if (Node6.isStringLiteral(typeInit)) {
+  if (Node5.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -1886,10 +1722,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (Node6.isArrayLiteralExpression(typeInit)) {
+  if (Node5.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!Node6.isStringLiteral(el)) return null;
+      if (!Node5.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -1924,11 +1760,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && Node6.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && Node5.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && Node6.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && Node5.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && Node6.isPropertyAssignment(typeProp)) {
+      if (typeProp && Node5.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -1955,14 +1791,14 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin, controllerCl
     const filterClassArg = args[0];
     if (!filterClassArg) continue;
     const factoryStaticClass = resolveFactoryStaticClass(filterClassArg);
-    if (!factoryStaticClass && !Node6.isIdentifier(filterClassArg)) continue;
+    if (!factoryStaticClass && !Node5.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && Node6.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && Node5.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && Node6.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && Node5.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && Node6.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && Node5.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
@@ -1971,7 +1807,7 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin, controllerCl
     const resolved = factoryStaticClass ? void 0 : findType(filterClassName, declFile, project);
     const declaredClass = factoryStaticClass ?? (resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg));
     const ownRoute = !mixin || (controllerClass ? method.getParent() === controllerClass : declFile.getFilePath() !== mixin.factoryFilePath);
-    const namedByRoute = ownRoute && Node6.isIdentifier(filterClassArg) ? declaredClass : void 0;
+    const namedByRoute = ownRoute && Node5.isIdentifier(filterClassArg) ? declaredClass : void 0;
     for (const candidate of orderFilterCandidates({
       namedByRoute,
       supplied: resolveMixinFilterClass(mixin, project),
@@ -2049,22 +1885,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (Node6.isObjectLiteralExpression(arg)) {
+    if (Node5.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && Node6.isPropertyAssignment(entityProp)) {
+      if (entityProp && Node5.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && Node6.isArrowFunction(init)) {
+        if (init && Node5.isArrowFunction(init)) {
           const body = init.getBody();
-          if (Node6.isIdentifier(body)) {
+          if (Node5.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    if (Node6.isArrowFunction(arg)) {
+    if (Node5.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (Node6.isIdentifier(body)) {
+      if (Node5.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -2083,36 +1919,36 @@ function extractClassPropertyTypes(classDecl, project) {
   return fields;
 }
 function resolveLocalClassDeclaration(identifier) {
-  if (!Node6.isIdentifier(identifier)) return void 0;
-  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node6.isClassDeclaration(n));
+  if (!Node5.isIdentifier(identifier)) return void 0;
+  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && Node5.isClassDeclaration(n));
 }
 function resolveDeclaredEntity(optionsArg, filterClass, project) {
-  if (!Node6.isObjectLiteralExpression(optionsArg)) return void 0;
+  if (!Node5.isObjectLiteralExpression(optionsArg)) return void 0;
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !Node6.isPropertyAssignment(entityProp)) return void 0;
+  if (!entityProp || !Node5.isPropertyAssignment(entityProp)) return void 0;
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !Node6.isIdentifier(entityInit)) return void 0;
+  if (!entityInit || !Node5.isIdentifier(entityInit)) return void 0;
   const resolved = findType(entityInit.getText(), filterClass.getSourceFile(), project);
   if (!resolved || resolved.kind !== "class") return void 0;
   return resolved.decl;
 }
 function readFieldNameList(optionsArg, key) {
-  if (!Node6.isObjectLiteralExpression(optionsArg)) return void 0;
+  if (!Node5.isObjectLiteralExpression(optionsArg)) return void 0;
   const prop = optionsArg.getProperty(key);
-  if (!prop || !Node6.isPropertyAssignment(prop)) return void 0;
+  if (!prop || !Node5.isPropertyAssignment(prop)) return void 0;
   const init = prop.getInitializer();
-  if (!init || !Node6.isArrayLiteralExpression(init)) return void 0;
+  if (!init || !Node5.isArrayLiteralExpression(init)) return void 0;
   const names = /* @__PURE__ */ new Set();
   for (const el of init.getElements()) {
-    if (Node6.isStringLiteral(el)) {
+    if (Node5.isStringLiteral(el)) {
       names.add(el.getLiteralValue());
       continue;
     }
-    if (Node6.isObjectLiteralExpression(el)) {
+    if (Node5.isObjectLiteralExpression(el)) {
       const fieldProp = el.getProperty("field");
-      if (fieldProp && Node6.isPropertyAssignment(fieldProp)) {
+      if (fieldProp && Node5.isPropertyAssignment(fieldProp)) {
         const fieldInit = fieldProp.getInitializer();
-        if (fieldInit && Node6.isStringLiteral(fieldInit)) {
+        if (fieldInit && Node5.isStringLiteral(fieldInit)) {
           names.add(fieldInit.getLiteralValue());
           continue;
         }
@@ -2136,7 +1972,7 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!Node6.isObjectLiteralExpression(optionsArg)) return [];
+  if (!Node5.isObjectLiteralExpression(optionsArg)) return [];
   const declaredEntity = resolveDeclaredEntity(optionsArg, filterClass, project);
   const entityDecl = preferDeclaredEntity ? declaredEntity ?? entityOverride : entityOverride ?? declaredEntity;
   if (!entityDecl) return [];
@@ -2147,17 +1983,17 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
     const relArgs = relationsDecorator.getArguments();
-    if (relArgs.length > 0 && Node6.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && Node5.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!Node6.isPropertyAssignment(relProp)) continue;
+        if (!Node5.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !Node6.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !Node5.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !Node6.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !Node5.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !Node6.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !Node5.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (Node6.isStringLiteral(el)) {
+          if (Node5.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -2168,15 +2004,15 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
 }
 
 // src/discovery/pipe-schema.ts
-import { Node as Node9 } from "ts-morph";
+import { Node as Node8 } from "ts-morph";
 
 // src/discovery/schema-type-inference.ts
 import {
-  ts as ts2
+  ts as ts3
 } from "ts-morph";
 
 // src/discovery/schema-type-program.ts
-import { Node as Node7, Project as Project3, ts } from "ts-morph";
+import { FileSystemRefreshResult as FileSystemRefreshResult2, Node as Node6, Project as Project2, ts as ts2 } from "ts-morph";
 var PARAM_DECORATORS = /* @__PURE__ */ new Set(["Body", "Query", "Param"]);
 var SchemaTypeProgram = class {
   constructor(discovery) {
@@ -2186,10 +2022,10 @@ var SchemaTypeProgram = class {
       ...base,
       // A tsconfig-less consumer gets ES5 by default, whose lib has no `Map`/`Set`/
       // `Promise` for the schema libraries' declarations to lean on.
-      target: base.target ?? ts.ScriptTarget.ES2022,
+      target: base.target ?? ts2.ScriptTarget.ES2022,
       // With neither set, resolve the way a bundler does: package `exports`
       // (`zod/v4`) and extensionless or `.js` relative imports all resolve.
-      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: ts.ModuleKind.ESNext, moduleResolution: ts.ModuleResolutionKind.Bundler } : {},
+      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: ts2.ModuleKind.ESNext, moduleResolution: ts2.ModuleResolutionKind.Bundler } : {},
       // Without it `.nullable()` and `.optional()` would erase to the bare type.
       strictNullChecks: true,
       // No ambient `@types/*` (a tsconfig's `types: ['node']`): a schema does not
@@ -2197,17 +2033,16 @@ var SchemaTypeProgram = class {
       types: [],
       noEmit: true
     };
-    this.project = new Project3({
+    this.project = new Project2({
       skipAddingFilesFromTsConfig: true,
       compilerOptions: this.options
     });
-    for (const sf of discovery.getSourceFiles()) this.request(sf.getFilePath(), { schema: true });
-    this.flush();
+    this.requestDiscoveryFiles();
   }
   project;
   options;
   /** Parses a file that is not in discovery's Project, without adding it there. */
-  scratch = new Project3({
+  scratch = new Project2({
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
     skipFileDependencyResolution: true
@@ -2215,6 +2050,53 @@ var SchemaTypeProgram = class {
   needs = /* @__PURE__ */ new Map();
   /** Pruned text per file, as last written into {@link project}. */
   written = /* @__PURE__ */ new Map();
+  /** What {@link project} read from disk unpruned (packages, declaration files). */
+  externalFiles = new DiskFingerprints();
+  scratchFiles = new DiskFingerprints();
+  /** The last pruning of each file, with the source text and needs it was pruned for. */
+  pruned = /* @__PURE__ */ new Map();
+  /**
+   * Bring the program up to date with discovery's files and the disk, keeping the
+   * lib and package declarations it has already parsed and checked. Leaves it
+   * holding exactly the files a new program built now would hold, with the same
+   * text. Returns false when a file the program read unpruned has changed on disk
+   * (a package was reinstalled, a `.d.ts` was edited): the caller builds a new
+   * program instead.
+   */
+  refresh() {
+    const program = this.project.getProgram().compilerObject;
+    const external = program.getSourceFiles().filter(
+      (file) => !program.isSourceFileDefaultLibrary(file) && !this.written.has(file.fileName)
+    ).map((file) => ({ path: file.fileName, text: file.text }));
+    if (this.externalFiles.changed(external).length > 0) return false;
+    const scratch = this.scratch.getSourceFiles().map((sf) => ({ path: sf.getFilePath(), text: sf.getFullText() }));
+    for (const path of this.scratchFiles.changed(scratch)) {
+      const sf = this.scratch.getSourceFile(path);
+      if (sf?.refreshFromFileSystemSync() === FileSystemRefreshResult2.Deleted) {
+        this.scratchFiles.forget(path);
+      }
+    }
+    this.needs.clear();
+    this.requestDiscoveryFiles();
+    for (const path of [...this.written.keys()]) {
+      if (this.needs.has(path)) continue;
+      const sf = this.project.getSourceFile(path);
+      if (sf) this.project.removeSourceFile(sf);
+      this.written.delete(path);
+    }
+    return true;
+  }
+  /**
+   * Everything discovery holds now (the controllers) goes in before the first
+   * query: a file added afterwards discards the program and its checker, and
+   * rebuilding them once per controller is exactly the cost this avoids.
+   */
+  requestDiscoveryFiles() {
+    for (const sf of this.discovery.getSourceFiles()) {
+      this.request(sf.getFilePath(), { schema: true });
+    }
+    this.flush();
+  }
   /**
    * The typed copy of a discovery file, with its schema positions kept. Adding one
    * that was not there yet (a contract file discovery reached lazily) rebuilds the
@@ -2255,12 +2137,21 @@ var SchemaTypeProgram = class {
     while (this.queue.length > 0) {
       const path = this.queue.pop();
       const original = this.original(path);
-      if (!original) continue;
-      const needs = this.needs.get(path);
-      const text = this.prune(original, needs);
+      if (!original) {
+        if (this.written.has(path)) changed.set(path, void 0);
+        continue;
+      }
+      const { text, requests } = this.pruneCached(path, original, this.needs.get(path));
+      for (const { path: target, want } of requests) this.request(target, want);
       if (this.written.get(path) !== text) changed.set(path, text);
     }
     for (const [path, text] of changed) {
+      if (text === void 0) {
+        const sf = this.project.getSourceFile(path);
+        if (sf) this.project.removeSourceFile(sf);
+        this.written.delete(path);
+        continue;
+      }
       this.project.createSourceFile(path, text, { overwrite: true });
       this.written.set(path, text);
     }
@@ -2269,11 +2160,29 @@ var SchemaTypeProgram = class {
   original(path) {
     return this.discovery.getSourceFile(path) ?? this.scratch.getSourceFile(path) ?? this.scratch.addSourceFileAtPathIfExists(path);
   }
+  /** {@link prune}, reusing the last result while the file's text and needs are the same. */
+  pruneCached(path, sf, needs) {
+    const source = sf.getFullText();
+    const key = `${needs.schema}:${needs.all}:${[...needs.names].sort().join(",")}`;
+    const last = this.pruned.get(path);
+    if (last && last.source === source && last.needs === key) return last;
+    const result = this.prune(sf, needs);
+    if (result.resolved) this.pruned.set(path, { ...result, source, needs: key });
+    else this.pruned.delete(path);
+    return result;
+  }
   /**
    * `sf`'s text with every import/re-export nothing in `needs` references blanked,
-   * requesting from each kept one's target the names it brings in.
+   * and the names each kept one brings in from its target.
    */
   prune(sf, needs) {
+    const requests = [];
+    let resolved = true;
+    const resolveFrom = (specifier) => {
+      const target = this.resolve(specifier, sf);
+      if (target === null) resolved = false;
+      return target ?? void 0;
+    };
     const locals = topLevelDeclarations(sf);
     const roots = [];
     if (needs.all) roots.push(...sf.getStatements());
@@ -2307,7 +2216,7 @@ var SchemaTypeProgram = class {
     const seen = new Set(queue);
     while (queue.length > 0) {
       const node = queue.pop();
-      const ids = Node7.isIdentifier(node) ? [node] : node.getDescendantsOfKind(ts.SyntaxKind.Identifier);
+      const ids = Node6.isIdentifier(node) ? [node] : node.getDescendantsOfKind(ts2.SyntaxKind.Identifier);
       for (const id of ids) {
         const name = id.getText();
         if (referenced.has(name)) continue;
@@ -2326,7 +2235,7 @@ var SchemaTypeProgram = class {
       }
     };
     for (const decl of sf.getImportDeclarations()) {
-      const target = this.resolve(decl.getModuleSpecifierValue(), sf);
+      const target = resolveFrom(decl.getModuleSpecifierValue());
       const namespace = decl.getNamespaceImport()?.getText();
       const def = decl.getDefaultImport()?.getText();
       const named = decl.getNamedImports().map((n) => ({
@@ -2340,21 +2249,24 @@ var SchemaTypeProgram = class {
         continue;
       }
       if (target) {
-        this.request(target, {
-          all: wantsNamespace,
-          names: [...wantsDefault ? ["default"] : [], ...named.map((n) => n.imported)]
+        requests.push({
+          path: target,
+          want: {
+            all: wantsNamespace,
+            names: [...wantsDefault ? ["default"] : [], ...named.map((n) => n.imported)]
+          }
         });
       }
     }
     for (const exp of sf.getExportDeclarations()) {
       const spec = exp.getModuleSpecifierValue();
       if (spec === void 0) continue;
-      const target = this.resolve(spec, sf);
+      const target = resolveFrom(spec);
       if (exp.isNamespaceExport() || exp.getNamedExports().length === 0) {
         if (!needs.all && unresolvedNames.length === 0) {
           blank(exp);
         } else if (target) {
-          this.request(target, { all: needs.all, names: unresolvedNames });
+          requests.push({ path: target, want: { all: needs.all, names: unresolvedNames } });
         }
         continue;
       }
@@ -2362,22 +2274,24 @@ var SchemaTypeProgram = class {
         (n) => needs.all || needs.names.has((n.getAliasNode() ?? n.getNameNode()).getText())
       ).map((n) => n.getNameNode().getText());
       if (wanted.length === 0) blank(exp);
-      else if (target) this.request(target, { names: wanted });
+      else if (target) requests.push({ path: target, want: { names: wanted } });
     }
-    return chars.join("");
+    return { text: chars.join(""), requests, resolved };
   }
   /**
-   * The project source file a module specifier resolves to, or undefined for a
-   * package (read unpruned by the program itself) or an unresolvable one.
+   * The project source file a module specifier resolves to; undefined for a
+   * package or a declaration file (read unpruned by the program itself), null for
+   * one that does not resolve.
    */
   resolve(specifier, from) {
-    const resolved = ts.resolveModuleName(
+    const resolved = ts2.resolveModuleName(
       specifier,
       from.getFilePath(),
       this.options,
-      ts.sys
+      ts2.sys
     ).resolvedModule;
-    if (!resolved || resolved.isExternalLibraryImport) return void 0;
+    if (!resolved) return null;
+    if (resolved.isExternalLibraryImport) return void 0;
     const file = resolved.resolvedFileName;
     if (file.endsWith(".d.ts") || !/\.(m|c)?tsx?$/.test(file)) return void 0;
     return file;
@@ -2386,20 +2300,20 @@ var SchemaTypeProgram = class {
 function schemaPositions(sf) {
   const roots = [];
   sf.forEachDescendant((node) => {
-    if (Node7.isDecorator(node)) {
+    if (Node6.isDecorator(node)) {
       const name = node.getName();
       if (name === "ApplyContract") {
         roots.push(...node.getArguments());
       } else if (PARAM_DECORATORS.has(name)) {
         for (const arg of node.getArguments()) {
-          if (Node7.isNewExpression(arg) || Node7.isCallExpression(arg)) {
+          if (Node6.isNewExpression(arg) || Node6.isCallExpression(arg)) {
             roots.push(...arg.getArguments());
           }
         }
       }
-    } else if (Node7.isCallExpression(node)) {
+    } else if (Node6.isCallExpression(node)) {
       const callee = node.getExpression();
-      const name = Node7.isIdentifier(callee) ? callee.getText() : Node7.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
+      const name = Node6.isIdentifier(callee) ? callee.getText() : Node6.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
       if (name === "defineContract") roots.push(...node.getArguments());
     }
   });
@@ -2432,8 +2346,13 @@ function defaultExport(sf) {
 
 // src/discovery/schema-type-inference.ts
 var programs = /* @__PURE__ */ new WeakMap();
+var stale = /* @__PURE__ */ new WeakSet();
 function programFor(discovery) {
   let program = programs.get(discovery);
+  if (program && stale.has(discovery)) {
+    stale.delete(discovery);
+    if (!program.refresh()) program = void 0;
+  }
   if (!program) {
     program = new SchemaTypeProgram(discovery);
     programs.set(discovery, program);
@@ -2442,6 +2361,10 @@ function programFor(discovery) {
 }
 function clearSchemaTypeProject(discovery) {
   programs.delete(discovery);
+  stale.delete(discovery);
+}
+function invalidateSchemaTypeProject(discovery) {
+  if (programs.has(discovery)) stale.add(discovery);
 }
 function counterpart(typedSf, node) {
   const start = node.getStart();
@@ -2505,7 +2428,7 @@ function objectKey(name) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
 }
 function isOptionalSymbol(sym) {
-  return (sym.getFlags() & ts2.SymbolFlags.Optional) !== 0;
+  return (sym.getFlags() & ts3.SymbolFlags.Optional) !== 0;
 }
 function isSymbolKeyed(sym) {
   return sym.getName().startsWith("__@");
@@ -2666,11 +2589,11 @@ function acceptsUndefined(types) {
 }
 
 // src/discovery/zod-ast-to-ts.ts
-import { Node as Node8, SyntaxKind as SyntaxKind3 } from "ts-morph";
+import { Node as Node7, SyntaxKind as SyntaxKind2 } from "ts-morph";
 function zodAstToTs(node) {
-  if (!Node8.isCallExpression(node)) return "unknown";
+  if (!Node7.isCallExpression(node)) return "unknown";
   const expr = node.getExpression();
-  if (Node8.isPropertyAccessExpression(expr)) {
+  if (Node7.isPropertyAccessExpression(expr)) {
     const methodName = expr.getName();
     const receiver = expr.getExpression();
     if (methodName === "optional") {
@@ -2694,17 +2617,17 @@ function zodAstToTs(node) {
       case "literal": {
         const lit = args[0];
         if (!lit) return "unknown";
-        if (Node8.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (Node8.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === SyntaxKind3.TrueKeyword) return "true";
-        if (lit.getKind() === SyntaxKind3.FalseKeyword) return "false";
+        if (Node7.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (Node7.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 || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
         const members = arrArg.getElements().map(
-          (el) => Node8.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+          (el) => Node7.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
         );
         return members.join(" | ");
       }
@@ -2715,10 +2638,10 @@ function zodAstToTs(node) {
       }
       case "object": {
         const objArg = args[0];
-        if (!objArg || !Node8.isObjectLiteralExpression(objArg)) return "unknown";
+        if (!objArg || !Node7.isObjectLiteralExpression(objArg)) return "unknown";
         const lines = [];
         for (const prop of objArg.getProperties()) {
-          if (!Node8.isPropertyAssignment(prop)) continue;
+          if (!Node7.isPropertyAssignment(prop)) continue;
           const key = prop.getName();
           const valNode = prop.getInitializer();
           if (!valNode) continue;
@@ -2730,7 +2653,7 @@ function zodAstToTs(node) {
       }
       case "union": {
         const arrArg = args[0];
-        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
         return arrArg.getElements().map(zodAstToTs).join(" | ");
       }
       case "record": {
@@ -2740,7 +2663,7 @@ function zodAstToTs(node) {
       }
       case "tuple": {
         const arrArg = args[0];
-        if (!arrArg || !Node8.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !Node7.isArrayLiteralExpression(arrArg)) return "unknown";
         return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
       }
       default:
@@ -2750,9 +2673,9 @@ function zodAstToTs(node) {
   return "unknown";
 }
 function isOptionalChain(node) {
-  if (!Node8.isCallExpression(node)) return false;
+  if (!Node7.isCallExpression(node)) return false;
   const expr = node.getExpression();
-  return Node8.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+  return Node7.isPropertyAccessExpression(expr) && expr.getName() === "optional";
 }
 function memberType(val, position, project) {
   if (project) {
@@ -2764,13 +2687,13 @@ function memberType(val, position, project) {
   return zodAstToTs(val);
 }
 function parseDefineContractCall(callExpr, project) {
-  if (!Node8.isCallExpression(callExpr)) return null;
+  if (!Node7.isCallExpression(callExpr)) return null;
   const callee = callExpr.getExpression();
-  const calleeName = Node8.isIdentifier(callee) ? callee.getText() : Node8.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  const calleeName = Node7.isIdentifier(callee) ? callee.getText() : Node7.isPropertyAccessExpression(callee) ? callee.getName() : "";
   if (calleeName !== "defineContract") return null;
   const args = callExpr.getArguments();
   const optsArg = args[0];
-  if (!optsArg || !Node8.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node7.isObjectLiteralExpression(optsArg)) return null;
   let query = null;
   let body = null;
   let response = "unknown";
@@ -2778,7 +2701,7 @@ function parseDefineContractCall(callExpr, project) {
   let bodyZodText = null;
   let queryZodText = null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node8.isPropertyAssignment(prop)) continue;
+    if (!Node7.isPropertyAssignment(prop)) continue;
     const propName = prop.getName();
     const val = prop.getInitializer();
     if (!val) continue;
@@ -2800,7 +2723,7 @@ function parseDefineContractCall(callExpr, project) {
 // src/discovery/pipe-schema.ts
 function pipeSchemaOf(decorator, project) {
   for (const pipe of decorator.getArguments()) {
-    if (!Node9.isNewExpression(pipe) && !Node9.isCallExpression(pipe)) continue;
+    if (!Node8.isNewExpression(pipe) && !Node8.isCallExpression(pipe)) continue;
     for (const arg of pipe.getArguments()) {
       if (!couldBeSchema(arg)) continue;
       const inferred = inferSchema(arg, project);
@@ -2822,15 +2745,15 @@ function pipeSchemaOf(decorator, project) {
   return null;
 }
 function couldBeSchema(arg) {
-  return Node9.isIdentifier(arg) || Node9.isPropertyAccessExpression(arg) || Node9.isCallExpression(arg) || Node9.isAsExpression(arg) || Node9.isSatisfiesExpression(arg) || Node9.isParenthesizedExpression(arg);
+  return Node8.isIdentifier(arg) || Node8.isPropertyAccessExpression(arg) || Node8.isCallExpression(arg) || Node8.isAsExpression(arg) || Node8.isSatisfiesExpression(arg) || Node8.isParenthesizedExpression(arg);
 }
 function syntacticZodType(arg, project) {
   let expr = arg;
-  if (Node9.isIdentifier(arg)) {
+  if (Node8.isIdentifier(arg)) {
     const resolved = resolveImportedVariable(arg.getText(), arg.getSourceFile(), project);
     expr = resolved?.decl.getInitializer();
   }
-  if (!expr || !Node9.isCallExpression(expr)) return null;
+  if (!expr || !Node8.isCallExpression(expr)) return null;
   const type = zodAstToTs(expr);
   return type === "unknown" ? null : type;
 }
@@ -2866,22 +2789,22 @@ var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
 ]);
 function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /* @__PURE__ */ new Map()) {
   if (depth <= 0) return "unknown";
-  if (Node10.isArrayTypeNode(typeNode)) {
+  if (Node9.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth, subst)}>`;
   }
-  if (Node10.isUnionTypeNode(typeNode)) {
+  if (Node9.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" | ");
   }
-  if (Node10.isIntersectionTypeNode(typeNode)) {
+  if (Node9.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" & ");
   }
-  if (Node10.isParenthesizedTypeNode(typeNode)) {
+  if (Node9.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth, subst)})`;
   }
-  if (Node10.isTypeReference(typeNode)) {
+  if (Node9.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = Node10.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = Node9.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     const bound = subst.get(name);
     if (bound !== void 0) return bound;
     if (name === "string" || name === "number" || name === "boolean") return name;
@@ -2904,10 +2827,10 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
     return "unknown";
   }
-  if (Node10.isTypeLiteral(typeNode)) {
+  if (Node9.isTypeLiteral(typeNode)) {
     const members = [];
     for (const member of typeNode.getMembers()) {
-      if (Node10.isPropertySignature(member)) {
+      if (Node9.isPropertySignature(member)) {
         const memberTypeNode = member.getTypeNode();
         const memberType2 = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
         members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType2}`);
@@ -2918,11 +2841,11 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     return members.length > 0 ? `{ ${members.join("; ")} }` : "{}";
   }
   const kind = typeNode.getKind();
-  if (kind === SyntaxKind4.StringKeyword) return "string";
-  if (kind === SyntaxKind4.NumberKeyword) return "number";
-  if (kind === SyntaxKind4.BooleanKeyword) return "boolean";
-  if (kind === SyntaxKind4.UnknownKeyword) return "unknown";
-  if (kind === SyntaxKind4.AnyKeyword) return "unknown";
+  if (kind === SyntaxKind3.StringKeyword) return "string";
+  if (kind === SyntaxKind3.NumberKeyword) return "number";
+  if (kind === SyntaxKind3.BooleanKeyword) return "boolean";
+  if (kind === SyntaxKind3.UnknownKeyword) return "unknown";
+  if (kind === SyntaxKind3.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
 function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode, subst = /* @__PURE__ */ new Map()) {
@@ -2980,7 +2903,7 @@ function resolvePropertied(decl, sourceFile, project, depth, subst = /* @__PURE_
 }
 function namedField(decorator) {
   const first = decorator.getArguments()[0];
-  return first && Node10.isStringLiteral(first) ? first.getLiteralValue() : null;
+  return first && Node9.isStringLiteral(first) ? first.getLiteralValue() : null;
 }
 function extractBodyType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
@@ -3030,8 +2953,8 @@ function extractQueryType(method, sourceFile, project) {
 function isParamOptional(param) {
   if (param.hasQuestionToken() || param.hasInitializer()) return true;
   const typeNode = param.getTypeNode();
-  if (typeNode && Node10.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().some((t) => t.getKind() === SyntaxKind4.UndefinedKeyword);
+  if (typeNode && Node9.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().some((t) => t.getKind() === SyntaxKind3.UndefinedKeyword);
   }
   return false;
 }
@@ -3043,7 +2966,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!Node10.isStringLiteral(nameArg)) continue;
+    if (!Node9.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -3080,28 +3003,28 @@ function extractUploadedFiles(method) {
   for (const decorator of method.getDecorators()) {
     if (decorator.getName() !== "UseInterceptors") continue;
     for (const arg of decorator.getArguments()) {
-      if (!Node10.isCallExpression(arg)) continue;
+      if (!Node9.isCallExpression(arg)) continue;
       const interceptor = arg.getExpression().getText();
       const callArgs = arg.getArguments();
       const firstArg2 = callArgs[0];
       if (interceptor === "FileInterceptor") {
-        if (firstArg2 && Node10.isStringLiteral(firstArg2)) {
+        if (firstArg2 && Node9.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: ${FILE}`);
           multipart = true;
         }
       } else if (interceptor === "FilesInterceptor") {
-        if (firstArg2 && Node10.isStringLiteral(firstArg2)) {
+        if (firstArg2 && Node9.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: Array<${FILE}>`);
           multipart = true;
         }
       } else if (interceptor === "FileFieldsInterceptor") {
-        if (firstArg2 && Node10.isArrayLiteralExpression(firstArg2)) {
+        if (firstArg2 && Node9.isArrayLiteralExpression(firstArg2)) {
           for (const el of firstArg2.getElements()) {
-            if (!Node10.isObjectLiteralExpression(el)) continue;
+            if (!Node9.isObjectLiteralExpression(el)) continue;
             const nameProp = el.getProperty("name");
-            if (nameProp && Node10.isPropertyAssignment(nameProp)) {
+            if (nameProp && Node9.isPropertyAssignment(nameProp)) {
               const init = nameProp.getInitializer();
-              if (init && Node10.isStringLiteral(init)) {
+              if (init && Node9.isStringLiteral(init)) {
                 entries.push(`${init.getLiteralValue()}: Array<${FILE}>`);
               }
             }
@@ -3121,13 +3044,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && Node10.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && Node9.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!Node10.isPropertyAssignment(prop)) continue;
+        if (!Node9.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (Node10.isArrayLiteralExpression(val)) {
+        if (Node9.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -3148,24 +3071,24 @@ function extractResponseType(method, sourceFile, project) {
 }
 function apiResponseStatus(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !Node10.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node9.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node10.isPropertyAssignment(prop)) continue;
+    if (!Node9.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "status") continue;
     const val = prop.getInitializer();
-    if (val && Node10.isNumericLiteral(val)) return Number(val.getLiteralValue());
+    if (val && Node9.isNumericLiteral(val)) return Number(val.getLiteralValue());
   }
   return null;
 }
 function apiResponseTypeNode(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !Node10.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !Node9.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!Node10.isPropertyAssignment(prop)) continue;
+    if (!Node9.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "type") continue;
     const val = prop.getInitializer();
     if (!val) return null;
-    if (Node10.isArrayLiteralExpression(val)) {
+    if (Node9.isArrayLiteralExpression(val)) {
       const first = val.getElements()[0];
       return first ? { node: first, isArray: true } : null;
     }
@@ -3183,7 +3106,7 @@ function extractErrorType(method, sourceFile, project) {
     const inner = resolveIdentifierToClassType(typeInfo.node, sourceFile, project, 3);
     const type = typeInfo.isArray ? `Array<${inner}>` : inner;
     let ref = null;
-    if (Node10.isIdentifier(typeInfo.node)) {
+    if (Node9.isIdentifier(typeInfo.node)) {
       const name = typeInfo.node.getText();
       const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
       if (localDecl?.isExported()) {
@@ -3200,7 +3123,7 @@ function extractErrorType(method, sourceFile, project) {
   return null;
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!Node10.isIdentifier(node)) return "unknown";
+  if (!Node9.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -3220,9 +3143,9 @@ var STREAM_ENVELOPES = /* @__PURE__ */ new Set(["MessageEvent", "MessageEventLik
 var BINARY_RESPONSE_TYPES = /* @__PURE__ */ new Set(["StreamableFile", "Buffer"]);
 function detectBinaryResponse(method) {
   const node = unwrapNamedContainer(method.getReturnTypeNode(), /* @__PURE__ */ new Set(["Promise"]));
-  if (!node || !Node10.isTypeReference(node)) return false;
+  if (!node || !Node9.isTypeReference(node)) return false;
   const typeName = node.getTypeName();
-  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node9.isIdentifier(typeName) ? typeName.getText() : "";
   return BINARY_RESPONSE_TYPES.has(name);
 }
 function detectStreamElement(method) {
@@ -3237,9 +3160,9 @@ function detectStreamElement(method) {
   return null;
 }
 function streamContainerElement(node) {
-  if (!node || !Node10.isTypeReference(node)) return null;
+  if (!node || !Node9.isTypeReference(node)) return null;
   const typeName = node.getTypeName();
-  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node9.isIdentifier(typeName) ? typeName.getText() : "";
   if (STREAM_CONTAINERS.has(name) || STREAM_CONTAINERS_GENERATOR.has(name)) {
     return node.getTypeArguments()[0] ?? null;
   }
@@ -3249,9 +3172,9 @@ function hasAsQueryDecorator(method) {
   return method.getDecorators().some((d) => d.getName() === "AsQuery");
 }
 function unwrapNamedContainer(node, names) {
-  if (!node || !Node10.isTypeReference(node)) return node;
+  if (!node || !Node9.isTypeReference(node)) return node;
   const typeName = node.getTypeName();
-  const name = Node10.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = Node9.isIdentifier(typeName) ? typeName.getText() : "";
   if (names.has(name)) {
     return node.getTypeArguments()[0] ?? node;
   }
@@ -3298,11 +3221,11 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && Node10.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && Node9.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (Node10.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (Node9.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && Node10.isIdentifier(val)) {
+            if (val && Node9.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -3389,7 +3312,7 @@ async function discoverContractsFast(opts) {
   return routes;
 }
 function resolveTsconfigPath(cwd, tsconfig) {
-  return tsconfig ? resolve3(tsconfig) : join4(cwd, "tsconfig.json");
+  return tsconfig ? resolve3(tsconfig) : join3(cwd, "tsconfig.json");
 }
 var NO_TSCONFIG_OPTIONS = {
   allowJs: true,
@@ -3398,25 +3321,25 @@ var NO_TSCONFIG_OPTIONS = {
 };
 function loadDiscoveryTsconfig(tsconfigPath) {
   if (!existsSync(tsconfigPath)) return { options: null, files: [] };
-  const read = ts3.readConfigFile(tsconfigPath, (path) => ts3.sys.readFile(path));
+  const read = ts4.readConfigFile(tsconfigPath, (path) => ts4.sys.readFile(path));
   if (read.error) {
     return {
       options: null,
       files: [tsconfigPath],
-      error: ts3.flattenDiagnosticMessageText(read.error.messageText, " ")
+      error: ts4.flattenDiagnosticMessageText(read.error.messageText, " ")
     };
   }
   const host = {
-    useCaseSensitiveFileNames: ts3.sys.useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: ts4.sys.useCaseSensitiveFileNames,
     // The one line that keeps a tsconfig from being a filesystem walk.
     readDirectory: () => [],
-    fileExists: (path) => ts3.sys.fileExists(path),
+    fileExists: (path) => ts4.sys.fileExists(path),
     // `extends` is resolved through the host, so a consumer whose `paths` live
     // in a base tsconfig keeps working.
-    readFile: (path) => ts3.sys.readFile(path)
+    readFile: (path) => ts4.sys.readFile(path)
   };
-  const sourceFile = ts3.readJsonConfigFile(tsconfigPath, (path) => ts3.sys.readFile(path));
-  const parsed = ts3.parseJsonSourceFileConfigFileContent(
+  const sourceFile = ts4.readJsonConfigFile(tsconfigPath, (path) => ts4.sys.readFile(path));
+  const parsed = ts4.parseJsonSourceFileConfigFileContent(
     sourceFile,
     host,
     dirname2(tsconfigPath),
@@ -3439,7 +3362,7 @@ function createDiscoveryProject(tsconfigPath, tsconfig = loadDiscoveryTsconfig(t
       `[nestjs-codegen/fast] Could not load ${tsconfigPath}: ${tsconfig.error} \u2014 continuing WITHOUT its compiler options, so path alias imports (e.g. '@/...') will not resolve and controllers extending an alias-imported factory will contribute NO routes to the generated client.`
     );
   }
-  return new Project4({
+  return new Project3({
     compilerOptions: tsconfig.options ?? { ...NO_TSCONFIG_OPTIONS },
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
@@ -3481,6 +3404,9 @@ var PersistentDiscovery = class _PersistentDiscovery {
   glob;
   /** Absolute paths of the controllers currently loaded as extraction roots. */
   controllerPaths = /* @__PURE__ */ new Set();
+  /** Every file in {@link project}, as last read from disk. */
+  files = new DiskFingerprints();
+  unresolved = new UnresolvedImports();
   constructor(project, cwd, glob) {
     this.project = project;
     this.cwd = cwd;
@@ -3506,6 +3432,8 @@ var PersistentDiscovery = class _PersistentDiscovery {
   }
   /** Run the initial extraction (equivalent to a first `discoverContractsFast`). */
   discover() {
+    clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return this.runExtraction();
   }
   /**
@@ -3513,26 +3441,39 @@ var PersistentDiscovery = class _PersistentDiscovery {
    * from disk (controllers AND any lazily-loaded DTO/imported files), re-globs
    * to pick up added/removed controllers, clears the per-Project caches, then
    * re-extracts. `changedPaths` is a hint; correctness does not depend on it
-   * being exhaustive because re-globbing + refresh-on-presence covers the set.
+   * being exhaustive because re-globbing + comparing every loaded file with the
+   * disk covers the set.
    */
-  async rediscover(changedPaths) {
-    if (changedPaths) {
-      for (const p of changedPaths) {
-        const abs = resolve3(p);
-        const sf = this.project.getSourceFile(abs);
-        if (sf) {
-          await sf.refreshFromFileSystem();
-        }
+  async rediscover(changedPaths, options = {}) {
+    const hinted = new Set([...changedPaths ?? []].map((p) => resolve3(p)));
+    const program = this.project.getProgram().compilerObject;
+    const sources = program.getSourceFiles().filter(
+      (file) => !program.isSourceFileDefaultLibrary(file) && !program.isSourceFileFromExternalLibrary(file)
+    ).map((file) => ({ path: file.fileName, text: file.text }));
+    for (const path of /* @__PURE__ */ new Set([...hinted, ...this.files.changed(sources)])) {
+      const sf = this.project.getSourceFile(path);
+      if (sf && await sf.refreshFromFileSystem() === FileSystemRefreshResult3.Deleted) {
+        this.files.forget(path);
       }
     }
+    const inProject = new Set(this.project.getSourceFiles().map((sf) => sf.getFilePath()));
+    const definitions = this.project.getLanguageService().compilerObject.getProgram();
+    for (const path of definitions ? this.unresolved.nowResolving(definitions) : []) {
+      const sf = this.project.getSourceFile(path);
+      if (!sf) continue;
+      this.project.removeSourceFile(sf);
+      if (inProject.has(path)) this.project.addSourceFileAtPathIfExists(path);
+    }
     const globbed = new Set(
       await fg2(this.glob, { cwd: this.cwd, absolute: true, onlyFiles: true })
     );
+    let controllersChanged = false;
     for (const f of globbed) {
       if (!this.controllerPaths.has(f)) {
         try {
           this.project.addSourceFileAtPath(f);
           this.controllerPaths.add(f);
+          controllersChanged = true;
         } catch {
         }
       }
@@ -3542,25 +3483,31 @@ var PersistentDiscovery = class _PersistentDiscovery {
         const sf = this.project.getSourceFile(f);
         if (sf) this.project.removeSourceFile(sf);
         this.controllerPaths.delete(f);
+        controllersChanged = true;
       }
     }
+    if (controllersChanged || options.filesAddedOrRemoved) {
+      clearMixinTypeProject();
+      clearSchemaTypeProject(this.project);
+    } else {
+      invalidateMixinTypeProject();
+      invalidateSchemaTypeProject(this.project);
+    }
     return this.runExtraction();
   }
   /** Clear stale per-Project caches, then extract over the controller set. */
   runExtraction() {
     clearTypeResolutionCaches(this.project);
     clearEnumCache(this.project);
-    clearMixinTypeProject();
-    clearSchemaTypeProject(this.project);
     return extractRoutesFrom(this.project, this.controllerPaths);
   }
 };
 function decoratorStringArg(decoratorExpr) {
   if (!decoratorExpr) return void 0;
-  if (Node11.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (Node11.isArrayLiteralExpression(decoratorExpr)) {
+  if (Node10.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (Node10.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && Node11.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && Node10.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -3681,9 +3628,9 @@ function extractContractRoute(args) {
   let contractDef = null;
   let bodyZodRef = null;
   let queryZodRef = null;
-  if (Node11.isCallExpression(firstDecoratorArg)) {
+  if (Node10.isCallExpression(firstDecoratorArg)) {
     contractDef = parseDefineContractCall(firstDecoratorArg, project);
-  } else if (Node11.isIdentifier(firstDecoratorArg)) {
+  } else if (Node10.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -3838,7 +3785,300 @@ function extractFromSourceFile(sourceFile, project) {
   return routes;
 }
 
+// src/discovery/shared-props.ts
+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 discoverSharedPropsFromConfig(config) {
+  if (!config.app?.moduleEntry) return null;
+  try {
+    const tsconfigPath = config.app.tsconfig ?? join4(config.codegen.cwd, "tsconfig.json");
+    let project;
+    try {
+      project = sharedPropsProject(tsconfigPath);
+    } catch {
+      project = new Project4({
+        skipAddingFilesFromTsConfig: true,
+        skipLoadingLibFiles: true,
+        skipFileDependencyResolution: true,
+        compilerOptions: { allowJs: true, strict: false }
+      });
+    }
+    return discoverSharedProps(project, config.app.moduleEntry);
+  } catch {
+    return null;
+  }
+}
+var parsedTsconfigs = /* @__PURE__ */ new Map();
+function readText(file) {
+  try {
+    return readFileSync2(file, "utf8");
+  } catch {
+    return "\0missing";
+  }
+}
+function sharedPropsProject(tsconfigPath) {
+  const text = loadDiscoveryTsconfig(tsconfigPath).files.map((file) => `${file}\0${readText(file)}`).join("\0");
+  const flags = {
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: true,
+    skipFileDependencyResolution: true
+  };
+  const parsed = parsedTsconfigs.get(tsconfigPath);
+  if (parsed?.text === text) return new Project4({ ...flags, compilerOptions: parsed.options });
+  const project = new Project4({ ...flags, tsConfigFilePath: tsconfigPath });
+  parsedTsconfigs.set(tsconfigPath, { text, options: project.getCompilerOptions() });
+  return project;
+}
+function findForRootCall(sourceFile) {
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind4.CallExpression);
+  for (const call of callExpressions) {
+    const expr = call.getExpression();
+    if (!Node11.isPropertyAccessExpression(expr)) continue;
+    const methodName = expr.getName();
+    const objectExpr = expr.getExpression();
+    if (methodName === "forRoot" && Node11.isIdentifier(objectExpr)) {
+      const name = objectExpr.getText();
+      if (name === "InertiaModule") {
+        return call;
+      }
+    }
+  }
+  return null;
+}
+function findShareInitializer(forRootCall) {
+  if (!Node11.isCallExpression(forRootCall)) return null;
+  const args = forRootCall.getArguments();
+  const firstArg2 = args[0];
+  if (!firstArg2 || !Node11.isObjectLiteralExpression(firstArg2)) return null;
+  for (const prop of firstArg2.getProperties()) {
+    if (Node11.isPropertyAssignment(prop) && prop.getName() === "share") {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function extractShareType(node, sourceFile, project) {
+  if (Node11.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 (Node11.isArrowFunction(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (Node11.isFunctionExpression(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (Node11.isObjectLiteralExpression(node)) {
+    const result = extractFromObjectLiteral(node);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  return null;
+}
+function resolveIdentifierToImportRef(id, sourceFile, project) {
+  if (!Node11.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 = Node11.isArrowFunction(node) || Node11.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  if (returnTypeNode) {
+    return extractFromReturnTypeAnnotation(returnTypeNode);
+  }
+  if (Node11.isArrowFunction(node)) {
+    const body = node.getBody();
+    if (Node11.isParenthesizedExpression(body)) {
+      const inner = body.getExpression();
+      if (Node11.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    if (Node11.isObjectLiteralExpression(body)) {
+      return extractFromObjectLiteral(body);
+    }
+    if (Node11.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  if (Node11.isFunctionExpression(node)) {
+    const body = node.getBody();
+    if (Node11.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  return null;
+}
+function extractFromReturnTypeAnnotation(typeNode) {
+  if (Node11.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    if (Node11.isIdentifier(typeName) && typeName.getText() === "Promise") {
+      const typeArgs = typeNode.getTypeArguments();
+      const firstArg2 = typeArgs[0];
+      if (firstArg2) {
+        return extractFromReturnTypeAnnotation(firstArg2);
+      }
+      return null;
+    }
+  }
+  if (Node11.isTypeLiteral(typeNode)) {
+    const properties = [];
+    for (const member of typeNode.getMembers()) {
+      if (Node11.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 (!Node11.isBlock(block)) return null;
+  const statements = block.getStatements();
+  for (let i = statements.length - 1; i >= 0; i--) {
+    const stmt = statements[i];
+    if (!Node11.isReturnStatement(stmt)) continue;
+    const expr = stmt.getExpression();
+    if (!expr) continue;
+    if (Node11.isObjectLiteralExpression(expr)) {
+      return extractFromObjectLiteral(expr);
+    }
+    if (Node11.isParenthesizedExpression(expr)) {
+      const inner = expr.getExpression();
+      if (Node11.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    break;
+  }
+  return null;
+}
+function extractFromObjectLiteral(objLiteral) {
+  if (!Node11.isObjectLiteralExpression(objLiteral)) return null;
+  const properties = [];
+  for (const prop of objLiteral.getProperties()) {
+    if (!Node11.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 (Node11.isStringLiteral(node)) return "string";
+  if (Node11.isTemplateExpression(node) || Node11.isNoSubstitutionTemplateLiteral(node))
+    return "string";
+  if (Node11.isNumericLiteral(node)) return "number";
+  if (node.getKind() === SyntaxKind4.TrueKeyword || node.getKind() === SyntaxKind4.FalseKeyword) {
+    return "boolean";
+  }
+  if (node.getKind() === SyntaxKind4.NullKeyword) return "null";
+  if (Node11.isIdentifier(node) && node.getText() === "undefined") return "undefined";
+  if (Node11.isObjectLiteralExpression(node)) {
+    const props = node.getProperties();
+    if (props.length === 0) return "Record<string, unknown>";
+    const entries = [];
+    for (const prop of props) {
+      if (!Node11.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 (Node11.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 (Node11.isConditionalExpression(node)) {
+    const whenTrue = inferExpressionType(node.getWhenTrue());
+    const whenFalse = inferExpressionType(node.getWhenFalse());
+    if (whenTrue === whenFalse) return whenTrue;
+    return `${whenTrue} | ${whenFalse}`;
+  }
+  if (Node11.isParenthesizedExpression(node)) {
+    return inferExpressionType(node.getExpression());
+  }
+  if (Node11.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 join5, relative as relative4 } from "path";
+
 // src/extension/registry.ts
+import { relative as relative3, resolve as resolve4 } from "path";
+import { Project as Project5 } from "ts-morph";
 function resolveApiSlots(extensions) {
   let layer;
   let layerOwner;
@@ -5620,36 +5860,64 @@ async function discoverInputFiles(config) {
   const matched = await fg3(globs, { cwd, absolute: true, onlyFiles: true });
   return [...new Set(matched)].sort();
 }
-async function computeInputsHash(config, extraInputs = []) {
+var READ_CONCURRENCY = 64;
+async function readAll(paths, read) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < paths.length; i += READ_CONCURRENCY) {
+    const batch = paths.slice(i, i + READ_CONCURRENCY);
+    const texts = await Promise.all(batch.map(read));
+    batch.forEach((path, j) => out.set(path, texts[j]));
+  }
+  return out;
+}
+async function readInputs(config) {
+  const cwd = config.codegen.cwd;
+  const tsconfigPath = resolveTsconfigPath(cwd, config.app?.tsconfig ?? void 0);
+  const extended = loadDiscoveryTsconfig(tsconfigPath).files;
+  const tsconfigFiles = extended.length > 0 ? extended : [tsconfigPath];
+  const files = await discoverInputFiles(config);
+  const contents = /* @__PURE__ */ new Map();
+  const tsconfigs = await readAll(
+    tsconfigFiles,
+    (file) => readFile2(file, "utf8").catch(() => null)
+  );
+  for (const [file, text] of tsconfigs) contents.set(file, text);
+  for (const [file, text] of await readAll(files, (file2) => readFile2(file2, "utf8"))) {
+    contents.set(file, text);
+  }
+  return { tsconfigFiles, files, contents, tracked: /* @__PURE__ */ new Map() };
+}
+async function readInput(snapshot, path) {
+  return snapshot.contents.get(path) ?? readFile2(path, "utf8");
+}
+async function computeInputsHash(config, extraInputs = [], snapshot) {
+  const inputs = snapshot ?? await readInputs(config);
   const hash = createHash("sha256");
   hash.update(`version:${VERSION}
 `);
   hash.update(`config:${serializeConfig(config)}
 `);
   const cwd = config.codegen.cwd;
-  const tsconfigPath = resolveTsconfigPath(cwd, config.app?.tsconfig ?? void 0);
-  const tsconfigFiles = loadDiscoveryTsconfig(tsconfigPath).files;
-  for (const file of tsconfigFiles.length > 0 ? tsconfigFiles : [tsconfigPath]) {
-    const contents = await readFile2(file, "utf8").catch(() => null);
+  for (const file of inputs.tsconfigFiles) {
     hash.update(`tsconfig:${relative7(cwd, file)}
 `);
-    hash.update(contents ?? " missing");
+    hash.update(inputs.contents.get(file) ?? " missing");
     hash.update("\n");
   }
-  const globbed = await discoverInputFiles(config);
-  const globbedRelative = new Set(globbed.map((file) => relative7(cwd, file)));
+  const globbedRelative = new Set(inputs.files.map((file) => relative7(cwd, file)));
   const extra = [...new Set(extraInputs)].filter((file) => !globbedRelative.has(file)).sort();
-  for (const file of globbed) {
-    const contents = await readFile2(file, "utf8");
+  for (const file of inputs.files) {
     hash.update(`file:${relative7(cwd, file)}
 `);
-    hash.update(contents);
+    hash.update(inputs.contents.get(file));
     hash.update("\n");
   }
+  const unread = extra.map((file) => join13(cwd, file)).filter((abs) => !inputs.tracked.has(abs));
+  for (const [abs, text] of await readAll(unread, readTrackedInput)) inputs.tracked.set(abs, text);
   for (const file of extra) {
     hash.update(`extra:${file}
 `);
-    hash.update(await readTrackedInput(join13(cwd, file)));
+    hash.update(inputs.tracked.get(join13(cwd, file)));
     hash.update("\n");
   }
   return hash.digest("hex");
@@ -5730,14 +5998,15 @@ function driftGuardMessage(outDir, previousEntryPoint, currentEntryPoint, differ
 async function generate(config, inputRoutes = [], entryPoint = "cli") {
   setCodegenDebug(config.debug);
   const manifest = await readManifest(config.codegen.outDir);
-  const inputsHash = await computeInputsHash(config, manifest?.extraInputs ?? []);
+  const inputs = await readInputs(config);
+  const inputsHash = await computeInputsHash(config, manifest?.extraInputs ?? [], inputs);
   if (await isManifestFresh(config.codegen.outDir, manifest, inputsHash)) {
     console.log(`[nestjs-codegen] ${config.codegen.outDir} up to date, skipped`);
     return;
   }
   const configHash = computeConfigHash(config);
   const configKeyHashes = computeConfigKeyHashes(config);
-  if (config.driftGuard && manifest?.entryPoint && manifest.entryPoint !== entryPoint && manifest.configHash && manifest.configHash !== configHash) {
+  if (config.driftGuard && manifest?.version === VERSION && manifest?.entryPoint && manifest.entryPoint !== entryPoint && manifest.configHash && manifest.configHash !== configHash) {
     throw new DriftGuardError(
       driftGuardMessage(
         config.codegen.outDir,
@@ -5758,7 +6027,7 @@ async function generate(config, inputRoutes = [], entryPoint = "cli") {
   }
   if (config.pages) {
     const pagesConfig = config.pages;
-    const pages = await discoverPageScopes(config);
+    const pages = await discoverPageScopes(config, (path) => readInput(inputs, path));
     const sharedProps = discoverSharedPropsFromConfig(config);
     await emitPages(pages, config.codegen.outDir, {
       propsExport: pagesConfig.propsExport,
@@ -5808,7 +6077,7 @@ async function generate(config, inputRoutes = [], entryPoint = "cli") {
   }
   const outputFiles = await listOutputFiles(config.codegen.outDir);
   const extraInputs = [...trackedInputs].sort();
-  const recordedHash = extraInputs.length > 0 ? await computeInputsHash(config, extraInputs) : inputsHash;
+  const recordedHash = extraInputs.length > 0 ? await computeInputsHash(config, extraInputs, inputs) : inputsHash;
   await writeManifest(config.codegen.outDir, {
     version: VERSION,
     hash: recordedHash,
@@ -5991,13 +6260,15 @@ async function watch(config, onChange, options = {}) {
   pagesWatcher.on("unlink", schedulePagesRegenerate);
   let contractsDebounceTimer;
   const pendingChangedPaths = /* @__PURE__ */ new Set();
+  let pendingAddedOrRemoved = false;
   const contractsWatcher = chokidar.watch(join16(config.codegen.cwd, config.contracts.glob), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
   });
-  function scheduleContractsRegenerate(changedPath) {
+  function scheduleContractsRegenerate(changedPath, addedOrRemoved = false) {
     if (typeof changedPath === "string") pendingChangedPaths.add(changedPath);
+    if (addedOrRemoved) pendingAddedOrRemoved = true;
     if (contractsDebounceTimer !== void 0) {
       clearTimeout(contractsDebounceTimer);
     }
@@ -6005,8 +6276,12 @@ async function watch(config, onChange, options = {}) {
       contractsDebounceTimer = void 0;
       const changed = [...pendingChangedPaths];
       pendingChangedPaths.clear();
+      const filesAddedOrRemoved = pendingAddedOrRemoved;
+      pendingAddedOrRemoved = false;
       try {
-        const routes = await (await getDiscovery()).rediscover(changed);
+        const routes = await (await getDiscovery()).rediscover(changed, {
+          filesAddedOrRemoved
+        });
         lastRoutes = routes;
         await generateAndTrack(routes);
       } catch (err) {
@@ -6018,20 +6293,25 @@ async function watch(config, onChange, options = {}) {
       onChange?.();
     }, config.contracts.debounceMs);
   }
-  contractsWatcher.on("add", (p) => scheduleContractsRegenerate(p));
+  contractsWatcher.on("add", (p) => scheduleContractsRegenerate(p, true));
   contractsWatcher.on("change", (p) => scheduleContractsRegenerate(p));
-  contractsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p));
+  contractsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p, true));
   const formsWatcher = chokidar.watch(join16(config.codegen.cwd, config.forms.watch), {
     ignoreInitial: true,
     persistent: true,
     awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
   });
-  formsWatcher.on("add", (p) => scheduleContractsRegenerate(p));
+  formsWatcher.on("add", (p) => scheduleContractsRegenerate(p, true));
   formsWatcher.on("change", (p) => scheduleContractsRegenerate(p));
-  formsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p));
-  trackedWatcher.on("add", (p) => scheduleContractsRegenerate(p));
+  formsWatcher.on("unlink", (p) => scheduleContractsRegenerate(p, true));
+  trackedWatcher.on("add", (p) => scheduleContractsRegenerate(p, true));
   trackedWatcher.on("change", (p) => scheduleContractsRegenerate(p));
-  trackedWatcher.on("unlink", (p) => scheduleContractsRegenerate(p));
+  trackedWatcher.on("unlink", (p) => scheduleContractsRegenerate(p, true));
+  await Promise.all(
+    [pagesWatcher, contractsWatcher, formsWatcher].map(
+      (w) => new Promise((resolveReady) => w.once("ready", () => resolveReady()))
+    )
+  );
   return {
     close: async () => {
       if (pagesDebounceTimer !== void 0) {
@@ -6052,7 +6332,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.29.0";
+var VERSION = "0.30.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -6080,22 +6360,22 @@ async function runCodegen(opts = {}) {
 
 // src/cli/doctor.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { join as join18 } from "path";
 
 // src/cli/init.ts
 import { execFileSync } from "child_process";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { access as access2, mkdir as mkdir11, readFile as readFile5, writeFile as writeFile11 } from "fs/promises";
 import { join as join17 } from "path";
 import { createInterface } from "readline";
 
 // src/cli/patch-utils.ts
-import { readFileSync, writeFileSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync } from "fs";
 function patchJsonFile(filePath, mutator, parse = (raw) => raw) {
   let raw;
   try {
-    raw = readFileSync(filePath, "utf8");
+    raw = readFileSync3(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -6313,7 +6593,7 @@ async function patchPackageJsonScripts(cwd, scripts) {
 function patchAppModule(filePath, rootView) {
   let content;
   try {
-    content = readFileSync2(filePath, "utf8");
+    content = readFileSync4(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -6354,7 +6634,7 @@ ${indent}HomeController,${content.slice(bracketPos)}`;
 function patchMainTs(filePath) {
   let content;
   try {
-    content = readFileSync2(filePath, "utf8");
+    content = readFileSync4(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -6838,14 +7118,14 @@ function checkFileExists(cwd, file) {
 }
 function readJson(path) {
   try {
-    const raw = readFileSync3(path, "utf8").replace(/\/\/.*$/gm, "");
+    const raw = readFileSync5(path, "utf8").replace(/\/\/.*$/gm, "");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeJsonField(filePath, dotPath, value) {
-  const raw = readFileSync3(filePath, "utf8");
+  const raw = readFileSync5(filePath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "");
   const obj = JSON.parse(stripped);
   let target = obj;
@@ -7054,7 +7334,7 @@ async function runDoctor(opts) {
     }
   });
   if (checkFileExists(cwd, "vite.config.ts")) {
-    const viteContent = readFileSync3(join18(cwd, "vite.config.ts"), "utf8");
+    const viteContent = readFileSync5(join18(cwd, "vite.config.ts"), "utf8");
     checks.push({
       name: "vite.config.ts has resolve.alias",
       pass: viteContent.includes("resolve") && viteContent.includes("alias"),
@@ -7120,7 +7400,7 @@ async function runDoctor(opts) {
   }
   if (checkFileExists(cwd, ".gitignore")) {
     const gitignorePath = join18(cwd, ".gitignore");
-    const gitignore = readFileSync3(gitignorePath, "utf8");
+    const gitignore = readFileSync5(gitignorePath, "utf8");
     checks.push({
       name: ".gitignore includes .nestjs-inertia/",
       pass: gitignore.includes(".nestjs-inertia"),