@dudousxd/nestjs-codegen 0.28.0 → 0.29.1

package/dist/cli/main.cjs

@@ -281,7 +281,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 });
     }
@@ -289,10 +289,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,
@@ -363,297 +367,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 changed;
   }
-  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());
-  }
-  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;
@@ -665,8 +432,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) {
@@ -707,17 +474,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)];
   }
@@ -739,8 +506,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;
@@ -931,13 +698,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];
@@ -1071,7 +838,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
@@ -1285,22 +1052,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();
         }
       }
     }
@@ -1309,30 +1076,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());
         }
       }
     }
@@ -1343,9 +1110,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;
 }
@@ -1354,12 +1121,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;
@@ -1367,7 +1134,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") {
@@ -1381,12 +1148,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 };
   }
@@ -1394,9 +1161,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()) };
     }
@@ -1414,7 +1181,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();
@@ -1467,28 +1234,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;
         }
@@ -1508,19 +1275,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" };
@@ -1538,25 +1305,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;
           }
@@ -1579,7 +1346,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) {
@@ -1587,11 +1354,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 };
@@ -1601,15 +1368,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 };
           }
@@ -1652,6 +1419,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);
@@ -1851,15 +1661,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();
@@ -2217,8 +2054,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;
@@ -2231,6 +2067,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
@@ -2271,12 +2154,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);
     }
@@ -2285,11 +2177,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());
@@ -2342,7 +2252,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) => ({
@@ -2356,21 +2266,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;
       }
@@ -2378,13 +2291,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(
@@ -2393,7 +2307,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;
@@ -2448,8 +2363,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);
@@ -2458,6 +2378,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();
@@ -3405,7 +3329,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,
@@ -3413,7 +3337,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 {
@@ -3435,7 +3359,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
   );
@@ -3497,6 +3421,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;
@@ -3522,6 +3449,8 @@ var PersistentDiscovery = class _PersistentDiscovery {
   }
   /** Run the initial extraction (equivalent to a first `discoverContractsFast`). */
   discover() {
+    clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return this.runExtraction();
   }
   /**
@@ -3529,26 +3458,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 {
         }
       }
@@ -3558,16 +3500,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);
   }
 };
@@ -3854,7 +3802,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 ?? (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;
+    }
+  }
+  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 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 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("; ")} }`;
+  }
+  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;
@@ -3905,7 +4146,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,
@@ -5636,36 +5877,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");
@@ -5746,7 +6015,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;
@@ -5774,7 +6044,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,
@@ -5824,7 +6094,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,
@@ -6007,13 +6277,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);
     }
@@ -6021,8 +6293,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) {
@@ -6034,20 +6310,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) {
@@ -6068,7 +6344,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.28.0";
+var VERSION = "0.29.1";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {
@@ -6096,28 +6372,28 @@ async function runCodegen(opts = {}) {
 
 // src/cli/doctor.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs4 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_path20 = require("path");
 
 // src/cli/init.ts
 var import_node_child_process = require("child_process");
-var import_node_fs3 = require("fs");
+var import_node_fs5 = require("fs");
 var import_promises16 = require("fs/promises");
 var import_node_path19 = require("path");
 var import_node_readline = require("readline");
 
 // src/cli/patch-utils.ts
-var import_node_fs2 = require("fs");
+var import_node_fs4 = require("fs");
 function patchJsonFile(filePath, mutator, parse = (raw) => raw) {
   let raw;
   try {
-    raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+    raw = (0, import_node_fs4.readFileSync)(filePath, "utf8");
   } catch {
     return "skipped";
   }
   const json = JSON.parse(parse(raw));
   if (!mutator(json)) return "already";
-  (0, import_node_fs2.writeFileSync)(filePath, `${JSON.stringify(json, null, 2)}
+  (0, import_node_fs4.writeFileSync)(filePath, `${JSON.stringify(json, null, 2)}
 `, "utf8");
   return "patched";
 }
@@ -6329,7 +6605,7 @@ async function patchPackageJsonScripts(cwd, scripts) {
 function patchAppModule(filePath, rootView) {
   let content;
   try {
-    content = (0, import_node_fs3.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs5.readFileSync)(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -6364,13 +6640,13 @@ ${indent}HomeController,${content.slice(bracketPos)}`;
     }
   }
   if (!changed) return "already";
-  (0, import_node_fs3.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs5.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 function patchMainTs(filePath) {
   let content;
   try {
-    content = (0, import_node_fs3.readFileSync)(filePath, "utf8");
+    content = (0, import_node_fs5.readFileSync)(filePath, "utf8");
   } catch {
     return "skipped";
   }
@@ -6395,7 +6671,7 @@ function patchMainTs(filePath) {
   });`;
   content = `${content.slice(0, insertAfterPos)}
 ${viteSetup}${content.slice(insertAfterPos)}`;
-  (0, import_node_fs3.writeFileSync)(filePath, content, "utf8");
+  (0, import_node_fs5.writeFileSync)(filePath, content, "utf8");
   return "patched";
 }
 function configTemplate(framework) {
@@ -6850,18 +7126,18 @@ ${green("\u2713")} Setup complete! Run: ${bold("nest start --watch")}
 
 // src/cli/doctor.ts
 function checkFileExists(cwd, file) {
-  return (0, import_node_fs4.existsSync)((0, import_node_path20.join)(cwd, file));
+  return (0, import_node_fs6.existsSync)((0, import_node_path20.join)(cwd, file));
 }
 function readJson(path) {
   try {
-    const raw = (0, import_node_fs4.readFileSync)(path, "utf8").replace(/\/\/.*$/gm, "");
+    const raw = (0, import_node_fs6.readFileSync)(path, "utf8").replace(/\/\/.*$/gm, "");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function writeJsonField(filePath, dotPath, value) {
-  const raw = (0, import_node_fs4.readFileSync)(filePath, "utf8");
+  const raw = (0, import_node_fs6.readFileSync)(filePath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "");
   const obj = JSON.parse(stripped);
   let target = obj;
@@ -6881,7 +7157,7 @@ function writeJsonField(filePath, dotPath, value) {
   } else {
     target[lastKey] = value;
   }
-  (0, import_node_fs4.writeFileSync)(filePath, `${JSON.stringify(obj, null, 2)}
+  (0, import_node_fs6.writeFileSync)(filePath, `${JSON.stringify(obj, null, 2)}
 `, "utf8");
 }
 function getPackageVersion(cwd, pkg) {
@@ -6893,8 +7169,8 @@ function getPackageVersion(cwd, pkg) {
   }
 }
 function detectPkgManager(cwd) {
-  if ((0, import_node_fs4.existsSync)((0, import_node_path20.join)(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if ((0, import_node_fs4.existsSync)((0, import_node_path20.join)(cwd, "yarn.lock"))) return "yarn";
+  if ((0, import_node_fs6.existsSync)((0, import_node_path20.join)(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if ((0, import_node_fs6.existsSync)((0, import_node_path20.join)(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function runDoctor(opts) {
@@ -7015,7 +7291,7 @@ async function runDoctor(opts) {
     pass: !!inertiaTsconfig,
     fix: "Create tsconfig.inertia.json (typechecks inertia/ + .nestjs-inertia/)",
     autoFix: () => {
-      (0, import_node_fs4.writeFileSync)(inertiaTsconfigPath, TSCONFIG_INERTIA_TEMPLATE, "utf8");
+      (0, import_node_fs6.writeFileSync)(inertiaTsconfigPath, TSCONFIG_INERTIA_TEMPLATE, "utf8");
     }
   });
   if (inertiaTsconfig) {
@@ -7063,14 +7339,14 @@ async function runDoctor(opts) {
   const innerTsconfigPath = (0, import_node_path20.join)(cwd, "inertia", "tsconfig.json");
   checks.push({
     name: "inertia/tsconfig.json exists (VSCode picks up ~codegen alias)",
-    pass: (0, import_node_fs4.existsSync)(innerTsconfigPath),
+    pass: (0, import_node_fs6.existsSync)(innerTsconfigPath),
     fix: "Create inertia/tsconfig.json that extends ../tsconfig.inertia.json",
     autoFix: () => {
-      (0, import_node_fs4.writeFileSync)(innerTsconfigPath, INERTIA_TSCONFIG_TEMPLATE, "utf8");
+      (0, import_node_fs6.writeFileSync)(innerTsconfigPath, INERTIA_TSCONFIG_TEMPLATE, "utf8");
     }
   });
   if (checkFileExists(cwd, "vite.config.ts")) {
-    const viteContent = (0, import_node_fs4.readFileSync)((0, import_node_path20.join)(cwd, "vite.config.ts"), "utf8");
+    const viteContent = (0, import_node_fs6.readFileSync)((0, import_node_path20.join)(cwd, "vite.config.ts"), "utf8");
     checks.push({
       name: "vite.config.ts has resolve.alias",
       pass: viteContent.includes("resolve") && viteContent.includes("alias"),
@@ -7136,12 +7412,12 @@ async function runDoctor(opts) {
   }
   if (checkFileExists(cwd, ".gitignore")) {
     const gitignorePath = (0, import_node_path20.join)(cwd, ".gitignore");
-    const gitignore = (0, import_node_fs4.readFileSync)(gitignorePath, "utf8");
+    const gitignore = (0, import_node_fs6.readFileSync)(gitignorePath, "utf8");
     checks.push({
       name: ".gitignore includes .nestjs-inertia/",
       pass: gitignore.includes(".nestjs-inertia"),
       fix: "Add .nestjs-inertia/ to .gitignore",
-      autoFix: () => (0, import_node_fs4.appendFileSync)(gitignorePath, "\n.nestjs-inertia/\n")
+      autoFix: () => (0, import_node_fs6.appendFileSync)(gitignorePath, "\n.nestjs-inertia/\n")
     });
   }
   const pkgJsonPath = (0, import_node_path20.join)(cwd, "package.json");