@dudousxd/nestjs-codegen 0.28.0 → 0.29.1

package/dist/nest/index.cjs

@@ -215,13 +215,52 @@ var import_node_path18 = require("path");
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 
 // src/discovery/contracts-fast.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_path3 = require("path");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_ts_morph11 = require("ts-morph");
+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 {
+        const stat2 = (0, import_node_fs.statSync)(path);
+        key = `${stat2.mtimeMs}:${stat2.size}`;
+      } catch {
+        this.stats.delete(path);
+        changed.push(path);
+        continue;
+      }
+      if (this.stats.get(path) === key) continue;
+      let disk;
+      try {
+        disk = (0, import_node_fs.readFileSync)(path, "utf-8");
+      } catch {
+        disk = void 0;
+      }
+      if (disk === text) {
+        this.stats.set(path, key);
+      } else {
+        this.stats.delete(path);
+        changed.push(path);
+      }
+    }
+    return changed;
+  }
+  /** Forget `path`, so its next check compares content again. */
+  forget(path) {
+    this.stats.delete(path);
+  }
+};
 
 // src/discovery/dto-type-resolver.ts
-var import_ts_morph10 = require("ts-morph");
+var import_ts_morph11 = require("ts-morph");
 
 // src/discovery/dto-to-ir.ts
 var import_ts_morph2 = require("ts-morph");
@@ -982,7 +1021,7 @@ function inSchemaFromDecorator(decorator) {
 }
 
 // src/discovery/filter-for.ts
-var import_ts_morph5 = require("ts-morph");
+var import_ts_morph6 = require("ts-morph");
 
 // src/discovery/filter-field-types.ts
 var import_ts_morph3 = require("ts-morph");
@@ -1222,23 +1261,66 @@ 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);
-  if (import_ts_morph4.Node.isCallExpression(expr)) return expr;
-  if (!import_ts_morph4.Node.isIdentifier(expr)) return void 0;
+  if (import_ts_morph5.Node.isCallExpression(expr)) return expr;
+  if (!import_ts_morph5.Node.isIdentifier(expr)) return void 0;
   const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find(
-    (n) => n !== void 0 && import_ts_morph4.Node.isVariableDeclaration(n)
+    (n) => n !== void 0 && import_ts_morph5.Node.isVariableDeclaration(n)
   );
   const init = decl?.getInitializer();
   if (!init) return void 0;
   const unwrapped = unwrapExpression(init);
-  return import_ts_morph4.Node.isCallExpression(unwrapped) ? unwrapped : void 0;
+  return import_ts_morph5.Node.isCallExpression(unwrapped) ? unwrapped : void 0;
 }
 function unwrapExpression(node) {
   let current = node;
-  while (import_ts_morph4.Node.isAsExpression(current) || import_ts_morph4.Node.isSatisfiesExpression(current) || import_ts_morph4.Node.isParenthesizedExpression(current) || import_ts_morph4.Node.isTypeAssertion(current)) {
+  while (import_ts_morph5.Node.isAsExpression(current) || import_ts_morph5.Node.isSatisfiesExpression(current) || import_ts_morph5.Node.isParenthesizedExpression(current) || import_ts_morph5.Node.isTypeAssertion(current)) {
     current = current.getExpression();
   }
   return current;
@@ -1246,17 +1328,17 @@ function unwrapExpression(node) {
 function resolveReturnedClass(factoryDecl) {
   const body = factoryDecl.getBody();
   if (!body) return void 0;
-  const returns = body.getDescendants().filter((n) => import_ts_morph4.Node.isReturnStatement(n));
+  const returns = body.getDescendants().filter((n) => import_ts_morph5.Node.isReturnStatement(n));
   for (const ret of returns) {
     const expr = ret.getExpression();
     if (!expr) continue;
     const inner = unwrapExpression(expr);
-    if (import_ts_morph4.Node.isClassExpression(inner)) {
+    if (import_ts_morph5.Node.isClassExpression(inner)) {
       return inner;
     }
-    if (import_ts_morph4.Node.isIdentifier(inner)) {
+    if (import_ts_morph5.Node.isIdentifier(inner)) {
       const name = inner.getText();
-      const decl = body.getDescendants().find((n) => import_ts_morph4.Node.isClassDeclaration(n) && n.getName() === name);
+      const decl = body.getDescendants().find((n) => import_ts_morph5.Node.isClassDeclaration(n) && n.getName() === name);
       if (decl) return decl;
     }
   }
@@ -1264,10 +1346,10 @@ function resolveReturnedClass(factoryDecl) {
 }
 function factoryCalleeName(call) {
   const callee = unwrapExpression(call.getExpression());
-  if (import_ts_morph4.Node.isIdentifier(callee)) return callee;
-  if (import_ts_morph4.Node.isPropertyAccessExpression(callee)) {
+  if (import_ts_morph5.Node.isIdentifier(callee)) return callee;
+  if (import_ts_morph5.Node.isPropertyAccessExpression(callee)) {
     const name = callee.getNameNode();
-    return import_ts_morph4.Node.isIdentifier(name) ? name : void 0;
+    return import_ts_morph5.Node.isIdentifier(name) ? name : void 0;
   }
   return void 0;
 }
@@ -1280,19 +1362,19 @@ function resolveFactoryFromName(name, seen) {
   seen.add(name);
   const decls = name.getDefinitions().map((d) => d.getDeclarationNode()).filter((n) => n !== void 0);
   for (const decl of decls) {
-    if (import_ts_morph4.Node.isFunctionDeclaration(decl) || import_ts_morph4.Node.isMethodDeclaration(decl)) return decl;
-    if (import_ts_morph4.Node.isPropertyAssignment(decl)) {
+    if (import_ts_morph5.Node.isFunctionDeclaration(decl) || import_ts_morph5.Node.isMethodDeclaration(decl)) return decl;
+    if (import_ts_morph5.Node.isPropertyAssignment(decl)) {
       const init = decl.getInitializer();
       const inner = init ? unwrapExpression(init) : void 0;
-      if (inner && import_ts_morph4.Node.isIdentifier(inner)) {
+      if (inner && import_ts_morph5.Node.isIdentifier(inner)) {
         const resolved = resolveFactoryFromName(inner, seen);
         if (resolved) return resolved;
       }
       continue;
     }
-    if (import_ts_morph4.Node.isShorthandPropertyAssignment(decl)) {
+    if (import_ts_morph5.Node.isShorthandPropertyAssignment(decl)) {
       const nameNode = decl.getNameNode();
-      const resolved = import_ts_morph4.Node.isIdentifier(nameNode) ? resolveFactoryFromName(nameNode, seen) : void 0;
+      const resolved = import_ts_morph5.Node.isIdentifier(nameNode) ? resolveFactoryFromName(nameNode, seen) : void 0;
       if (resolved) return resolved;
     }
   }
@@ -1304,7 +1386,7 @@ function warnUnresolvedFactory(cls, calleeText, reason) {
   );
 }
 function resolveFactoryStaticClass(node) {
-  if (!import_ts_morph4.Node.isPropertyAccessExpression(node)) return void 0;
+  if (!import_ts_morph5.Node.isPropertyAccessExpression(node)) return void 0;
   const call = resolveHeritageCall(node.getExpression());
   if (!call) return void 0;
   const factoryDecl = resolveFactoryDeclaration(call);
@@ -1312,13 +1394,13 @@ function resolveFactoryStaticClass(node) {
   const returnedClass = resolveReturnedClass(factoryDecl);
   if (!returnedClass) return void 0;
   const staticProp = returnedClass.getStaticProperties().find((p) => p.getName() === node.getName());
-  if (!staticProp || !import_ts_morph4.Node.isPropertyDeclaration(staticProp)) return void 0;
+  if (!staticProp || !import_ts_morph5.Node.isPropertyDeclaration(staticProp)) return void 0;
   const init = staticProp.getInitializer();
   if (!init) return void 0;
   const inner = unwrapExpression(init);
-  if (import_ts_morph4.Node.isClassExpression(inner)) return inner;
-  if (!import_ts_morph4.Node.isIdentifier(inner)) return void 0;
-  return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph4.Node.isClassDeclaration(n));
+  if (import_ts_morph5.Node.isClassExpression(inner)) return inner;
+  if (!import_ts_morph5.Node.isIdentifier(inner)) return void 0;
+  return inner.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
 }
 function resolveBaseClass(cls) {
   const heritage = cls.getExtends()?.getExpression();
@@ -1329,8 +1411,8 @@ function resolveBaseClass(cls) {
     return factoryDecl ? resolveReturnedClass(factoryDecl) : void 0;
   }
   const expr = unwrapExpression(heritage);
-  if (!import_ts_morph4.Node.isIdentifier(expr)) return void 0;
-  return expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph4.Node.isClassDeclaration(n));
+  if (!import_ts_morph5.Node.isIdentifier(expr)) return void 0;
+  return expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
 }
 function collectMethodsThroughChain(returnedClass) {
   const byName = /* @__PURE__ */ new Map();
@@ -1377,7 +1459,7 @@ function resolveInheritedMethods(cls) {
       classArgs.push(positional);
       continue;
     }
-    if (!import_ts_morph4.Node.isObjectLiteralExpression(arg)) continue;
+    if (!import_ts_morph5.Node.isObjectLiteralExpression(arg)) continue;
     for (const prop of arg.getProperties()) {
       const named = resolvePropertyClassReference(prop);
       if (!named) continue;
@@ -1399,8 +1481,8 @@ function resolveInheritedMethods(cls) {
 }
 function resolveClassReference(node) {
   const expr = unwrapExpression(node);
-  if (!import_ts_morph4.Node.isIdentifier(expr)) return void 0;
-  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph4.Node.isClassDeclaration(n));
+  if (!import_ts_morph5.Node.isIdentifier(expr)) return void 0;
+  const decl = expr.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
   if (!decl) return void 0;
   return {
     name: decl.getName() ?? expr.getText(),
@@ -1408,29 +1490,56 @@ function resolveClassReference(node) {
   };
 }
 function resolvePropertyClassReference(prop) {
-  if (import_ts_morph4.Node.isShorthandPropertyAssignment(prop)) {
+  if (import_ts_morph5.Node.isShorthandPropertyAssignment(prop)) {
     const ref2 = resolveClassReference(prop.getNameNode());
     return ref2 ? { key: prop.getName(), ref: ref2 } : void 0;
   }
-  if (!import_ts_morph4.Node.isPropertyAssignment(prop)) return void 0;
+  if (!import_ts_morph5.Node.isPropertyAssignment(prop)) return void 0;
   const init = prop.getInitializer();
   if (!init) return void 0;
   const ref = resolveClassReference(init);
   if (!ref) return void 0;
   const nameNode = prop.getNameNode();
-  const key = import_ts_morph4.Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName();
+  const key = import_ts_morph5.Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName();
   return { key, ref };
 }
 var mixinTypeProject;
+var mixinFiles = new DiskFingerprints();
+var mixinStale = false;
+var mixinUnresolved = new UnresolvedImports();
 function getMixinTypeProject() {
-  mixinTypeProject ??= new import_ts_morph4.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();
@@ -1461,7 +1570,7 @@ function resolveClassRef(ref, project) {
   return file?.getClass(ref.name);
 }
 function classifyFilterForHint(typeInit) {
-  if (import_ts_morph5.Node.isStringLiteral(typeInit)) {
+  if (import_ts_morph6.Node.isStringLiteral(typeInit)) {
     switch (typeInit.getLiteralValue()) {
       case "string":
         return { kind: "string" };
@@ -1475,10 +1584,10 @@ function classifyFilterForHint(typeInit) {
         return null;
     }
   }
-  if (import_ts_morph5.Node.isArrayLiteralExpression(typeInit)) {
+  if (import_ts_morph6.Node.isArrayLiteralExpression(typeInit)) {
     const values = [];
     for (const el of typeInit.getElements()) {
-      if (!import_ts_morph5.Node.isStringLiteral(el)) return null;
+      if (!import_ts_morph6.Node.isStringLiteral(el)) return null;
       values.push(el.getLiteralValue());
     }
     if (values.length === 0) return null;
@@ -1513,11 +1622,11 @@ function extractFilterForHints(classDecl, project) {
     if (!filterForDec) continue;
     const args = filterForDec.getArguments();
     const keyArg = args[0];
-    const inputKey = keyArg && import_ts_morph5.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
+    const inputKey = keyArg && import_ts_morph6.Node.isStringLiteral(keyArg) ? keyArg.getLiteralValue() : method.getName();
     const optsArg = args[1];
-    if (optsArg && import_ts_morph5.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph6.Node.isObjectLiteralExpression(optsArg)) {
       const typeProp = optsArg.getProperty("type");
-      if (typeProp && import_ts_morph5.Node.isPropertyAssignment(typeProp)) {
+      if (typeProp && import_ts_morph6.Node.isPropertyAssignment(typeProp)) {
         const typeInit = typeProp.getInitializer();
         if (typeInit) {
           const classified = classifyFilterForHint(typeInit);
@@ -1544,14 +1653,14 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin, controllerCl
     const filterClassArg = args[0];
     if (!filterClassArg) continue;
     const factoryStaticClass = resolveFactoryStaticClass(filterClassArg);
-    if (!factoryStaticClass && !import_ts_morph5.Node.isIdentifier(filterClassArg)) continue;
+    if (!factoryStaticClass && !import_ts_morph6.Node.isIdentifier(filterClassArg)) continue;
     let source = "query";
     const optionsArg = args[1];
-    if (optionsArg && import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) {
+    if (optionsArg && import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) {
       const sourceProp = optionsArg.getProperty("source");
-      if (sourceProp && import_ts_morph5.Node.isPropertyAssignment(sourceProp)) {
+      if (sourceProp && import_ts_morph6.Node.isPropertyAssignment(sourceProp)) {
         const init = sourceProp.getInitializer();
-        if (init && import_ts_morph5.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
+        if (init && import_ts_morph6.Node.isStringLiteral(init) && init.getLiteralValue() === "body") {
           source = "body";
         }
       }
@@ -1560,7 +1669,7 @@ function extractApplyFilterInfo(method, sourceFile, project, mixin, controllerCl
     const resolved = factoryStaticClass ? void 0 : findType(filterClassName, declFile, project);
     const declaredClass = factoryStaticClass ?? (resolved?.kind === "class" ? resolved.decl : resolveLocalClassDeclaration(filterClassArg));
     const ownRoute = !mixin || (controllerClass ? method.getParent() === controllerClass : declFile.getFilePath() !== mixin.factoryFilePath);
-    const namedByRoute = ownRoute && import_ts_morph5.Node.isIdentifier(filterClassArg) ? declaredClass : void 0;
+    const namedByRoute = ownRoute && import_ts_morph6.Node.isIdentifier(filterClassArg) ? declaredClass : void 0;
     for (const candidate of orderFilterCandidates({
       namedByRoute,
       supplied: resolveMixinFilterClass(mixin, project),
@@ -1638,22 +1747,22 @@ function resolveRelationEntity(prop, sourceFile, project) {
     const args = dec.getArguments();
     if (args.length === 0) continue;
     const arg = args[0];
-    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
+    if (import_ts_morph6.Node.isObjectLiteralExpression(arg)) {
       const entityProp = arg.getProperty("entity");
-      if (entityProp && import_ts_morph5.Node.isPropertyAssignment(entityProp)) {
+      if (entityProp && import_ts_morph6.Node.isPropertyAssignment(entityProp)) {
         const init = entityProp.getInitializer();
-        if (init && import_ts_morph5.Node.isArrowFunction(init)) {
+        if (init && import_ts_morph6.Node.isArrowFunction(init)) {
           const body = init.getBody();
-          if (import_ts_morph5.Node.isIdentifier(body)) {
+          if (import_ts_morph6.Node.isIdentifier(body)) {
             const resolved = findType(body.getText(), prop.getSourceFile(), project);
             if (resolved?.kind === "class") return resolved.decl;
           }
         }
       }
     }
-    if (import_ts_morph5.Node.isArrowFunction(arg)) {
+    if (import_ts_morph6.Node.isArrowFunction(arg)) {
       const body = arg.getBody();
-      if (import_ts_morph5.Node.isIdentifier(body)) {
+      if (import_ts_morph6.Node.isIdentifier(body)) {
         const resolved = findType(body.getText(), prop.getSourceFile(), project);
         if (resolved?.kind === "class") return resolved.decl;
       }
@@ -1672,36 +1781,36 @@ function extractClassPropertyTypes(classDecl, project) {
   return fields;
 }
 function resolveLocalClassDeclaration(identifier) {
-  if (!import_ts_morph5.Node.isIdentifier(identifier)) return void 0;
-  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph5.Node.isClassDeclaration(n));
+  if (!import_ts_morph6.Node.isIdentifier(identifier)) return void 0;
+  return identifier.getDefinitions().map((d) => d.getDeclarationNode()).find((n) => n !== void 0 && import_ts_morph6.Node.isClassDeclaration(n));
 }
 function resolveDeclaredEntity(optionsArg, filterClass, project) {
-  if (!import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) return void 0;
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return void 0;
   const entityProp = optionsArg.getProperty("entity");
-  if (!entityProp || !import_ts_morph5.Node.isPropertyAssignment(entityProp)) return void 0;
+  if (!entityProp || !import_ts_morph6.Node.isPropertyAssignment(entityProp)) return void 0;
   const entityInit = entityProp.getInitializer();
-  if (!entityInit || !import_ts_morph5.Node.isIdentifier(entityInit)) return void 0;
+  if (!entityInit || !import_ts_morph6.Node.isIdentifier(entityInit)) return void 0;
   const resolved = findType(entityInit.getText(), filterClass.getSourceFile(), project);
   if (!resolved || resolved.kind !== "class") return void 0;
   return resolved.decl;
 }
 function readFieldNameList(optionsArg, key) {
-  if (!import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) return void 0;
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return void 0;
   const prop = optionsArg.getProperty(key);
-  if (!prop || !import_ts_morph5.Node.isPropertyAssignment(prop)) return void 0;
+  if (!prop || !import_ts_morph6.Node.isPropertyAssignment(prop)) return void 0;
   const init = prop.getInitializer();
-  if (!init || !import_ts_morph5.Node.isArrayLiteralExpression(init)) return void 0;
+  if (!init || !import_ts_morph6.Node.isArrayLiteralExpression(init)) return void 0;
   const names = /* @__PURE__ */ new Set();
   for (const el of init.getElements()) {
-    if (import_ts_morph5.Node.isStringLiteral(el)) {
+    if (import_ts_morph6.Node.isStringLiteral(el)) {
       names.add(el.getLiteralValue());
       continue;
     }
-    if (import_ts_morph5.Node.isObjectLiteralExpression(el)) {
+    if (import_ts_morph6.Node.isObjectLiteralExpression(el)) {
       const fieldProp = el.getProperty("field");
-      if (fieldProp && import_ts_morph5.Node.isPropertyAssignment(fieldProp)) {
+      if (fieldProp && import_ts_morph6.Node.isPropertyAssignment(fieldProp)) {
         const fieldInit = fieldProp.getInitializer();
-        if (fieldInit && import_ts_morph5.Node.isStringLiteral(fieldInit)) {
+        if (fieldInit && import_ts_morph6.Node.isStringLiteral(fieldInit)) {
           names.add(fieldInit.getLiteralValue());
           continue;
         }
@@ -1725,7 +1834,7 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   const args = filterableDecorator.getArguments();
   if (args.length === 0) return [];
   const optionsArg = args[0];
-  if (!import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) return [];
+  if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) return [];
   const declaredEntity = resolveDeclaredEntity(optionsArg, filterClass, project);
   const entityDecl = preferDeclaredEntity ? declaredEntity ?? entityOverride : entityOverride ?? declaredEntity;
   if (!entityDecl) return [];
@@ -1736,17 +1845,17 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
   const relationsDecorator = filterClass.getDecorators().find((d) => d.getName() === "Relations");
   if (relationsDecorator) {
     const relArgs = relationsDecorator.getArguments();
-    if (relArgs.length > 0 && import_ts_morph5.Node.isObjectLiteralExpression(relArgs[0])) {
+    if (relArgs.length > 0 && import_ts_morph6.Node.isObjectLiteralExpression(relArgs[0])) {
       for (const relProp of relArgs[0].getProperties()) {
-        if (!import_ts_morph5.Node.isPropertyAssignment(relProp)) continue;
+        if (!import_ts_morph6.Node.isPropertyAssignment(relProp)) continue;
         const relInit = relProp.getInitializer();
-        if (!relInit || !import_ts_morph5.Node.isObjectLiteralExpression(relInit)) continue;
+        if (!relInit || !import_ts_morph6.Node.isObjectLiteralExpression(relInit)) continue;
         const keysProp = relInit.getProperty("keys");
-        if (!keysProp || !import_ts_morph5.Node.isPropertyAssignment(keysProp)) continue;
+        if (!keysProp || !import_ts_morph6.Node.isPropertyAssignment(keysProp)) continue;
         const keysInit = keysProp.getInitializer();
-        if (!keysInit || !import_ts_morph5.Node.isArrayLiteralExpression(keysInit)) continue;
+        if (!keysInit || !import_ts_morph6.Node.isArrayLiteralExpression(keysInit)) continue;
         for (const el of keysInit.getElements()) {
-          if (import_ts_morph5.Node.isStringLiteral(el)) {
+          if (import_ts_morph6.Node.isStringLiteral(el)) {
             fields.push(toFilterFieldType(el.getLiteralValue(), { kind: "unknown" }));
           }
         }
@@ -1757,13 +1866,13 @@ function extractFilterableEntityFields(filterClass, project, entityOverride, pre
 }
 
 // src/discovery/pipe-schema.ts
-var import_ts_morph9 = require("ts-morph");
+var import_ts_morph10 = require("ts-morph");
 
 // src/discovery/schema-type-inference.ts
-var import_ts_morph7 = require("ts-morph");
+var import_ts_morph8 = require("ts-morph");
 
 // src/discovery/schema-type-program.ts
-var import_ts_morph6 = require("ts-morph");
+var import_ts_morph7 = require("ts-morph");
 var PARAM_DECORATORS = /* @__PURE__ */ new Set(["Body", "Query", "Param"]);
 var SchemaTypeProgram = class {
   constructor(discovery) {
@@ -1773,10 +1882,10 @@ var SchemaTypeProgram = class {
       ...base,
       // A tsconfig-less consumer gets ES5 by default, whose lib has no `Map`/`Set`/
       // `Promise` for the schema libraries' declarations to lean on.
-      target: base.target ?? import_ts_morph6.ts.ScriptTarget.ES2022,
+      target: base.target ?? import_ts_morph7.ts.ScriptTarget.ES2022,
       // With neither set, resolve the way a bundler does: package `exports`
       // (`zod/v4`) and extensionless or `.js` relative imports all resolve.
-      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: import_ts_morph6.ts.ModuleKind.ESNext, moduleResolution: import_ts_morph6.ts.ModuleResolutionKind.Bundler } : {},
+      ...base.module === void 0 && base.moduleResolution === void 0 ? { module: import_ts_morph7.ts.ModuleKind.ESNext, moduleResolution: import_ts_morph7.ts.ModuleResolutionKind.Bundler } : {},
       // Without it `.nullable()` and `.optional()` would erase to the bare type.
       strictNullChecks: true,
       // No ambient `@types/*` (a tsconfig's `types: ['node']`): a schema does not
@@ -1784,17 +1893,16 @@ var SchemaTypeProgram = class {
       types: [],
       noEmit: true
     };
-    this.project = new import_ts_morph6.Project({
+    this.project = new import_ts_morph7.Project({
       skipAddingFilesFromTsConfig: true,
       compilerOptions: this.options
     });
-    for (const sf of discovery.getSourceFiles()) this.request(sf.getFilePath(), { schema: true });
-    this.flush();
+    this.requestDiscoveryFiles();
   }
   project;
   options;
   /** Parses a file that is not in discovery's Project, without adding it there. */
-  scratch = new import_ts_morph6.Project({
+  scratch = new import_ts_morph7.Project({
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
     skipFileDependencyResolution: true
@@ -1802,6 +1910,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
@@ -1842,12 +1997,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);
     }
@@ -1856,11 +2020,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());
@@ -1894,7 +2076,7 @@ var SchemaTypeProgram = class {
     const seen = new Set(queue);
     while (queue.length > 0) {
       const node = queue.pop();
-      const ids = import_ts_morph6.Node.isIdentifier(node) ? [node] : node.getDescendantsOfKind(import_ts_morph6.ts.SyntaxKind.Identifier);
+      const ids = import_ts_morph7.Node.isIdentifier(node) ? [node] : node.getDescendantsOfKind(import_ts_morph7.ts.SyntaxKind.Identifier);
       for (const id of ids) {
         const name = id.getText();
         if (referenced.has(name)) continue;
@@ -1913,7 +2095,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) => ({
@@ -1927,21 +2109,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;
       }
@@ -1949,22 +2134,24 @@ var SchemaTypeProgram = class {
         (n) => needs.all || needs.names.has((n.getAliasNode() ?? n.getNameNode()).getText())
       ).map((n) => n.getNameNode().getText());
       if (wanted.length === 0) blank(exp);
-      else if (target) this.request(target, { names: wanted });
+      else if (target) requests.push({ path: target, want: { names: wanted } });
     }
-    return chars.join("");
+    return { text: chars.join(""), requests, resolved };
   }
   /**
-   * The project source file a module specifier resolves to, or undefined for a
-   * package (read unpruned by the program itself) or an unresolvable one.
+   * The project source file a module specifier resolves to; undefined for a
+   * package or a declaration file (read unpruned by the program itself), null for
+   * one that does not resolve.
    */
   resolve(specifier, from) {
-    const resolved = import_ts_morph6.ts.resolveModuleName(
+    const resolved = import_ts_morph7.ts.resolveModuleName(
       specifier,
       from.getFilePath(),
       this.options,
-      import_ts_morph6.ts.sys
+      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;
@@ -1973,20 +2160,20 @@ var SchemaTypeProgram = class {
 function schemaPositions(sf) {
   const roots = [];
   sf.forEachDescendant((node) => {
-    if (import_ts_morph6.Node.isDecorator(node)) {
+    if (import_ts_morph7.Node.isDecorator(node)) {
       const name = node.getName();
       if (name === "ApplyContract") {
         roots.push(...node.getArguments());
       } else if (PARAM_DECORATORS.has(name)) {
         for (const arg of node.getArguments()) {
-          if (import_ts_morph6.Node.isNewExpression(arg) || import_ts_morph6.Node.isCallExpression(arg)) {
+          if (import_ts_morph7.Node.isNewExpression(arg) || import_ts_morph7.Node.isCallExpression(arg)) {
             roots.push(...arg.getArguments());
           }
         }
       }
-    } else if (import_ts_morph6.Node.isCallExpression(node)) {
+    } else if (import_ts_morph7.Node.isCallExpression(node)) {
       const callee = node.getExpression();
-      const name = import_ts_morph6.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph6.Node.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
+      const name = import_ts_morph7.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph7.Node.isPropertyAccessExpression(callee) ? callee.getName() : void 0;
       if (name === "defineContract") roots.push(...node.getArguments());
     }
   });
@@ -2019,8 +2206,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);
@@ -2029,6 +2221,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();
@@ -2092,7 +2288,7 @@ function objectKey(name) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
 }
 function isOptionalSymbol(sym) {
-  return (sym.getFlags() & import_ts_morph7.ts.SymbolFlags.Optional) !== 0;
+  return (sym.getFlags() & import_ts_morph8.ts.SymbolFlags.Optional) !== 0;
 }
 function isSymbolKeyed(sym) {
   return sym.getName().startsWith("__@");
@@ -2253,11 +2449,11 @@ function acceptsUndefined(types) {
 }
 
 // src/discovery/zod-ast-to-ts.ts
-var import_ts_morph8 = require("ts-morph");
+var import_ts_morph9 = require("ts-morph");
 function zodAstToTs(node) {
-  if (!import_ts_morph8.Node.isCallExpression(node)) return "unknown";
+  if (!import_ts_morph9.Node.isCallExpression(node)) return "unknown";
   const expr = node.getExpression();
-  if (import_ts_morph8.Node.isPropertyAccessExpression(expr)) {
+  if (import_ts_morph9.Node.isPropertyAccessExpression(expr)) {
     const methodName = expr.getName();
     const receiver = expr.getExpression();
     if (methodName === "optional") {
@@ -2281,17 +2477,17 @@ function zodAstToTs(node) {
       case "literal": {
         const lit = args[0];
         if (!lit) return "unknown";
-        if (import_ts_morph8.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
-        if (import_ts_morph8.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
-        if (lit.getKind() === import_ts_morph8.SyntaxKind.TrueKeyword) return "true";
-        if (lit.getKind() === import_ts_morph8.SyntaxKind.FalseKeyword) return "false";
+        if (import_ts_morph9.Node.isStringLiteral(lit)) return JSON.stringify(lit.getLiteralValue());
+        if (import_ts_morph9.Node.isNumericLiteral(lit)) return lit.getLiteralValue().toString();
+        if (lit.getKind() === import_ts_morph9.SyntaxKind.TrueKeyword) return "true";
+        if (lit.getKind() === import_ts_morph9.SyntaxKind.FalseKeyword) return "false";
         return "unknown";
       }
       case "enum": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         const members = arrArg.getElements().map(
-          (el) => import_ts_morph8.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
+          (el) => import_ts_morph9.Node.isStringLiteral(el) ? JSON.stringify(el.getLiteralValue()) : "unknown"
         );
         return members.join(" | ");
       }
@@ -2302,10 +2498,10 @@ function zodAstToTs(node) {
       }
       case "object": {
         const objArg = args[0];
-        if (!objArg || !import_ts_morph8.Node.isObjectLiteralExpression(objArg)) return "unknown";
+        if (!objArg || !import_ts_morph9.Node.isObjectLiteralExpression(objArg)) return "unknown";
         const lines = [];
         for (const prop of objArg.getProperties()) {
-          if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+          if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
           const key = prop.getName();
           const valNode = prop.getInitializer();
           if (!valNode) continue;
@@ -2317,7 +2513,7 @@ function zodAstToTs(node) {
       }
       case "union": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         return arrArg.getElements().map(zodAstToTs).join(" | ");
       }
       case "record": {
@@ -2327,7 +2523,7 @@ function zodAstToTs(node) {
       }
       case "tuple": {
         const arrArg = args[0];
-        if (!arrArg || !import_ts_morph8.Node.isArrayLiteralExpression(arrArg)) return "unknown";
+        if (!arrArg || !import_ts_morph9.Node.isArrayLiteralExpression(arrArg)) return "unknown";
         return `[${arrArg.getElements().map(zodAstToTs).join(", ")}]`;
       }
       default:
@@ -2337,9 +2533,9 @@ function zodAstToTs(node) {
   return "unknown";
 }
 function isOptionalChain(node) {
-  if (!import_ts_morph8.Node.isCallExpression(node)) return false;
+  if (!import_ts_morph9.Node.isCallExpression(node)) return false;
   const expr = node.getExpression();
-  return import_ts_morph8.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
+  return import_ts_morph9.Node.isPropertyAccessExpression(expr) && expr.getName() === "optional";
 }
 function memberType(val, position, project) {
   if (project) {
@@ -2351,13 +2547,13 @@ function memberType(val, position, project) {
   return zodAstToTs(val);
 }
 function parseDefineContractCall(callExpr, project) {
-  if (!import_ts_morph8.Node.isCallExpression(callExpr)) return null;
+  if (!import_ts_morph9.Node.isCallExpression(callExpr)) return null;
   const callee = callExpr.getExpression();
-  const calleeName = import_ts_morph8.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph8.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+  const calleeName = import_ts_morph9.Node.isIdentifier(callee) ? callee.getText() : import_ts_morph9.Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
   if (calleeName !== "defineContract") return null;
   const args = callExpr.getArguments();
   const optsArg = args[0];
-  if (!optsArg || !import_ts_morph8.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph9.Node.isObjectLiteralExpression(optsArg)) return null;
   let query = null;
   let body = null;
   let response = "unknown";
@@ -2365,7 +2561,7 @@ function parseDefineContractCall(callExpr, project) {
   let bodyZodText = null;
   let queryZodText = null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph8.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph9.Node.isPropertyAssignment(prop)) continue;
     const propName = prop.getName();
     const val = prop.getInitializer();
     if (!val) continue;
@@ -2387,7 +2583,7 @@ function parseDefineContractCall(callExpr, project) {
 // src/discovery/pipe-schema.ts
 function pipeSchemaOf(decorator, project) {
   for (const pipe of decorator.getArguments()) {
-    if (!import_ts_morph9.Node.isNewExpression(pipe) && !import_ts_morph9.Node.isCallExpression(pipe)) continue;
+    if (!import_ts_morph10.Node.isNewExpression(pipe) && !import_ts_morph10.Node.isCallExpression(pipe)) continue;
     for (const arg of pipe.getArguments()) {
       if (!couldBeSchema(arg)) continue;
       const inferred = inferSchema(arg, project);
@@ -2409,15 +2605,15 @@ function pipeSchemaOf(decorator, project) {
   return null;
 }
 function couldBeSchema(arg) {
-  return import_ts_morph9.Node.isIdentifier(arg) || import_ts_morph9.Node.isPropertyAccessExpression(arg) || import_ts_morph9.Node.isCallExpression(arg) || import_ts_morph9.Node.isAsExpression(arg) || import_ts_morph9.Node.isSatisfiesExpression(arg) || import_ts_morph9.Node.isParenthesizedExpression(arg);
+  return import_ts_morph10.Node.isIdentifier(arg) || import_ts_morph10.Node.isPropertyAccessExpression(arg) || import_ts_morph10.Node.isCallExpression(arg) || import_ts_morph10.Node.isAsExpression(arg) || import_ts_morph10.Node.isSatisfiesExpression(arg) || import_ts_morph10.Node.isParenthesizedExpression(arg);
 }
 function syntacticZodType(arg, project) {
   let expr = arg;
-  if (import_ts_morph9.Node.isIdentifier(arg)) {
+  if (import_ts_morph10.Node.isIdentifier(arg)) {
     const resolved = resolveImportedVariable(arg.getText(), arg.getSourceFile(), project);
     expr = resolved?.decl.getInitializer();
   }
-  if (!expr || !import_ts_morph9.Node.isCallExpression(expr)) return null;
+  if (!expr || !import_ts_morph10.Node.isCallExpression(expr)) return null;
   const type = zodAstToTs(expr);
   return type === "unknown" ? null : type;
 }
@@ -2453,22 +2649,22 @@ var PASSTHROUGH_UTILITY = /* @__PURE__ */ new Set([
 ]);
 function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /* @__PURE__ */ new Map()) {
   if (depth <= 0) return "unknown";
-  if (import_ts_morph10.Node.isArrayTypeNode(typeNode)) {
+  if (import_ts_morph11.Node.isArrayTypeNode(typeNode)) {
     const elementType = typeNode.getElementTypeNode();
     return `Array<${resolveTypeNodeToString(elementType, sourceFile, project, depth, subst)}>`;
   }
-  if (import_ts_morph10.Node.isUnionTypeNode(typeNode)) {
+  if (import_ts_morph11.Node.isUnionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" | ");
   }
-  if (import_ts_morph10.Node.isIntersectionTypeNode(typeNode)) {
+  if (import_ts_morph11.Node.isIntersectionTypeNode(typeNode)) {
     return typeNode.getTypeNodes().map((t) => resolveTypeNodeToString(t, sourceFile, project, depth, subst)).join(" & ");
   }
-  if (import_ts_morph10.Node.isParenthesizedTypeNode(typeNode)) {
+  if (import_ts_morph11.Node.isParenthesizedTypeNode(typeNode)) {
     return `(${resolveTypeNodeToString(typeNode.getTypeNode(), sourceFile, project, depth, subst)})`;
   }
-  if (import_ts_morph10.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph11.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
+    const name = import_ts_morph11.Node.isIdentifier(typeName) ? typeName.getText() : typeNode.getText();
     const bound = subst.get(name);
     if (bound !== void 0) return bound;
     if (name === "string" || name === "number" || name === "boolean") return name;
@@ -2491,10 +2687,10 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     dbg("unresolvable type:", name, "in", sourceFile.getFilePath());
     return "unknown";
   }
-  if (import_ts_morph10.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph11.Node.isTypeLiteral(typeNode)) {
     const members = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph10.Node.isPropertySignature(member)) {
+      if (import_ts_morph11.Node.isPropertySignature(member)) {
         const memberTypeNode = member.getTypeNode();
         const memberType2 = memberTypeNode ? resolveTypeNodeToString(memberTypeNode, sourceFile, project, depth, subst) : "unknown";
         members.push(`${member.getName()}${member.hasQuestionToken() ? "?" : ""}: ${memberType2}`);
@@ -2505,11 +2701,11 @@ function resolveTypeNodeToString(typeNode, sourceFile, project, depth, subst = /
     return members.length > 0 ? `{ ${members.join("; ")} }` : "{}";
   }
   const kind = typeNode.getKind();
-  if (kind === import_ts_morph10.SyntaxKind.StringKeyword) return "string";
-  if (kind === import_ts_morph10.SyntaxKind.NumberKeyword) return "number";
-  if (kind === import_ts_morph10.SyntaxKind.BooleanKeyword) return "boolean";
-  if (kind === import_ts_morph10.SyntaxKind.UnknownKeyword) return "unknown";
-  if (kind === import_ts_morph10.SyntaxKind.AnyKeyword) return "unknown";
+  if (kind === import_ts_morph11.SyntaxKind.StringKeyword) return "string";
+  if (kind === import_ts_morph11.SyntaxKind.NumberKeyword) return "number";
+  if (kind === import_ts_morph11.SyntaxKind.BooleanKeyword) return "boolean";
+  if (kind === import_ts_morph11.SyntaxKind.UnknownKeyword) return "unknown";
+  if (kind === import_ts_morph11.SyntaxKind.AnyKeyword) return "unknown";
   return typeNode.getText();
 }
 function unwrapFirstTypeArg(typeNode, sourceFile, project, depth, mode, subst = /* @__PURE__ */ new Map()) {
@@ -2567,7 +2763,7 @@ function resolvePropertied(decl, sourceFile, project, depth, subst = /* @__PURE_
 }
 function namedField(decorator) {
   const first = decorator.getArguments()[0];
-  return first && import_ts_morph10.Node.isStringLiteral(first) ? first.getLiteralValue() : null;
+  return first && import_ts_morph11.Node.isStringLiteral(first) ? first.getLiteralValue() : null;
 }
 function extractBodyType(method, sourceFile, project) {
   for (const param of method.getParameters()) {
@@ -2617,8 +2813,8 @@ function extractQueryType(method, sourceFile, project) {
 function isParamOptional(param) {
   if (param.hasQuestionToken() || param.hasInitializer()) return true;
   const typeNode = param.getTypeNode();
-  if (typeNode && import_ts_morph10.Node.isUnionTypeNode(typeNode)) {
-    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph10.SyntaxKind.UndefinedKeyword);
+  if (typeNode && import_ts_morph11.Node.isUnionTypeNode(typeNode)) {
+    return typeNode.getTypeNodes().some((t) => t.getKind() === import_ts_morph11.SyntaxKind.UndefinedKeyword);
   }
   return false;
 }
@@ -2630,7 +2826,7 @@ function extractParamsType(method, sourceFile, project) {
     const paramArgs = paramDecorator.getArguments();
     if (paramArgs.length === 0) continue;
     const nameArg = paramArgs[0];
-    if (!import_ts_morph10.Node.isStringLiteral(nameArg)) continue;
+    if (!import_ts_morph11.Node.isStringLiteral(nameArg)) continue;
     const paramName = nameArg.getLiteralValue();
     const typeNode = param.getTypeNode();
     const paramType = typeNode ? resolveTypeNodeToString(typeNode, sourceFile, project, 3) : "string";
@@ -2667,28 +2863,28 @@ function extractUploadedFiles(method) {
   for (const decorator of method.getDecorators()) {
     if (decorator.getName() !== "UseInterceptors") continue;
     for (const arg of decorator.getArguments()) {
-      if (!import_ts_morph10.Node.isCallExpression(arg)) continue;
+      if (!import_ts_morph11.Node.isCallExpression(arg)) continue;
       const interceptor = arg.getExpression().getText();
       const callArgs = arg.getArguments();
       const firstArg2 = callArgs[0];
       if (interceptor === "FileInterceptor") {
-        if (firstArg2 && import_ts_morph10.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph11.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: ${FILE}`);
           multipart = true;
         }
       } else if (interceptor === "FilesInterceptor") {
-        if (firstArg2 && import_ts_morph10.Node.isStringLiteral(firstArg2)) {
+        if (firstArg2 && import_ts_morph11.Node.isStringLiteral(firstArg2)) {
           entries.push(`${firstArg2.getLiteralValue()}: Array<${FILE}>`);
           multipart = true;
         }
       } else if (interceptor === "FileFieldsInterceptor") {
-        if (firstArg2 && import_ts_morph10.Node.isArrayLiteralExpression(firstArg2)) {
+        if (firstArg2 && import_ts_morph11.Node.isArrayLiteralExpression(firstArg2)) {
           for (const el of firstArg2.getElements()) {
-            if (!import_ts_morph10.Node.isObjectLiteralExpression(el)) continue;
+            if (!import_ts_morph11.Node.isObjectLiteralExpression(el)) continue;
             const nameProp = el.getProperty("name");
-            if (nameProp && import_ts_morph10.Node.isPropertyAssignment(nameProp)) {
+            if (nameProp && import_ts_morph11.Node.isPropertyAssignment(nameProp)) {
               const init = nameProp.getInitializer();
-              if (init && import_ts_morph10.Node.isStringLiteral(init)) {
+              if (init && import_ts_morph11.Node.isStringLiteral(init)) {
                 entries.push(`${init.getLiteralValue()}: Array<${FILE}>`);
               }
             }
@@ -2708,13 +2904,13 @@ function extractResponseType(method, sourceFile, project) {
   if (apiResponseDecorator) {
     const args = apiResponseDecorator.getArguments();
     const optsArg = args[0];
-    if (optsArg && import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) {
+    if (optsArg && import_ts_morph11.Node.isObjectLiteralExpression(optsArg)) {
       for (const prop of optsArg.getProperties()) {
-        if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
+        if (!import_ts_morph11.Node.isPropertyAssignment(prop)) continue;
         if (prop.getName() !== "type") continue;
         const val = prop.getInitializer();
         if (!val) continue;
-        if (import_ts_morph10.Node.isArrayLiteralExpression(val)) {
+        if (import_ts_morph11.Node.isArrayLiteralExpression(val)) {
           const elements = val.getElements();
           const firstEl = elements[0];
           if (elements.length > 0 && firstEl !== void 0) {
@@ -2735,24 +2931,24 @@ function extractResponseType(method, sourceFile, project) {
 }
 function apiResponseStatus(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph11.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph11.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "status") continue;
     const val = prop.getInitializer();
-    if (val && import_ts_morph10.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
+    if (val && import_ts_morph11.Node.isNumericLiteral(val)) return Number(val.getLiteralValue());
   }
   return null;
 }
 function apiResponseTypeNode(decorator) {
   const optsArg = decorator.getArguments()[0];
-  if (!optsArg || !import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) return null;
+  if (!optsArg || !import_ts_morph11.Node.isObjectLiteralExpression(optsArg)) return null;
   for (const prop of optsArg.getProperties()) {
-    if (!import_ts_morph10.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph11.Node.isPropertyAssignment(prop)) continue;
     if (prop.getName() !== "type") continue;
     const val = prop.getInitializer();
     if (!val) return null;
-    if (import_ts_morph10.Node.isArrayLiteralExpression(val)) {
+    if (import_ts_morph11.Node.isArrayLiteralExpression(val)) {
       const first = val.getElements()[0];
       return first ? { node: first, isArray: true } : null;
     }
@@ -2770,7 +2966,7 @@ function extractErrorType(method, sourceFile, project) {
     const inner = resolveIdentifierToClassType(typeInfo.node, sourceFile, project, 3);
     const type = typeInfo.isArray ? `Array<${inner}>` : inner;
     let ref = null;
-    if (import_ts_morph10.Node.isIdentifier(typeInfo.node)) {
+    if (import_ts_morph11.Node.isIdentifier(typeInfo.node)) {
       const name = typeInfo.node.getText();
       const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
       if (localDecl?.isExported()) {
@@ -2787,7 +2983,7 @@ function extractErrorType(method, sourceFile, project) {
   return null;
 }
 function resolveIdentifierToClassType(node, sourceFile, project, depth) {
-  if (!import_ts_morph10.Node.isIdentifier(node)) return "unknown";
+  if (!import_ts_morph11.Node.isIdentifier(node)) return "unknown";
   const name = node.getText();
   const resolved = findType(name, sourceFile, project);
   if (resolved) {
@@ -2807,9 +3003,9 @@ var STREAM_ENVELOPES = /* @__PURE__ */ new Set(["MessageEvent", "MessageEventLik
 var BINARY_RESPONSE_TYPES = /* @__PURE__ */ new Set(["StreamableFile", "Buffer"]);
 function detectBinaryResponse(method) {
   const node = unwrapNamedContainer(method.getReturnTypeNode(), /* @__PURE__ */ new Set(["Promise"]));
-  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return false;
+  if (!node || !import_ts_morph11.Node.isTypeReference(node)) return false;
   const typeName = node.getTypeName();
-  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph11.Node.isIdentifier(typeName) ? typeName.getText() : "";
   return BINARY_RESPONSE_TYPES.has(name);
 }
 function detectStreamElement(method) {
@@ -2824,9 +3020,9 @@ function detectStreamElement(method) {
   return null;
 }
 function streamContainerElement(node) {
-  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return null;
+  if (!node || !import_ts_morph11.Node.isTypeReference(node)) return null;
   const typeName = node.getTypeName();
-  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph11.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (STREAM_CONTAINERS.has(name) || STREAM_CONTAINERS_GENERATOR.has(name)) {
     return node.getTypeArguments()[0] ?? null;
   }
@@ -2836,9 +3032,9 @@ function hasAsQueryDecorator(method) {
   return method.getDecorators().some((d) => d.getName() === "AsQuery");
 }
 function unwrapNamedContainer(node, names) {
-  if (!node || !import_ts_morph10.Node.isTypeReference(node)) return node;
+  if (!node || !import_ts_morph11.Node.isTypeReference(node)) return node;
   const typeName = node.getTypeName();
-  const name = import_ts_morph10.Node.isIdentifier(typeName) ? typeName.getText() : "";
+  const name = import_ts_morph11.Node.isIdentifier(typeName) ? typeName.getText() : "";
   if (names.has(name)) {
     return node.getTypeArguments()[0] ?? node;
   }
@@ -2885,11 +3081,11 @@ function extractDtoContract(method, sourceFile, project, mixin, controllerClass)
     if (apiResp) {
       const args = apiResp.getArguments();
       const optsArg = args[0];
-      if (optsArg && import_ts_morph10.Node.isObjectLiteralExpression(optsArg)) {
+      if (optsArg && import_ts_morph11.Node.isObjectLiteralExpression(optsArg)) {
         for (const prop of optsArg.getProperties()) {
-          if (import_ts_morph10.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
+          if (import_ts_morph11.Node.isPropertyAssignment(prop) && prop.getName() === "type") {
             const val = prop.getInitializer();
-            if (val && import_ts_morph10.Node.isIdentifier(val)) {
+            if (val && import_ts_morph11.Node.isIdentifier(val)) {
               const name = val.getText();
               const localDecl = sourceFile.getInterface(name) || sourceFile.getClass(name) || sourceFile.getTypeAlias(name);
               if (localDecl?.isExported()) {
@@ -2969,26 +3165,26 @@ var NO_TSCONFIG_OPTIONS = {
   strict: false
 };
 function loadDiscoveryTsconfig(tsconfigPath) {
-  if (!(0, import_node_fs.existsSync)(tsconfigPath)) return { options: null, files: [] };
-  const read = import_ts_morph11.ts.readConfigFile(tsconfigPath, (path) => import_ts_morph11.ts.sys.readFile(path));
+  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 {
       options: null,
       files: [tsconfigPath],
-      error: import_ts_morph11.ts.flattenDiagnosticMessageText(read.error.messageText, " ")
+      error: import_ts_morph12.ts.flattenDiagnosticMessageText(read.error.messageText, " ")
     };
   }
   const host = {
-    useCaseSensitiveFileNames: import_ts_morph11.ts.sys.useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: import_ts_morph12.ts.sys.useCaseSensitiveFileNames,
     // The one line that keeps a tsconfig from being a filesystem walk.
     readDirectory: () => [],
-    fileExists: (path) => import_ts_morph11.ts.sys.fileExists(path),
+    fileExists: (path) => import_ts_morph12.ts.sys.fileExists(path),
     // `extends` is resolved through the host, so a consumer whose `paths` live
     // in a base tsconfig keeps working.
-    readFile: (path) => import_ts_morph11.ts.sys.readFile(path)
+    readFile: (path) => import_ts_morph12.ts.sys.readFile(path)
   };
-  const sourceFile = import_ts_morph11.ts.readJsonConfigFile(tsconfigPath, (path) => import_ts_morph11.ts.sys.readFile(path));
-  const parsed = import_ts_morph11.ts.parseJsonSourceFileConfigFileContent(
+  const sourceFile = import_ts_morph12.ts.readJsonConfigFile(tsconfigPath, (path) => import_ts_morph12.ts.sys.readFile(path));
+  const parsed = import_ts_morph12.ts.parseJsonSourceFileConfigFileContent(
     sourceFile,
     host,
     (0, import_node_path3.dirname)(tsconfigPath),
@@ -3011,7 +3207,7 @@ function createDiscoveryProject(tsconfigPath, tsconfig = loadDiscoveryTsconfig(t
       `[nestjs-codegen/fast] Could not load ${tsconfigPath}: ${tsconfig.error} \u2014 continuing WITHOUT its compiler options, so path alias imports (e.g. '@/...') will not resolve and controllers extending an alias-imported factory will contribute NO routes to the generated client.`
     );
   }
-  return new import_ts_morph11.Project({
+  return new import_ts_morph12.Project({
     compilerOptions: tsconfig.options ?? { ...NO_TSCONFIG_OPTIONS },
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: true,
@@ -3046,6 +3242,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;
@@ -3071,6 +3270,8 @@ var PersistentDiscovery = class _PersistentDiscovery {
   }
   /** Run the initial extraction (equivalent to a first `discoverContractsFast`). */
   discover() {
+    clearMixinTypeProject();
+    clearSchemaTypeProject(this.project);
     return this.runExtraction();
   }
   /**
@@ -3078,26 +3279,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_path3.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_path3.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_glob.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 {
         }
       }
@@ -3107,25 +3321,31 @@ var PersistentDiscovery = class _PersistentDiscovery {
         const sf = this.project.getSourceFile(f);
         if (sf) this.project.removeSourceFile(sf);
         this.controllerPaths.delete(f);
+        controllersChanged = true;
       }
     }
+    if (controllersChanged || options.filesAddedOrRemoved) {
+      clearMixinTypeProject();
+      clearSchemaTypeProject(this.project);
+    } else {
+      invalidateMixinTypeProject();
+      invalidateSchemaTypeProject(this.project);
+    }
     return this.runExtraction();
   }
   /** Clear stale per-Project caches, then extract over the controller set. */
   runExtraction() {
     clearTypeResolutionCaches(this.project);
     clearEnumCache(this.project);
-    clearMixinTypeProject();
-    clearSchemaTypeProject(this.project);
     return extractRoutesFrom(this.project, this.controllerPaths);
   }
 };
 function decoratorStringArg(decoratorExpr) {
   if (!decoratorExpr) return void 0;
-  if (import_ts_morph11.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
-  if (import_ts_morph11.Node.isArrayLiteralExpression(decoratorExpr)) {
+  if (import_ts_morph12.Node.isStringLiteral(decoratorExpr)) return decoratorExpr.getLiteralValue();
+  if (import_ts_morph12.Node.isArrayLiteralExpression(decoratorExpr)) {
     const first = decoratorExpr.getElements()[0];
-    if (first && import_ts_morph11.Node.isStringLiteral(first)) return first.getLiteralValue();
+    if (first && import_ts_morph12.Node.isStringLiteral(first)) return first.getLiteralValue();
   }
   return void 0;
 }
@@ -3246,9 +3466,9 @@ function extractContractRoute(args) {
   let contractDef = null;
   let bodyZodRef = null;
   let queryZodRef = null;
-  if (import_ts_morph11.Node.isCallExpression(firstDecoratorArg)) {
+  if (import_ts_morph12.Node.isCallExpression(firstDecoratorArg)) {
     contractDef = parseDefineContractCall(firstDecoratorArg, project);
-  } else if (import_ts_morph11.Node.isIdentifier(firstDecoratorArg)) {
+  } else if (import_ts_morph12.Node.isIdentifier(firstDecoratorArg)) {
     const identName = firstDecoratorArg.getText();
     const resolvedVar = resolveImportedVariable(identName, sourceFile, project);
     if (!resolvedVar) {
@@ -3432,7 +3652,7 @@ async function discoverPages(opts) {
       const rel = (0, import_node_path4.relative)(opts.cwd, file);
       const nameRel = (0, import_node_path4.relative)(pagesBase, file).split(import_node_path4.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 });
     }
@@ -3440,10 +3660,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,
@@ -3518,8 +3742,9 @@ var import_promises11 = require("fs/promises");
 var import_node_path15 = require("path");
 
 // src/discovery/shared-props.ts
+var import_node_fs3 = require("fs");
 var import_node_path5 = require("path");
-var import_ts_morph12 = require("ts-morph");
+var import_ts_morph13 = require("ts-morph");
 function discoverSharedProps(project, moduleEntry) {
   try {
     let sourceFile = project.getSourceFile(moduleEntry);
@@ -3545,14 +3770,9 @@ function discoverSharedPropsFromConfig(config) {
     const tsconfigPath = config.app.tsconfig ?? (0, import_node_path5.join)(config.codegen.cwd, "tsconfig.json");
     let project;
     try {
-      project = new import_ts_morph12.Project({
-        tsConfigFilePath: tsconfigPath,
-        skipAddingFilesFromTsConfig: true,
-        skipLoadingLibFiles: true,
-        skipFileDependencyResolution: true
-      });
+      project = sharedPropsProject(tsconfigPath);
     } catch {
-      project = new import_ts_morph12.Project({
+      project = new import_ts_morph13.Project({
         skipAddingFilesFromTsConfig: true,
         skipLoadingLibFiles: true,
         skipFileDependencyResolution: true,
@@ -3564,14 +3784,35 @@ function discoverSharedPropsFromConfig(config) {
     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_morph12.SyntaxKind.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph13.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
     const expr = call.getExpression();
-    if (!import_ts_morph12.Node.isPropertyAccessExpression(expr)) continue;
+    if (!import_ts_morph13.Node.isPropertyAccessExpression(expr)) continue;
     const methodName = expr.getName();
     const objectExpr = expr.getExpression();
-    if (methodName === "forRoot" && import_ts_morph12.Node.isIdentifier(objectExpr)) {
+    if (methodName === "forRoot" && import_ts_morph13.Node.isIdentifier(objectExpr)) {
       const name = objectExpr.getText();
       if (name === "InertiaModule") {
         return call;
@@ -3581,19 +3822,19 @@ function findForRootCall(sourceFile) {
   return null;
 }
 function findShareInitializer(forRootCall) {
-  if (!import_ts_morph12.Node.isCallExpression(forRootCall)) return null;
+  if (!import_ts_morph13.Node.isCallExpression(forRootCall)) return null;
   const args = forRootCall.getArguments();
   const firstArg2 = args[0];
-  if (!firstArg2 || !import_ts_morph12.Node.isObjectLiteralExpression(firstArg2)) return null;
+  if (!firstArg2 || !import_ts_morph13.Node.isObjectLiteralExpression(firstArg2)) return null;
   for (const prop of firstArg2.getProperties()) {
-    if (import_ts_morph12.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
+    if (import_ts_morph13.Node.isPropertyAssignment(prop) && prop.getName() === "share") {
       return prop.getInitializer() ?? null;
     }
   }
   return null;
 }
 function extractShareType(node, sourceFile, project) {
-  if (import_ts_morph12.Node.isIdentifier(node)) {
+  if (import_ts_morph13.Node.isIdentifier(node)) {
     const ref = resolveIdentifierToImportRef(node, sourceFile, project);
     if (ref) {
       return {
@@ -3603,22 +3844,22 @@ function extractShareType(node, sourceFile, project) {
       };
     }
   }
-  if (import_ts_morph12.Node.isArrowFunction(node)) {
+  if (import_ts_morph13.Node.isArrowFunction(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph12.Node.isFunctionExpression(node)) {
+  if (import_ts_morph13.Node.isFunctionExpression(node)) {
     const result = extractFromFunctionLike(node, sourceFile);
     return result ? { ...result, isImportRef: false } : null;
   }
-  if (import_ts_morph12.Node.isObjectLiteralExpression(node)) {
+  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_morph12.Node.isIdentifier(id)) return null;
+  if (!import_ts_morph13.Node.isIdentifier(id)) return null;
   const name = id.getText();
   const localFunc = sourceFile.getFunction(name);
   if (localFunc?.isExported()) {
@@ -3652,37 +3893,37 @@ function resolveIdentifierToImportRef(id, sourceFile, project) {
   return null;
 }
 function extractFromFunctionLike(node, _sourceFile) {
-  const returnTypeNode = import_ts_morph12.Node.isArrowFunction(node) || import_ts_morph12.Node.isFunctionExpression(node) ? node.getReturnTypeNode() : null;
+  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_morph12.Node.isArrowFunction(node)) {
+  if (import_ts_morph13.Node.isArrowFunction(node)) {
     const body = node.getBody();
-    if (import_ts_morph12.Node.isParenthesizedExpression(body)) {
+    if (import_ts_morph13.Node.isParenthesizedExpression(body)) {
       const inner = body.getExpression();
-      if (import_ts_morph12.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph13.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
-    if (import_ts_morph12.Node.isObjectLiteralExpression(body)) {
+    if (import_ts_morph13.Node.isObjectLiteralExpression(body)) {
       return extractFromObjectLiteral(body);
     }
-    if (import_ts_morph12.Node.isBlock(body)) {
+    if (import_ts_morph13.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
-  if (import_ts_morph12.Node.isFunctionExpression(node)) {
+  if (import_ts_morph13.Node.isFunctionExpression(node)) {
     const body = node.getBody();
-    if (import_ts_morph12.Node.isBlock(body)) {
+    if (import_ts_morph13.Node.isBlock(body)) {
       return extractFromBlockReturn(body);
     }
   }
   return null;
 }
 function extractFromReturnTypeAnnotation(typeNode) {
-  if (import_ts_morph12.Node.isTypeReference(typeNode)) {
+  if (import_ts_morph13.Node.isTypeReference(typeNode)) {
     const typeName = typeNode.getTypeName();
-    if (import_ts_morph12.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
+    if (import_ts_morph13.Node.isIdentifier(typeName) && typeName.getText() === "Promise") {
       const typeArgs = typeNode.getTypeArguments();
       const firstArg2 = typeArgs[0];
       if (firstArg2) {
@@ -3691,10 +3932,10 @@ function extractFromReturnTypeAnnotation(typeNode) {
       return null;
     }
   }
-  if (import_ts_morph12.Node.isTypeLiteral(typeNode)) {
+  if (import_ts_morph13.Node.isTypeLiteral(typeNode)) {
     const properties = [];
     for (const member of typeNode.getMembers()) {
-      if (import_ts_morph12.Node.isPropertySignature(member)) {
+      if (import_ts_morph13.Node.isPropertySignature(member)) {
         const name = member.getName();
         const memberTypeNode = member.getTypeNode();
         const type = memberTypeNode ? memberTypeNode.getText() : "unknown";
@@ -3708,19 +3949,19 @@ function extractFromReturnTypeAnnotation(typeNode) {
   return null;
 }
 function extractFromBlockReturn(block) {
-  if (!import_ts_morph12.Node.isBlock(block)) return null;
+  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_morph12.Node.isReturnStatement(stmt)) continue;
+    if (!import_ts_morph13.Node.isReturnStatement(stmt)) continue;
     const expr = stmt.getExpression();
     if (!expr) continue;
-    if (import_ts_morph12.Node.isObjectLiteralExpression(expr)) {
+    if (import_ts_morph13.Node.isObjectLiteralExpression(expr)) {
       return extractFromObjectLiteral(expr);
     }
-    if (import_ts_morph12.Node.isParenthesizedExpression(expr)) {
+    if (import_ts_morph13.Node.isParenthesizedExpression(expr)) {
       const inner = expr.getExpression();
-      if (import_ts_morph12.Node.isObjectLiteralExpression(inner)) {
+      if (import_ts_morph13.Node.isObjectLiteralExpression(inner)) {
         return extractFromObjectLiteral(inner);
       }
     }
@@ -3729,10 +3970,10 @@ function extractFromBlockReturn(block) {
   return null;
 }
 function extractFromObjectLiteral(objLiteral) {
-  if (!import_ts_morph12.Node.isObjectLiteralExpression(objLiteral)) return null;
+  if (!import_ts_morph13.Node.isObjectLiteralExpression(objLiteral)) return null;
   const properties = [];
   for (const prop of objLiteral.getProperties()) {
-    if (!import_ts_morph12.Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph13.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
     const initializer = prop.getInitializer();
     if (!initializer) continue;
@@ -3744,21 +3985,21 @@ function extractFromObjectLiteral(objLiteral) {
   return { typeString, properties, isImportRef: false };
 }
 function inferExpressionType(node) {
-  if (import_ts_morph12.Node.isStringLiteral(node)) return "string";
-  if (import_ts_morph12.Node.isTemplateExpression(node) || import_ts_morph12.Node.isNoSubstitutionTemplateLiteral(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_morph12.Node.isNumericLiteral(node)) return "number";
-  if (node.getKind() === import_ts_morph12.SyntaxKind.TrueKeyword || node.getKind() === import_ts_morph12.SyntaxKind.FalseKeyword) {
+  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_morph12.SyntaxKind.NullKeyword) return "null";
-  if (import_ts_morph12.Node.isIdentifier(node) && node.getText() === "undefined") return "undefined";
-  if (import_ts_morph12.Node.isObjectLiteralExpression(node)) {
+  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_morph12.Node.isPropertyAssignment(prop)) continue;
+      if (!import_ts_morph13.Node.isPropertyAssignment(prop)) continue;
       const key = prop.getName();
       const init = prop.getInitializer();
       if (!init) continue;
@@ -3767,23 +4008,23 @@ function inferExpressionType(node) {
     if (entries.length === 0) return "Record<string, unknown>";
     return `{ ${entries.join("; ")} }`;
   }
-  if (import_ts_morph12.Node.isArrayLiteralExpression(node)) {
+  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_morph12.Node.isConditionalExpression(node)) {
+  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_morph12.Node.isParenthesizedExpression(node)) {
+  if (import_ts_morph13.Node.isParenthesizedExpression(node)) {
     return inferExpressionType(node.getExpression());
   }
-  if (import_ts_morph12.Node.isAsExpression(node)) {
+  if (import_ts_morph13.Node.isAsExpression(node)) {
     const typeNode = node.getTypeNode();
     if (typeNode) return typeNode.getText();
   }
@@ -3796,7 +4037,7 @@ var import_node_path7 = require("path");
 
 // src/extension/registry.ts
 var import_node_path6 = require("path");
-var import_ts_morph13 = require("ts-morph");
+var import_ts_morph14 = require("ts-morph");
 function resolveApiSlots(extensions) {
   let layer;
   let layerOwner;
@@ -3847,7 +4088,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,
@@ -5519,7 +5760,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;
@@ -5547,7 +5789,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,
@@ -5597,7 +5839,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,
@@ -5780,13 +6022,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_path17.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);
     }
@@ -5794,8 +6038,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) {
@@ -5807,20 +6055,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_path17.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) {
@@ -5841,7 +6089,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.28.0";
+var VERSION = "0.29.1";
 
 // src/generate-manifest.ts
 var MANIFEST_FILE = ".codegen-manifest.json";
@@ -5906,36 +6154,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_promises15.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_promises15.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_promises15.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_promises15.readFile)(file, "utf8").catch(() => null);
+  for (const file of inputs.tsconfigFiles) {
     hash.update(`tsconfig:${(0, import_node_path18.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_path18.relative)(cwd, file)));
+  const globbedRelative = new Set(inputs.files.map((file) => (0, import_node_path18.relative)(cwd, file)));
   const extra = [...new Set(extraInputs)].filter((file) => !globbedRelative.has(file)).sort();
-  for (const file of globbed) {
-    const contents = await (0, import_promises15.readFile)(file, "utf8");
+  for (const file of inputs.files) {
     hash.update(`file:${(0, import_node_path18.relative)(cwd, file)}
 `);
-    hash.update(contents);
+    hash.update(inputs.contents.get(file));
     hash.update("\n");
   }
+  const unread = extra.map((file) => (0, import_node_path18.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_path18.join)(cwd, file)));
+    hash.update(inputs.tracked.get((0, import_node_path18.join)(cwd, file)));
     hash.update("\n");
   }
   return hash.digest("hex");