@dudousxd/nestjs-codegen 0.28.0 → 0.29.1

package/dist/index.cjs

@@ -315,7 +315,7 @@ async function discoverPages(opts) {
       const rel = (0, import_node_path2.relative)(opts.cwd, file);
       const nameRel = (0, import_node_path2.relative)(pagesBase, file).split(import_node_path2.sep).join("/");
       const name = `${prefix}${computeName(nameRel, opts.componentNameStrategy)}`;
-      const source = await (0, import_promises2.readFile)(file, "utf8");
+      const source = await (opts.read ? opts.read(file) : (0, import_promises2.readFile)(file, "utf8"));
       const propsSource = extractPropsSource(source, opts.propsExport);
       out.push({ name, absolutePath: file, relativePath: rel, propsSource, scope });
     }
@@ -323,10 +323,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,
@@ -397,297 +401,60 @@ function extractPropsSource(source, exportName) {
 }
 
 // src/discovery/shared-props.ts
-var import_node_path3 = require("path");
-var import_ts_morph = require("ts-morph");
-function discoverSharedProps(project, moduleEntry) {
-  try {
-    let sourceFile = project.getSourceFile(moduleEntry);
-    if (!sourceFile) {
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var import_ts_morph13 = require("ts-morph");
+
+// src/discovery/contracts-fast.ts
+var import_node_fs2 = require("fs");
+var import_node_path4 = require("path");
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_ts_morph12 = require("ts-morph");
+
+// src/discovery/disk-fingerprints.ts
+var import_node_fs = require("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 = (0, import_node_fs.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 ?? (0, import_node_path3.join)(config.codegen.cwd, "tsconfig.json");
-    let project;
-    try {
-      project = new import_ts_morph.Project({
-        tsConfigFilePath: tsconfigPath,
-        skipAddingFilesFromTsConfig: true,
-        skipLoadingLibFiles: true,
-        skipFileDependencyResolution: true
-      });
-    } catch {
-      project = new import_ts_morph.Project({
-        skipAddingFilesFromTsConfig: true,
-        skipLoadingLibFiles: true,
-        skipFileDependencyResolution: true,
-        compilerOptions: { allowJs: true, strict: false }
-      });
-    }
-    return discoverSharedProps(project, config.app.moduleEntry);
-  } catch {
-    return null;
-  }
-}
-function findForRootCall(sourceFile) {
-  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.CallExpression);
-  for (const call of callExpressions) {
-    const expr = call.getExpression();
-    if (!import_ts_morph.Node.isPropertyAccessExpression(expr)) continue;
-    const methodName = expr.getName();
-    const objectExpr = expr.getExpression();
-    if (methodName === "forRoot" && import_ts_morph.Node.isIdentifier(objectExpr)) {
-      const name = objectExpr.getText();
-      if (name === "InertiaModule") {
-        return call;
-      }
-    }
-  }
-  return null;
-}
-function findShareInitializer(forRootCall) {
-  if (!import_ts_morph.Node.isCallExpression(forRootCall)) return null;
-  const args = forRootCall.getArguments();
-  const firstArg2 = args[0];
-  if (!firstArg2 || !import_ts_morph.Node.isObjectLiteralExpression(firstArg2)) return null;
-  for (const prop of firstArg2.getProperties()) {
-    if (import_ts_morph.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
-      return prop.getInitializer() ?? null;
-    }
-  }
-  return null;
-}
-function extractShareType(node, sourceFile, project) {
-  if (import_ts_morph.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 (import_ts_morph.Node.isArrowFunction(node)) {
-    const result = extractFromFunctionLike(node, sourceFile);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  if (import_ts_morph.Node.isFunctionExpression(node)) {
-    const result = extractFromFunctionLike(node, sourceFile);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  if (import_ts_morph.Node.isObjectLiteralExpression(node)) {
-    const result = extractFromObjectLiteral(node);
-    return result ? { ...result, isImportRef: false } : null;
-  }
-  return null;
-}
-function resolveIdentifierToImportRef(id, sourceFile, project) {
-  if (!import_ts_morph.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 = import_ts_morph.Node.isArrowFunction(node) || import_ts_morph.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
-  if (returnTypeNode) {
-    return extractFromReturnTypeAnnotation(returnTypeNode);
-  }
-  if (import_ts_morph.Node.isArrowFunction(node)) {
-    const body = node.getBody();
-    if (import_ts_morph.Node.isParenthesizedExpression(body)) {
-      const inner = body.getExpression();
-      if (import_ts_morph.Node.isObjectLiteralExpression(inner)) {
-        return extractFromObjectLiteral(inner);
-      }
-    }
-    if (import_ts_morph.Node.isObjectLiteralExpression(body)) {
-      return extractFromObjectLiteral(body);
-    }
-    if (import_ts_morph.Node.isBlock(body)) {
-      return extractFromBlockReturn(body);
-    }
-  }
-  if (import_ts_morph.Node.isFunctionExpression(node)) {
-    const body = node.getBody();
-    if (import_ts_morph.Node.isBlock(body)) {
-      return extractFromBlockReturn(body);
-    }
-  }
-  return null;
-}
-function extractFromReturnTypeAnnotation(typeNode) {
-  if (import_ts_morph.Node.isTypeReference(typeNode)) {
-    const typeName = typeNode.getTypeName();
-    if (import_ts_morph.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 (import_ts_morph.Node.isTypeLiteral(typeNode)) {
-    const properties = [];
-    for (const member of typeNode.getMembers()) {
-      if (import_ts_morph.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 = (0, import_node_fs.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 (!import_ts_morph.Node.isBlock(block)) return null;
-  const statements = block.getStatements();
-  for (let i = statements.length - 1; i >= 0; i--) {
-    const stmt = statements[i];
-    if (!import_ts_morph.Node.isReturnStatement(stmt)) continue;
-    const expr = stmt.getExpression();
-    if (!expr) continue;
-    if (import_ts_morph.Node.isObjectLiteralExpression(expr)) {
-      return extractFromObjectLiteral(expr);
-    }
-    if (import_ts_morph.Node.isParenthesizedExpression(expr)) {
-      const inner = expr.getExpression();
-      if (import_ts_morph.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 (!import_ts_morph.Node.isObjectLiteralExpression(objLiteral)) return null;
-  const properties = [];
-  for (const prop of objLiteral.getProperties()) {
-    if (!import_ts_morph.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 (import_ts_morph.Node.isStringLiteral(node)) return "string";
-  if (import_ts_morph.Node.isTemplateExpression(node) || import_ts_morph.Node.isNoSubstitutionTemplateLiteral(node))
-    return "string";
-  if (import_ts_morph.Node.isNumericLiteral(node)) return "number";
-  if (node.getKind() === import_ts_morph.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph.SyntaxKind.FalseKeyword) {
-    return "boolean";
-  }
-  if (node.getKind() === import_ts_morph.SyntaxKind.NullKeyword) return "null";
-  if (import_ts_morph.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
-  if (import_ts_morph.Node.isObjectLiteralExpression(node)) {
-    const props = node.getProperties();
-    if (props.length === 0) return "Record<string, unknown>";
-    const entries = [];
-    for (const prop of props) {
-      if (!import_ts_morph.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("; ")} }`;
-  }
-  if (import_ts_morph.Node.isArrayLiteralExpression(node)) {
-    const elements = node.getElements();
-    if (elements.length === 0) return "Array<unknown>";
-    const first = elements[0];
-    if (first) return `Array<${inferExpressionType(first)}>`;
-    return "Array<unknown>";
-  }
-  if (import_ts_morph.Node.isConditionalExpression(node)) {
-    const whenTrue = inferExpressionType(node.getWhenTrue());
-    const whenFalse = inferExpressionType(node.getWhenFalse());
-    if (whenTrue === whenFalse) return whenTrue;
-    return `${whenTrue} | ${whenFalse}`;
-  }
-  if (import_ts_morph.Node.isParenthesizedExpression(node)) {
-    return inferExpressionType(node.getExpression());
+    return changed;
   }
-  if (import_ts_morph.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
-var import_promises3 = require("fs/promises");
-var import_node_path7 = require("path");
-
-// src/extension/registry.ts
-var import_node_path6 = require("path");
-var import_ts_morph13 = require("ts-morph");
-
-// src/discovery/contracts-fast.ts
-var import_node_fs = require("fs");
-var import_node_path5 = require("path");
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-var import_ts_morph12 = require("ts-morph");
+};
 
 // src/discovery/dto-type-resolver.ts
 var import_ts_morph11 = require("ts-morph");
 
 // src/discovery/dto-to-ir.ts
-var import_ts_morph3 = require("ts-morph");
+var import_ts_morph2 = require("ts-morph");
 
 // src/util/debug-log.ts
 var debugEnabled = false;
@@ -699,8 +466,8 @@ function debugWarn(message) {
 }
 
 // src/discovery/type-ref-resolution.ts
-var import_node_path4 = require("path");
-var import_ts_morph2 = require("ts-morph");
+var import_node_path3 = require("path");
+var import_ts_morph = require("ts-morph");
 var _EMPTY_CTX = { projectRoot: "", tsconfigPaths: null };
 var _ctxByProject = /* @__PURE__ */ new WeakMap();
 function setDiscoveryContext(project, ctx) {
@@ -741,17 +508,17 @@ function findTypeInFile(name, file) {
 }
 function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
   if (moduleSpecifier.startsWith(".")) {
-    const dir = (0, import_node_path4.dirname)(sourceFile.getFilePath());
+    const dir = (0, import_node_path3.dirname)(sourceFile.getFilePath());
     const ext = /\.(c|m)?(j|t)sx?$/.exec(moduleSpecifier)?.[0];
     const base = ext ? moduleSpecifier.slice(0, -ext.length) : moduleSpecifier;
     const flavour = ext?.startsWith(".c") ? "c" : ext?.startsWith(".m") ? "m" : "";
     const candidates = [
-      (0, import_node_path4.resolve)(dir, `${base}.${flavour}ts`),
-      ...flavour === "" ? [(0, import_node_path4.resolve)(dir, `${base}.tsx`)] : [],
-      (0, import_node_path4.resolve)(dir, `${moduleSpecifier}.ts`),
-      (0, import_node_path4.resolve)(dir, moduleSpecifier, "index.ts"),
-      (0, import_node_path4.resolve)(dir, `${base}.d.${flavour}ts`),
-      ...ext === void 0 ? [(0, import_node_path4.resolve)(dir, moduleSpecifier, "index.d.ts")] : []
+      (0, import_node_path3.resolve)(dir, `${base}.${flavour}ts`),
+      ...flavour === "" ? [(0, import_node_path3.resolve)(dir, `${base}.tsx`)] : [],
+      (0, import_node_path3.resolve)(dir, `${moduleSpecifier}.ts`),
+      (0, import_node_path3.resolve)(dir, moduleSpecifier, "index.ts"),
+      (0, import_node_path3.resolve)(dir, `${base}.d.${flavour}ts`),
+      ...ext === void 0 ? [(0, import_node_path3.resolve)(dir, moduleSpecifier, "index.d.ts")] : []
     ];
     return [...new Set(candidates)];
   }
@@ -773,8 +540,8 @@ function resolveModuleSpecifier(moduleSpecifier, sourceFile, project) {
         const rest = moduleSpecifier.slice(prefix.length);
         const candidates = [];
         for (const mapping of mappings) {
-          const resolved = (0, import_node_path4.resolve)(baseUrl, mapping.replace("*", rest));
-          candidates.push(`${resolved}.ts`, (0, import_node_path4.resolve)(resolved, "index.ts"));
+          const resolved = (0, import_node_path3.resolve)(baseUrl, mapping.replace("*", rest));
+          candidates.push(`${resolved}.ts`, (0, import_node_path3.resolve)(resolved, "index.ts"));
         }
         dbg("  resolved candidates:", candidates);
         return candidates;
@@ -965,13 +732,13 @@ function resolveTypeRef(nodeOrName, sourceFile, project, opts) {
     name = nodeOrName;
   } else {
     const typeNode = nodeOrName;
-    if (opts.unwrapContainers && import_ts_morph2.Node.isArrayTypeNode(typeNode)) {
+    if (opts.unwrapContainers && import_ts_morph.Node.isArrayTypeNode(typeNode)) {
       const inner = resolveTypeRef(typeNode.getElementTypeNode(), sourceFile, project, opts);
       return inner ? { ...inner, isArray: true } : null;
     }
-    if (!import_ts_morph2.Node.isTypeReference(typeNode)) return null;
+    if (!import_ts_morph.Node.isTypeReference(typeNode)) return null;
     const typeName = typeNode.getTypeName();
-    const refName = import_ts_morph2.Node.isIdentifier(typeName) ? typeName.getText() : null;
+    const refName = import_ts_morph.Node.isIdentifier(typeName) ? typeName.getText() : null;
     if (!refName) return null;
     if (opts.unwrapContainers && refName === "Promise") {
       const first = typeNode.getTypeArguments()[0];
@@ -1105,7 +872,7 @@ function buildProperty(prop, classFile, ctx) {
   const dec = (n) => decorators.get(n);
   const typeNode = prop.getTypeNode();
   const typeText = typeNode?.getText() ?? "unknown";
-  const isArrayType = !!typeNode && import_ts_morph3.Node.isArrayTypeNode(typeNode);
+  const isArrayType = !!typeNode && import_ts_morph2.Node.isArrayTypeNode(typeNode);
   const asField = (child) => applyPresence(
     has("IsArray") || isArrayType ? { kind: "array", element: child } : child,
     decorators
@@ -1319,22 +1086,22 @@ function firstArgText(decorator) {
 }
 function numericArg(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph3.Node.isNumericLiteral(arg)) return arg.getText();
+  if (arg && import_ts_morph2.Node.isNumericLiteral(arg)) return arg.getText();
   return null;
 }
 function numericArgs(decorator) {
   const args = decorator?.getArguments() ?? [];
-  const num = (n) => n && import_ts_morph3.Node.isNumericLiteral(n) ? n.getText() : null;
+  const num = (n) => n && import_ts_morph2.Node.isNumericLiteral(n) ? n.getText() : null;
   return [num(args[0]), num(args[1])];
 }
 function messageRaw(decorator) {
   const args = decorator?.getArguments() ?? [];
   for (const arg of args) {
-    if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph2.Node.isObjectLiteralExpression(arg)) {
       for (const prop of arg.getProperties()) {
-        if (import_ts_morph3.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
+        if (import_ts_morph2.Node.isPropertyAssignment(prop) && prop.getName() === "message") {
           const init = prop.getInitializer();
-          if (init && import_ts_morph3.Node.isStringLiteral(init)) return init.getText();
+          if (init && import_ts_morph2.Node.isStringLiteral(init)) return init.getText();
         }
       }
     }
@@ -1343,30 +1110,30 @@ function messageRaw(decorator) {
 }
 function resolveDiscriminator(decorator) {
   const optsArg = decorator?.getArguments()[1];
-  if (!optsArg || !import_ts_morph3.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph2.Node.isObjectLiteralExpression(optsArg)) return null;
   let discProp;
   for (const prop of optsArg.getProperties()) {
-    if (import_ts_morph3.Node.isPropertyAssignment(prop) && prop.getName() === "discriminator") {
+    if (import_ts_morph2.Node.isPropertyAssignment(prop) && prop.getName() === "discriminator") {
       discProp = prop.getInitializer();
     }
   }
-  if (!discProp || !import_ts_morph3.Node.isObjectLiteralExpression(discProp)) return null;
+  if (!discProp || !import_ts_morph2.Node.isObjectLiteralExpression(discProp)) return null;
   let property = null;
   const subTypes = [];
   for (const prop of discProp.getProperties()) {
-    if (!import_ts_morph3.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph2.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
     const init = prop.getInitializer();
     if (!init) continue;
-    if (name === "property" && import_ts_morph3.Node.isStringLiteral(init)) {
+    if (name === "property" && import_ts_morph2.Node.isStringLiteral(init)) {
       property = init.getLiteralValue();
-    } else if (name === "subTypes" && import_ts_morph3.Node.isArrayLiteralExpression(init)) {
+    } else if (name === "subTypes" && import_ts_morph2.Node.isArrayLiteralExpression(init)) {
       for (const el of init.getElements()) {
-        if (!import_ts_morph3.Node.isObjectLiteralExpression(el)) continue;
+        if (!import_ts_morph2.Node.isObjectLiteralExpression(el)) continue;
         for (const p of el.getProperties()) {
-          if (!import_ts_morph3.Node.isPropertyAssignment(p) || p.getName() !== "name") continue;
+          if (!import_ts_morph2.Node.isPropertyAssignment(p) || p.getName() !== "name") continue;
           const nameInit = p.getInitializer();
-          if (nameInit && import_ts_morph3.Node.isIdentifier(nameInit)) subTypes.push(nameInit.getText());
+          if (nameInit && import_ts_morph2.Node.isIdentifier(nameInit)) subTypes.push(nameInit.getText());
         }
       }
     }
@@ -1377,9 +1144,9 @@ function resolveDiscriminator(decorator) {
 function resolveTypeFactoryName(decorator) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph3.Node.isArrowFunction(arg)) {
+  if (import_ts_morph2.Node.isArrowFunction(arg)) {
     const body = arg.getBody();
-    if (import_ts_morph3.Node.isIdentifier(body)) return body.getText();
+    if (import_ts_morph2.Node.isIdentifier(body)) return body.getText();
   }
   return null;
 }
@@ -1388,12 +1155,12 @@ function singularClassName(typeText) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(inner) ? inner : null;
 }
 function genericTypeArgNames(typeNode) {
-  if (!typeNode || !import_ts_morph3.Node.isTypeReference(typeNode)) return [];
+  if (!typeNode || !import_ts_morph2.Node.isTypeReference(typeNode)) return [];
   const names = [];
   for (const arg of typeNode.getTypeArguments()) {
-    if (!import_ts_morph3.Node.isTypeReference(arg)) return [];
+    if (!import_ts_morph2.Node.isTypeReference(arg)) return [];
     const tn = arg.getTypeName();
-    if (!import_ts_morph3.Node.isIdentifier(tn)) return [];
+    if (!import_ts_morph2.Node.isIdentifier(tn)) return [];
     names.push(tn.getText());
   }
   return names;
@@ -1401,7 +1168,7 @@ function genericTypeArgNames(typeNode) {
 function enumSchemaFromDecorator(decorator, classFile, ctx) {
   const arg = firstArg(decorator);
   if (!arg) return null;
-  if (import_ts_morph3.Node.isIdentifier(arg)) {
+  if (import_ts_morph2.Node.isIdentifier(arg)) {
     const name = arg.getText();
     const resolved = findType(name, classFile, ctx.project);
     if (resolved && resolved.kind === "enum") {
@@ -1415,12 +1182,12 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
     }
     return { kind: "unknown", note: `@IsEnum(${name}): enum not resolvable to literals` };
   }
-  if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
+  if (import_ts_morph2.Node.isObjectLiteralExpression(arg)) {
     const values = [];
     for (const p of arg.getProperties()) {
-      if (!import_ts_morph3.Node.isPropertyAssignment(p)) continue;
+      if (!import_ts_morph2.Node.isPropertyAssignment(p)) continue;
       const init = p.getInitializer();
-      if (init && import_ts_morph3.Node.isStringLiteral(init)) values.push(init.getText());
+      if (init && import_ts_morph2.Node.isStringLiteral(init)) values.push(init.getText());
     }
     if (values.length > 0) return { kind: "enum", literals: values };
   }
@@ -1428,9 +1195,9 @@ function enumSchemaFromDecorator(decorator, classFile, ctx) {
 }
 function inSchemaFromDecorator(decorator) {
   const arg = firstArg(decorator);
-  if (arg && import_ts_morph3.Node.isArrayLiteralExpression(arg)) {
+  if (arg && import_ts_morph2.Node.isArrayLiteralExpression(arg)) {
     const elements = arg.getElements();
-    const allStrings = elements.every((e) => import_ts_morph3.Node.isStringLiteral(e));
+    const allStrings = elements.every((e) => import_ts_morph2.Node.isStringLiteral(e));
     if (allStrings && elements.length > 0) {
       return { kind: "enum", literals: elements.map((e) => e.getText()) };
     }
@@ -1448,7 +1215,7 @@ function inSchemaFromDecorator(decorator) {
 var import_ts_morph6 = require("ts-morph");
 
 // src/discovery/filter-field-types.ts
-var import_ts_morph4 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
 
 // src/discovery/enum-resolution.ts
 var _enumCache = /* @__PURE__ */ new WeakMap();
@@ -1501,28 +1268,28 @@ function markNullable(r, nullable) {
 }
 var TRANSPARENT_TYPE_BRANDS = /* @__PURE__ */ new Set(["Opt", "Hidden"]);
 function classifyTypeNode(typeNode, sourceFile, project, opts) {
-  if (import_ts_morph4.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph3.Node.isUnionTypeNode(typeNode)) {
     let nullable = false;
     const stringLits = [];
     const numberLits = [];
     const others = [];
     for (const member of typeNode.getTypeNodes()) {
       const kind = member.getKind();
-      if (kind === import_ts_morph4.SyntaxKind.NullKeyword || kind === import_ts_morph4.SyntaxKind.UndefinedKeyword) {
+      if (kind === import_ts_morph3.SyntaxKind.NullKeyword || kind === import_ts_morph3.SyntaxKind.UndefinedKeyword) {
         nullable = true;
         continue;
       }
-      if (import_ts_morph4.Node.isLiteralTypeNode(member)) {
+      if (import_ts_morph3.Node.isLiteralTypeNode(member)) {
         const lit = member.getLiteral();
-        if (import_ts_morph4.Node.isStringLiteral(lit)) {
+        if (import_ts_morph3.Node.isStringLiteral(lit)) {
           stringLits.push(lit.getLiteralValue());
           continue;
         }
-        if (import_ts_morph4.Node.isNumericLiteral(lit)) {
+        if (import_ts_morph3.Node.isNumericLiteral(lit)) {
           numberLits.push(lit.getText());
           continue;
         }
-        if (lit.getKind() === import_ts_morph4.SyntaxKind.NullKeyword) {
+        if (lit.getKind() === import_ts_morph3.SyntaxKind.NullKeyword) {
           nullable = true;
           continue;
         }
@@ -1542,19 +1309,19 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     return markNullable({ kind: "unknown" }, nullable);
   }
   switch (typeNode.getKind()) {
-    case import_ts_morph4.SyntaxKind.StringKeyword:
+    case import_ts_morph3.SyntaxKind.StringKeyword:
       return { kind: "string" };
-    case import_ts_morph4.SyntaxKind.NumberKeyword:
+    case import_ts_morph3.SyntaxKind.NumberKeyword:
       return { kind: "number" };
-    case import_ts_morph4.SyntaxKind.BooleanKeyword:
+    case import_ts_morph3.SyntaxKind.BooleanKeyword:
       return { kind: "boolean" };
-    case import_ts_morph4.SyntaxKind.AnyKeyword:
-    case import_ts_morph4.SyntaxKind.UnknownKeyword:
+    case import_ts_morph3.SyntaxKind.AnyKeyword:
+    case import_ts_morph3.SyntaxKind.UnknownKeyword:
       return { kind: "unknown" };
     default:
       break;
   }
-  if (import_ts_morph4.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph3.Node.isTypeReference(typeNode)) {
     const refName = typeNode.getTypeName().getText();
     if (refName === "Date") return { kind: "date" };
     if (refName === "Record" || refName === "Object") return { kind: "json" };
@@ -1572,25 +1339,25 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     if (typeRef) return { kind: "unknown", typeRef };
     return { kind: "unknown" };
   }
-  if (import_ts_morph4.Node.isTypeLiteral(typeNode)) return { kind: "json" };
+  if (import_ts_morph3.Node.isTypeLiteral(typeNode)) return { kind: "json" };
   return { kind: "unknown" };
 }
 function enumFromDecoratorArgs(args, sourceFile, project) {
   for (const arg of args) {
-    if (import_ts_morph4.Node.isArrowFunction(arg)) {
+    if (import_ts_morph3.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph4.Node.isIdentifier(body)) {
+      if (import_ts_morph3.Node.isIdentifier(body)) {
         const en = resolveEnumValues(body.getText(), sourceFile, project);
         if (en) return en;
       }
     }
-    if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
       const itemsProp = arg.getProperty("items");
-      if (itemsProp && import_ts_morph4.Node.isPropertyAssignment(itemsProp)) {
+      if (itemsProp && import_ts_morph3.Node.isPropertyAssignment(itemsProp)) {
         const init = itemsProp.getInitializer();
-        if (init && import_ts_morph4.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph3.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph4.Node.isIdentifier(body)) {
+          if (import_ts_morph3.Node.isIdentifier(body)) {
             const en = resolveEnumValues(body.getText(), sourceFile, project);
             if (en) return en;
           }
@@ -1613,7 +1380,7 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
       return { kind: "string" };
     }
     for (const arg of args) {
-      if (import_ts_morph4.Node.isStringLiteral(arg)) {
+      if (import_ts_morph3.Node.isStringLiteral(arg)) {
         const raw = arg.getLiteralValue();
         const kind = classifyTypeKeyword(raw);
         if (kind) {
@@ -1621,11 +1388,11 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
           return { kind };
         }
       }
-      if (import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
+      if (import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
         const enumProp = arg.getProperty("enum");
-        if (enumProp && import_ts_morph4.Node.isPropertyAssignment(enumProp)) {
+        if (enumProp && import_ts_morph3.Node.isPropertyAssignment(enumProp)) {
           const init = enumProp.getInitializer();
-          if (init && import_ts_morph4.Node.isIdentifier(init)) {
+          if (init && import_ts_morph3.Node.isIdentifier(init)) {
             const en = resolveEnumValues(init.getText(), sourceFile, project);
             if (en) {
               return en.numeric ? { kind: "number", enumValues: en.values, numericEnum: true } : { kind: "string", enumValues: en.values };
@@ -1635,15 +1402,15 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
         }
         for (const key of ["columnType", "type"]) {
           const typeProp = arg.getProperty(key);
-          if (!typeProp || !import_ts_morph4.Node.isPropertyAssignment(typeProp)) continue;
+          if (!typeProp || !import_ts_morph3.Node.isPropertyAssignment(typeProp)) continue;
           const init = typeProp.getInitializer();
           if (!init) continue;
-          if (import_ts_morph4.Node.isStringLiteral(init)) {
+          if (import_ts_morph3.Node.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
             continue;
           }
-          if (import_ts_morph4.Node.isIdentifier(init)) {
+          if (import_ts_morph3.Node.isIdentifier(init)) {
             const kind = classifyTypeKeyword(init.getText());
             if (kind) return { kind };
           }
@@ -1686,6 +1453,49 @@ function toFilterFieldType(name, r) {
 
 // src/discovery/heritage.ts
 var import_ts_morph5 = require("ts-morph");
+
+// src/discovery/unresolved-imports.ts
+var import_ts_morph4 = require("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 = import_ts_morph4.ts.resolveModuleName(specifier, from, options, import_ts_morph4.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 (!import_ts_morph4.ts.isImportDeclaration(statement) && !import_ts_morph4.ts.isExportDeclaration(statement)) continue;
+      const specifier = statement.moduleSpecifier;
+      if (!specifier || !import_ts_morph4.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);
@@ -1885,15 +1695,42 @@ function resolvePropertyClassReference(prop) {
   return { key, ref };
 }
 var mixinTypeProject;
+var mixinFiles = new DiskFingerprints();
+var mixinStale = false;
+var mixinUnresolved = new UnresolvedImports();
 function getMixinTypeProject() {
-  mixinTypeProject ??= new import_ts_morph5.Project({
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: { strict: true }
-  });
+  if (mixinTypeProject && mixinStale && !refreshMixinTypeProject(mixinTypeProject)) {
+    mixinTypeProject = void 0;
+  }
+  mixinStale = false;
+  if (!mixinTypeProject) {
+    mixinTypeProject = new import_ts_morph5.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() !== import_ts_morph5.FileSystemRefreshResult.Updated) return false;
+  }
+  project.resolveSourceFileDependencies();
+  return true;
 }
 function resolveInstantiatedReturnType(cls, methodName) {
   const filePath = cls.getSourceFile().getFilePath();
@@ -2251,8 +2088,7 @@ var SchemaTypeProgram = class {
       skipAddingFilesFromTsConfig: true,
       compilerOptions: this.options
     });
-    for (const sf of discovery.getSourceFiles()) this.request(sf.getFilePath(), { schema: true });
-    this.flush();
+    this.requestDiscoveryFiles();
   }
   project;
   options;
@@ -2265,6 +2101,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() === import_ts_morph7.FileSystemRefreshResult.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
@@ -2305,12 +2188,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);
     }
@@ -2319,11 +2211,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());
@@ -2376,7 +2286,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) => ({
@@ -2390,21 +2300,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;
       }
@@ -2412,13 +2325,14 @@ 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 = import_ts_morph7.ts.resolveModuleName(
@@ -2427,7 +2341,8 @@ var SchemaTypeProgram = class {
       this.options,
       import_ts_morph7.ts.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;
@@ -2482,8 +2397,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);
@@ -2492,6 +2412,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();
@@ -3439,7 +3363,7 @@ async function discoverContractsFast(opts) {
   return routes;
 }
 function resolveTsconfigPath(cwd, tsconfig) {
-  return tsconfig ? (0, import_node_path5.resolve)(tsconfig) : (0, import_node_path5.join)(cwd, "tsconfig.json");
+  return tsconfig ? (0, import_node_path4.resolve)(tsconfig) : (0, import_node_path4.join)(cwd, "tsconfig.json");
 }
 var NO_TSCONFIG_OPTIONS = {
   allowJs: true,
@@ -3447,7 +3371,7 @@ var NO_TSCONFIG_OPTIONS = {
   strict: false
 };
 function loadDiscoveryTsconfig(tsconfigPath) {
-  if (!(0, import_node_fs.existsSync)(tsconfigPath)) return { options: null, files: [] };
+  if (!(0, import_node_fs2.existsSync)(tsconfigPath)) return { options: null, files: [] };
   const read = import_ts_morph12.ts.readConfigFile(tsconfigPath, (path) => import_ts_morph12.ts.sys.readFile(path));
   if (read.error) {
     return {
@@ -3469,7 +3393,7 @@ function loadDiscoveryTsconfig(tsconfigPath) {
   const parsed = import_ts_morph12.ts.parseJsonSourceFileConfigFileContent(
     sourceFile,
     host,
-    (0, import_node_path5.dirname)(tsconfigPath),
+    (0, import_node_path4.dirname)(tsconfigPath),
     void 0,
     tsconfigPath
   );
@@ -3531,6 +3455,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;
@@ -3556,6 +3483,8 @@ var PersistentDiscovery = class _PersistentDiscovery {
   }
   /** Run the initial extraction (equivalent to a first `discoverContractsFast`). */
   discover() {
+    clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return this.runExtraction();
   }
   /**
@@ -3563,26 +3492,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 = (0, import_node_path5.resolve)(p);
-        const sf = this.project.getSourceFile(abs);
-        if (sf) {
-          await sf.refreshFromFileSystem();
-        }
+  async rediscover(changedPaths, options = {}) {
+    const hinted = new Set([...changedPaths ?? []].map((p) => (0, import_node_path4.resolve)(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() === import_ts_morph12.FileSystemRefreshResult.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 (0, import_fast_glob2.default)(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 {
         }
       }
@@ -3592,16 +3534,22 @@ 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);
   }
 };
@@ -3751,144 +3699,437 @@ function extractContractRoute(args) {
       if (contractDef.body !== null) {
         bodyZodRef = { name: `${identName}.body`, filePath };
       }
-      if (contractDef.query !== null) {
-        queryZodRef = { name: `${identName}.query`, filePath };
+      if (contractDef.query !== null) {
+        queryZodRef = { name: `${identName}.query`, filePath };
+      }
+    }
+  } else {
+    console.warn(
+      `[nestjs-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`
+    );
+    return null;
+  }
+  if (!contractDef) return null;
+  if (!verb) return null;
+  const resolvedPath = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: resolvedPath,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    mixin,
+    contractSource: {
+      query: contractDef.query,
+      body: contractDef.body,
+      response: contractDef.response,
+      error: contractDef.error,
+      // Path A: capture both the importable ref and the raw text. The emitter
+      // prefers inlining the text (client-safe — re-exporting from a controller
+      // would drag server-only deps into the client bundle).
+      bodyZodRef,
+      bodyZodText: contractDef.bodyZodText,
+      queryZodRef,
+      queryZodText: contractDef.queryZodText
+    }
+  });
+}
+function extractDtoRoute(args) {
+  const { cls, method, verb, prefix, className, sourceFile, project, seenNames, mixin } = args;
+  if (!verb) return null;
+  const combined = joinPaths(prefix, verb.handlerPath);
+  const methodName = method.getName();
+  const classAs = readAsDecorator(cls, `class ${className}`);
+  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
+  const dtoContract = extractDtoContract(method, method.getSourceFile(), project, mixin, cls);
+  const mixinResponse = mixin ? resolveInstantiatedReturnType(cls, methodName) : void 0;
+  return buildRoute({
+    className,
+    methodName,
+    resolvedMethod: verb.httpMethod,
+    combinedPath: combined,
+    classAs,
+    methodAs,
+    sourceFile,
+    seenNames,
+    mixin,
+    contractSource: {
+      query: dtoContract?.query ?? null,
+      body: dtoContract?.body ?? null,
+      response: mixinResponse ?? dtoContract?.response ?? "unknown",
+      error: dtoContract?.error ?? null,
+      paramTypes: dtoContract?.paramTypes ?? null,
+      queryRef: dtoContract?.queryRef ?? null,
+      bodyRef: dtoContract?.bodyRef ?? null,
+      responseRef: dtoContract?.responseRef ?? null,
+      errorRef: dtoContract?.errorRef ?? null,
+      filterFields: dtoContract?.filterFields ?? null,
+      filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
+      filterSource: dtoContract?.filterSource ?? null,
+      formWarnings: dtoContract?.formWarnings ?? [],
+      bodySchema: dtoContract?.bodySchema ?? null,
+      querySchema: dtoContract?.querySchema ?? null,
+      stream: dtoContract?.stream ?? false,
+      multipart: dtoContract?.multipart ?? false,
+      multipartBody: dtoContract?.multipartBody ?? null,
+      binaryResponse: dtoContract?.binaryResponse ?? false,
+      asQuery: dtoContract?.asQuery ?? false
+    }
+  });
+}
+function extractFromSourceFile(sourceFile, project) {
+  const routes = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const cls of sourceFile.getClasses()) {
+    const controllerDecorator = cls.getDecorator("Controller");
+    if (!controllerDecorator) continue;
+    const firstArg2 = controllerDecorator.getArguments()[0];
+    const prefix = decoratorStringArg(firstArg2) ?? "";
+    const className = cls.getName() ?? "Unknown";
+    const inherited = resolveInheritedMethods(cls);
+    const mixinBinding = inherited ? {
+      factoryName: inherited.factoryName,
+      factoryFilePath: inherited.factoryFilePath,
+      classArgs: inherited.classArgs,
+      namedClassArgs: inherited.namedClassArgs
+    } : void 0;
+    const ownMethods = cls.getMethods();
+    const ownNames = new Set(ownMethods.map((m) => m.getName()));
+    const methods = [
+      ...ownMethods.map((method) => ({ method, mixin: mixinBinding })),
+      ...(inherited?.methods ?? []).filter((method) => !ownNames.has(method.getName())).map((method) => ({ method, mixin: mixinBinding }))
+    ];
+    for (const { method, mixin } of methods) {
+      const verb = resolveVerb(method);
+      const applyContractDecorator = method.getDecorator("ApplyContract");
+      const route = applyContractDecorator ? extractContractRoute({
+        cls,
+        method,
+        applyContractDecorator,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        project,
+        seenNames,
+        mixin
+      }) : extractDtoRoute({
+        cls,
+        method,
+        verb,
+        prefix,
+        className,
+        sourceFile,
+        project,
+        seenNames,
+        mixin
+      });
+      if (route) routes.push(route);
+    }
+  }
+  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 ?? (0, import_node_path5.join)(config.codegen.cwd, "tsconfig.json");
+    let project;
+    try {
+      project = sharedPropsProject(tsconfigPath);
+    } catch {
+      project = new import_ts_morph13.Project({
+        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 (0, import_node_fs3.readFileSync)(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 import_ts_morph13.Project({ ...flags, compilerOptions: parsed.options });
+  const project = new import_ts_morph13.Project({ ...flags, tsConfigFilePath: tsconfigPath });
+  parsedTsconfigs.set(tsconfigPath, { text, options: project.getCompilerOptions() });
+  return project;
+}
+function findForRootCall(sourceFile) {
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph13.SyntaxKind.CallExpression);
+  for (const call of callExpressions) {
+    const expr = call.getExpression();
+    if (!import_ts_morph13.Node.isPropertyAccessExpression(expr)) continue;
+    const methodName = expr.getName();
+    const objectExpr = expr.getExpression();
+    if (methodName === "forRoot" && import_ts_morph13.Node.isIdentifier(objectExpr)) {
+      const name = objectExpr.getText();
+      if (name === "InertiaModule") {
+        return call;
+      }
+    }
+  }
+  return null;
+}
+function findShareInitializer(forRootCall) {
+  if (!import_ts_morph13.Node.isCallExpression(forRootCall)) return null;
+  const args = forRootCall.getArguments();
+  const firstArg2 = args[0];
+  if (!firstArg2 || !import_ts_morph13.Node.isObjectLiteralExpression(firstArg2)) return null;
+  for (const prop of firstArg2.getProperties()) {
+    if (import_ts_morph13.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
+      return prop.getInitializer() ?? null;
+    }
+  }
+  return null;
+}
+function extractShareType(node, sourceFile, project) {
+  if (import_ts_morph13.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 (import_ts_morph13.Node.isArrowFunction(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (import_ts_morph13.Node.isFunctionExpression(node)) {
+    const result = extractFromFunctionLike(node, sourceFile);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  if (import_ts_morph13.Node.isObjectLiteralExpression(node)) {
+    const result = extractFromObjectLiteral(node);
+    return result ? { ...result, isImportRef: false } : null;
+  }
+  return null;
+}
+function resolveIdentifierToImportRef(id, sourceFile, project) {
+  if (!import_ts_morph13.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 = import_ts_morph13.Node.isArrowFunction(node) || import_ts_morph13.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  if (returnTypeNode) {
+    return extractFromReturnTypeAnnotation(returnTypeNode);
+  }
+  if (import_ts_morph13.Node.isArrowFunction(node)) {
+    const body = node.getBody();
+    if (import_ts_morph13.Node.isParenthesizedExpression(body)) {
+      const inner = body.getExpression();
+      if (import_ts_morph13.Node.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    if (import_ts_morph13.Node.isObjectLiteralExpression(body)) {
+      return extractFromObjectLiteral(body);
+    }
+    if (import_ts_morph13.Node.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  if (import_ts_morph13.Node.isFunctionExpression(node)) {
+    const body = node.getBody();
+    if (import_ts_morph13.Node.isBlock(body)) {
+      return extractFromBlockReturn(body);
+    }
+  }
+  return null;
+}
+function extractFromReturnTypeAnnotation(typeNode) {
+  if (import_ts_morph13.Node.isTypeReference(typeNode)) {
+    const typeName = typeNode.getTypeName();
+    if (import_ts_morph13.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
+      const typeArgs = typeNode.getTypeArguments();
+      const firstArg2 = typeArgs[0];
+      if (firstArg2) {
+        return extractFromReturnTypeAnnotation(firstArg2);
       }
+      return null;
     }
-  } else {
-    console.warn(
-      `[nestjs-codegen/fast] @ApplyContract arg is not an identifier or call expression in ${sourceFile.getFilePath()} \u2014 skipping`
-    );
-    return null;
   }
-  if (!contractDef) return null;
-  if (!verb) return null;
-  const resolvedPath = joinPaths(prefix, verb.handlerPath);
-  const methodName = method.getName();
-  const classAs = readAsDecorator(cls, `class ${className}`);
-  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
-  return buildRoute({
-    className,
-    methodName,
-    resolvedMethod: verb.httpMethod,
-    combinedPath: resolvedPath,
-    classAs,
-    methodAs,
-    sourceFile,
-    seenNames,
-    mixin,
-    contractSource: {
-      query: contractDef.query,
-      body: contractDef.body,
-      response: contractDef.response,
-      error: contractDef.error,
-      // Path A: capture both the importable ref and the raw text. The emitter
-      // prefers inlining the text (client-safe — re-exporting from a controller
-      // would drag server-only deps into the client bundle).
-      bodyZodRef,
-      bodyZodText: contractDef.bodyZodText,
-      queryZodRef,
-      queryZodText: contractDef.queryZodText
+  if (import_ts_morph13.Node.isTypeLiteral(typeNode)) {
+    const properties = [];
+    for (const member of typeNode.getMembers()) {
+      if (import_ts_morph13.Node.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 extractDtoRoute(args) {
-  const { cls, method, verb, prefix, className, sourceFile, project, seenNames, mixin } = args;
-  if (!verb) return null;
-  const combined = joinPaths(prefix, verb.handlerPath);
-  const methodName = method.getName();
-  const classAs = readAsDecorator(cls, `class ${className}`);
-  const methodAs = readAsDecorator(method, `${className}.${methodName}`);
-  const dtoContract = extractDtoContract(method, method.getSourceFile(), project, mixin, cls);
-  const mixinResponse = mixin ? resolveInstantiatedReturnType(cls, methodName) : void 0;
-  return buildRoute({
-    className,
-    methodName,
-    resolvedMethod: verb.httpMethod,
-    combinedPath: combined,
-    classAs,
-    methodAs,
-    sourceFile,
-    seenNames,
-    mixin,
-    contractSource: {
-      query: dtoContract?.query ?? null,
-      body: dtoContract?.body ?? null,
-      response: mixinResponse ?? dtoContract?.response ?? "unknown",
-      error: dtoContract?.error ?? null,
-      paramTypes: dtoContract?.paramTypes ?? null,
-      queryRef: dtoContract?.queryRef ?? null,
-      bodyRef: dtoContract?.bodyRef ?? null,
-      responseRef: dtoContract?.responseRef ?? null,
-      errorRef: dtoContract?.errorRef ?? null,
-      filterFields: dtoContract?.filterFields ?? null,
-      filterFieldTypes: dtoContract?.filterFieldTypes ?? null,
-      filterSource: dtoContract?.filterSource ?? null,
-      formWarnings: dtoContract?.formWarnings ?? [],
-      bodySchema: dtoContract?.bodySchema ?? null,
-      querySchema: dtoContract?.querySchema ?? null,
-      stream: dtoContract?.stream ?? false,
-      multipart: dtoContract?.multipart ?? false,
-      multipartBody: dtoContract?.multipartBody ?? null,
-      binaryResponse: dtoContract?.binaryResponse ?? false,
-      asQuery: dtoContract?.asQuery ?? false
+function extractFromBlockReturn(block) {
+  if (!import_ts_morph13.Node.isBlock(block)) return null;
+  const statements = block.getStatements();
+  for (let i = statements.length - 1; i >= 0; i--) {
+    const stmt = statements[i];
+    if (!import_ts_morph13.Node.isReturnStatement(stmt)) continue;
+    const expr = stmt.getExpression();
+    if (!expr) continue;
+    if (import_ts_morph13.Node.isObjectLiteralExpression(expr)) {
+      return extractFromObjectLiteral(expr);
     }
-  });
+    if (import_ts_morph13.Node.isParenthesizedExpression(expr)) {
+      const inner = expr.getExpression();
+      if (import_ts_morph13.Node.isObjectLiteralExpression(inner)) {
+        return extractFromObjectLiteral(inner);
+      }
+    }
+    break;
+  }
+  return null;
 }
-function extractFromSourceFile(sourceFile, project) {
-  const routes = [];
-  const seenNames = /* @__PURE__ */ new Map();
-  for (const cls of sourceFile.getClasses()) {
-    const controllerDecorator = cls.getDecorator("Controller");
-    if (!controllerDecorator) continue;
-    const firstArg2 = controllerDecorator.getArguments()[0];
-    const prefix = decoratorStringArg(firstArg2) ?? "";
-    const className = cls.getName() ?? "Unknown";
-    const inherited = resolveInheritedMethods(cls);
-    const mixinBinding = inherited ? {
-      factoryName: inherited.factoryName,
-      factoryFilePath: inherited.factoryFilePath,
-      classArgs: inherited.classArgs,
-      namedClassArgs: inherited.namedClassArgs
-    } : void 0;
-    const ownMethods = cls.getMethods();
-    const ownNames = new Set(ownMethods.map((m) => m.getName()));
-    const methods = [
-      ...ownMethods.map((method) => ({ method, mixin: mixinBinding })),
-      ...(inherited?.methods ?? []).filter((method) => !ownNames.has(method.getName())).map((method) => ({ method, mixin: mixinBinding }))
-    ];
-    for (const { method, mixin } of methods) {
-      const verb = resolveVerb(method);
-      const applyContractDecorator = method.getDecorator("ApplyContract");
-      const route = applyContractDecorator ? extractContractRoute({
-        cls,
-        method,
-        applyContractDecorator,
-        verb,
-        prefix,
-        className,
-        sourceFile,
-        project,
-        seenNames,
-        mixin
-      }) : extractDtoRoute({
-        cls,
-        method,
-        verb,
-        prefix,
-        className,
-        sourceFile,
-        project,
-        seenNames,
-        mixin
-      });
-      if (route) routes.push(route);
+function extractFromObjectLiteral(objLiteral) {
+  if (!import_ts_morph13.Node.isObjectLiteralExpression(objLiteral)) return null;
+  const properties = [];
+  for (const prop of objLiteral.getProperties()) {
+    if (!import_ts_morph13.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 (import_ts_morph13.Node.isStringLiteral(node)) return "string";
+  if (import_ts_morph13.Node.isTemplateExpression(node) || import_ts_morph13.Node.isNoSubstitutionTemplateLiteral(node))
+    return "string";
+  if (import_ts_morph13.Node.isNumericLiteral(node)) return "number";
+  if (node.getKind() === import_ts_morph13.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph13.SyntaxKind.FalseKeyword) {
+    return "boolean";
+  }
+  if (node.getKind() === import_ts_morph13.SyntaxKind.NullKeyword) return "null";
+  if (import_ts_morph13.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
+  if (import_ts_morph13.Node.isObjectLiteralExpression(node)) {
+    const props = node.getProperties();
+    if (props.length === 0) return "Record<string, unknown>";
+    const entries = [];
+    for (const prop of props) {
+      if (!import_ts_morph13.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 routes;
+  if (import_ts_morph13.Node.isArrayLiteralExpression(node)) {
+    const elements = node.getElements();
+    if (elements.length === 0) return "Array<unknown>";
+    const first = elements[0];
+    if (first) return `Array<${inferExpressionType(first)}>`;
+    return "Array<unknown>";
+  }
+  if (import_ts_morph13.Node.isConditionalExpression(node)) {
+    const whenTrue = inferExpressionType(node.getWhenTrue());
+    const whenFalse = inferExpressionType(node.getWhenFalse());
+    if (whenTrue === whenFalse) return whenTrue;
+    return `${whenTrue} | ${whenFalse}`;
+  }
+  if (import_ts_morph13.Node.isParenthesizedExpression(node)) {
+    return inferExpressionType(node.getExpression());
+  }
+  if (import_ts_morph13.Node.isAsExpression(node)) {
+    const typeNode = node.getTypeNode();
+    if (typeNode) return typeNode.getText();
+  }
+  return "unknown";
 }
 
+// src/emit/emit-api.ts
+var import_promises3 = require("fs/promises");
+var import_node_path7 = require("path");
+
 // src/extension/registry.ts
+var import_node_path6 = require("path");
+var import_ts_morph14 = require("ts-morph");
 function resolveApiSlots(extensions) {
   let layer;
   let layerOwner;
@@ -3939,7 +4180,7 @@ function createExtensionContext(config, getRoutes, trackedInputs) {
     },
     project() {
       if (!project) {
-        project = new import_ts_morph13.Project({
+        project = new import_ts_morph14.Project({
           skipAddingFilesFromTsConfig: true,
           skipLoadingLibFiles: true,
           skipFileDependencyResolution: true,
@@ -5673,36 +5914,64 @@ async function discoverInputFiles(config) {
   const matched = await (0, import_fast_glob3.default)(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) => (0, import_promises11.readFile)(file, "utf8").catch(() => null)
+  );
+  for (const [file, text] of tsconfigs) contents.set(file, text);
+  for (const [file, text] of await readAll(files, (file2) => (0, import_promises11.readFile)(file2, "utf8"))) {
+    contents.set(file, text);
+  }
+  return { tsconfigFiles, files, contents, tracked: /* @__PURE__ */ new Map() };
+}
+async function readInput(snapshot, path) {
+  return snapshot.contents.get(path) ?? (0, import_promises11.readFile)(path, "utf8");
+}
+async function computeInputsHash(config, extraInputs = [], snapshot) {
+  const inputs = snapshot ?? await readInputs(config);
   const hash = (0, import_node_crypto.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 (0, import_promises11.readFile)(file, "utf8").catch(() => null);
+  for (const file of inputs.tsconfigFiles) {
     hash.update(`tsconfig:${(0, import_node_path15.relative)(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) => (0, import_node_path15.relative)(cwd, file)));
+  const globbedRelative = new Set(inputs.files.map((file) => (0, import_node_path15.relative)(cwd, file)));
   const extra = [...new Set(extraInputs)].filter((file) => !globbedRelative.has(file)).sort();
-  for (const file of globbed) {
-    const contents = await (0, import_promises11.readFile)(file, "utf8");
+  for (const file of inputs.files) {
     hash.update(`file:${(0, import_node_path15.relative)(cwd, file)}
 `);
-    hash.update(contents);
+    hash.update(inputs.contents.get(file));
     hash.update("\n");
   }
+  const unread = extra.map((file) => (0, import_node_path15.join)(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((0, import_node_path15.join)(cwd, file)));
+    hash.update(inputs.tracked.get((0, import_node_path15.join)(cwd, file)));
     hash.update("\n");
   }
   return hash.digest("hex");
@@ -5783,7 +6052,8 @@ 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;
@@ -5811,7 +6081,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,
@@ -5861,7 +6131,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,
@@ -6044,13 +6314,15 @@ async function watch(config, onChange, options = {}) {
   pagesWatcher.on("unlink", schedulePagesRegenerate);
   let contractsDebounceTimer;
   const pendingChangedPaths = /* @__PURE__ */ new Set();
+  let pendingAddedOrRemoved = false;
   const contractsWatcher = import_chokidar.default.watch((0, import_node_path18.join)(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);
     }
@@ -6058,8 +6330,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) {
@@ -6071,20 +6347,20 @@ 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 = import_chokidar.default.watch((0, import_node_path18.join)(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));
   return {
     close: async () => {
       if (pagesDebounceTimer !== void 0) {
@@ -6188,7 +6464,7 @@ function createChainModuleRenderer(opts) {
 }
 
 // src/extension/genui-sandbox-kit.ts
-var import_node_fs2 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path19 = require("path");
 var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 var GENUI_KIT_MODULE = "@dudousxd/nestjs-agent-core/genui/kit";
@@ -6200,6 +6476,12 @@ var DEFAULT_KIT_DIRS = [
   "app/components/ui",
   "components/ui"
 ];
+var LEGACY_OPTIONS = {
+  entry: "`entry: X` is now `components: X`",
+  include: "`include: G` is now `components: G` (globs, files, directories or packages)",
+  css: "`css: G` is now `styles: G` (the app's style entry files)"
+};
+var MIN_CORE = "0.53.0";
 async function loadKitModule(specifier = GENUI_KIT_MODULE) {
   let mod;
   try {
@@ -6208,19 +6490,24 @@ async function loadKitModule(specifier = GENUI_KIT_MODULE) {
     const code = err.code;
     if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
       throw new CodegenError(
-        `genuiSandboxKit() needs "${GENUI_KIT_MODULE}" \u2014 install @dudousxd/nestjs-agent-core@>=0.52.0, or pass \`generate\` to genuiSandboxKit().`
+        `genuiSandboxKit() needs "${GENUI_KIT_MODULE}" \u2014 install @dudousxd/nestjs-agent-core@>=${MIN_CORE}, or pass \`generate\` to genuiSandboxKit().`
       );
     }
     if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
       throw new CodegenError(
-        `genuiSandboxKit() needs "${GENUI_KIT_MODULE}", which the installed @dudousxd/nestjs-agent-core does not export \u2014 upgrade it to >=0.52.0.`
+        `genuiSandboxKit() needs "${GENUI_KIT_MODULE}", which the installed @dudousxd/nestjs-agent-core does not export \u2014 upgrade it to >=${MIN_CORE}.`
       );
     }
     throw err;
   }
   if (typeof mod.writeSandboxKitDocs !== "function") {
     throw new CodegenError(
-      `"${GENUI_KIT_MODULE}" has no writeSandboxKitDocs export \u2014 upgrade @dudousxd/nestjs-agent-core to >=0.52.0.`
+      `"${GENUI_KIT_MODULE}" has no writeSandboxKitDocs export \u2014 upgrade @dudousxd/nestjs-agent-core to >=${MIN_CORE}.`
+    );
+  }
+  if (typeof mod.resolveStyleEntries !== "function") {
+    throw new CodegenError(
+      `The installed @dudousxd/nestjs-agent-core predates genuiSandboxKit({ components, styles, wrapper }) \u2014 upgrade it to >=${MIN_CORE}.`
     );
   }
   return mod;
@@ -6234,52 +6521,92 @@ function globBase(glob) {
   return base.join("/");
 }
 function resolveKitFilesLocally(root, options) {
-  if (options.entry !== void 0) {
-    const entry = (0, import_node_path19.isAbsolute)(options.entry) ? options.entry : (0, import_node_path19.resolve)(root, options.entry);
-    return { entry, files: [entry], dirs: [(0, import_node_path19.dirname)(entry)] };
-  }
-  const include = options.include ?? DEFAULT_KIT_DIRS.filter((dir) => (0, import_node_fs2.existsSync)((0, import_node_path19.resolve)(root, dir))).map(
-    (dir) => `${dir}/*.{tsx,jsx,ts,js}`
-  )[0];
-  if (include === void 0) return null;
-  const globs = typeof include === "string" ? [include] : [...include];
-  const files = import_fast_glob4.default.sync(globs, { cwd: root, absolute: true, onlyFiles: true }).sort();
-  return { files, dirs: [...new Set(globs.map((glob) => (0, import_node_path19.resolve)(root, globBase(glob))))] };
+  const specs = options.components === void 0 ? DEFAULT_KIT_DIRS.filter((dir) => (0, import_node_fs4.existsSync)((0, import_node_path19.resolve)(root, dir))).slice(0, 1) : typeof options.components === "string" ? [options.components] : [...options.components];
+  const files = [];
+  const dirs = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    if (/[*?{]/.test(spec)) {
+      files.push(...import_fast_glob4.default.sync(spec, { cwd: root, absolute: true, onlyFiles: true }));
+      dirs.add((0, import_node_path19.resolve)(root, globBase(spec)));
+      continue;
+    }
+    const path = (0, import_node_path19.isAbsolute)(spec) ? spec : (0, import_node_path19.resolve)(root, spec);
+    if ((0, import_node_fs4.existsSync)(path) && (0, import_node_fs4.statSync)(path).isDirectory()) {
+      files.push(...import_fast_glob4.default.sync("*.{tsx,jsx,ts,js}", { cwd: path, absolute: true, onlyFiles: true }));
+      dirs.add(path);
+    } else if ((0, import_node_fs4.existsSync)(path)) {
+      files.push(path);
+      dirs.add((0, import_node_path19.dirname)(path));
+    }
+  }
+  if (options.wrapper !== void 0) {
+    const wrapper = (0, import_node_path19.isAbsolute)(options.wrapper) ? options.wrapper : (0, import_node_path19.resolve)(root, options.wrapper);
+    if ((0, import_node_fs4.existsSync)(wrapper)) files.push(wrapper);
+  }
+  if (files.length === 0 && dirs.size === 0) return null;
+  return { files: [...new Set(files)].sort(), dirs: [...dirs] };
 }
 function genuiSandboxKit(options = {}) {
+  const legacy = Object.keys(LEGACY_OPTIONS).filter(
+    (key) => options[key] !== void 0
+  );
+  if (legacy.length > 0) {
+    throw new CodegenError(
+      `genuiSandboxKit(): ${legacy.map((key) => `\`${key}\``).join(", ")} ${legacy.length > 1 ? "were" : "was"} removed \u2014 ${legacy.map((key) => LEGACY_OPTIONS[key]).join("; ")}. The options are now the agent's Vite plugin's: components, styles, wrapper, stylesDocs.`
+    );
+  }
   const output = options.output ?? DEFAULT_SANDBOX_KIT_OUTPUT;
   const source = {
-    ...options.entry !== void 0 ? { entry: options.entry } : {},
-    ...options.include !== void 0 ? { include: options.include } : {}
+    ...options.components !== void 0 ? { components: options.components } : {},
+    ...options.wrapper !== void 0 ? { wrapper: options.wrapper } : {}
   };
   const extension = {
     name: "genui-sandbox-kit",
     // Not read by the host: serialized into the config hash, so changing an option
     // invalidates skip-when-unchanged.
-    options: { ...source, css: options.css, tsconfig: options.tsconfig, output },
+    options: {
+      ...source,
+      styles: options.styles,
+      stylesDocs: options.stylesDocs,
+      tsconfig: options.tsconfig,
+      output
+    },
     async emitFiles(ctx) {
       const root = ctx.cwd;
       let generate2 = options.generate;
-      let resolveFiles = resolveKitFilesLocally;
+      let mod;
       if (!generate2) {
-        const mod = await loadKitModule(options.kitModule);
+        mod = await loadKitModule(options.kitModule);
         generate2 = mod.writeSandboxKitDocs;
-        if (typeof mod.resolveSandboxKitFiles === "function") {
-          resolveFiles = mod.resolveSandboxKitFiles;
-        }
       }
-      const kit = resolveFiles(root, source);
+      const resolveFiles = mod?.resolveSandboxKitFiles ?? resolveKitFilesLocally;
+      let kit = null;
+      try {
+        kit = resolveFiles(root, source);
+      } catch {
+        kit = null;
+      }
       if (kit) ctx.trackInput(...kit.files, ...kit.dirs);
-      if (options.css !== void 0) {
-        const css = typeof options.css === "string" ? [options.css] : [...options.css];
-        ctx.trackInput(...import_fast_glob4.default.sync(css, { cwd: root, absolute: true, onlyFiles: true }));
+      if (options.styles !== void 0) {
+        const entries = mod?.resolveStyleEntries ? mod.resolveStyleEntries(root, options.styles).files : import_fast_glob4.default.sync(typeof options.styles === "string" ? [options.styles] : [...options.styles], {
+          cwd: root,
+          absolute: true,
+          onlyFiles: true
+        });
+        const files = mod?.collectStyleSources ? mod.collectStyleSources(entries).map((source2) => source2.file) : entries;
+        ctx.trackInput(.../* @__PURE__ */ new Set([...entries, ...files]));
+      }
+      if (options.stylesDocs !== void 0 && !options.stylesDocs.includes("\n")) {
+        const guide = (0, import_node_path19.isAbsolute)(options.stylesDocs) ? options.stylesDocs : (0, import_node_path19.resolve)(root, options.stylesDocs);
+        if ((0, import_node_fs4.existsSync)(guide)) ctx.trackInput(guide);
       }
       ctx.trackInput((0, import_node_path19.isAbsolute)(output) ? output : (0, import_node_path19.resolve)(root, output));
       await generate2({
         root,
         output,
         ...source,
-        ...options.css !== void 0 ? { css: options.css } : {},
+        ...options.styles !== void 0 ? { styles: options.styles } : {},
+        ...options.stylesDocs !== void 0 ? { stylesDocs: options.stylesDocs } : {},
         ...options.tsconfig !== void 0 ? { tsconfig: options.tsconfig } : {}
       });
       return [];
@@ -6289,7 +6616,7 @@ function genuiSandboxKit(options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.28.0";
+var VERSION = "0.29.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CodegenError,