typescript 5.5.0-dev.20240509 → 5.5.0-dev.20240511

package/lib/typescript.js

@@ -68,7 +68,6 @@ __export(typescript_exports, {
   EmitHint: () => EmitHint,
   EmitOnly: () => EmitOnly,
   EndOfLineState: () => EndOfLineState,
-  EnumKind: () => EnumKind,
   ExitStatus: () => ExitStatus,
   ExportKind: () => ExportKind,
   Extension: () => Extension,
@@ -95,7 +94,7 @@ __export(typescript_exports, {
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
-  InlayHintKind: () => InlayHintKind,
+  InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
   InternalSymbolName: () => InternalSymbolName,
@@ -2369,7 +2368,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240509`;
+var version = `${versionMajorMinor}.0-dev.20240511`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6492,11 +6491,6 @@ var SymbolFlags = /* @__PURE__ */ ((SymbolFlags3) => {
   SymbolFlags3[SymbolFlags3["LateBindingContainer"] = 6256] = "LateBindingContainer";
   return SymbolFlags3;
 })(SymbolFlags || {});
-var EnumKind = /* @__PURE__ */ ((EnumKind2) => {
-  EnumKind2[EnumKind2["Numeric"] = 0] = "Numeric";
-  EnumKind2[EnumKind2["Literal"] = 1] = "Literal";
-  return EnumKind2;
-})(EnumKind || {});
 var CheckFlags = /* @__PURE__ */ ((CheckFlags2) => {
   CheckFlags2[CheckFlags2["None"] = 0] = "None";
   CheckFlags2[CheckFlags2["Instantiated"] = 1] = "Instantiated";
@@ -15978,7 +15972,7 @@ function canHaveLocals(node) {
   }
 }
 function isDeclarationKind(kind) {
-  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */;
+  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */ || kind === 202 /* NamedTupleMember */;
 }
 function isDeclarationStatementKind(kind) {
   return kind === 262 /* FunctionDeclaration */ || kind === 282 /* MissingDeclaration */ || kind === 263 /* ClassDeclaration */ || kind === 264 /* InterfaceDeclaration */ || kind === 265 /* TypeAliasDeclaration */ || kind === 266 /* EnumDeclaration */ || kind === 267 /* ModuleDeclaration */ || kind === 272 /* ImportDeclaration */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 278 /* ExportDeclaration */ || kind === 277 /* ExportAssignment */ || kind === 270 /* NamespaceExportDeclaration */;
@@ -23156,13 +23150,15 @@ function createNameResolver({
             let useResult = true;
             if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
               if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 320 /* JSDoc */) {
-                useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
+                useResult = result.flags & 262144 /* TypeParameter */ ? !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so type parameters are accessible from them
+                lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
               }
               if (meaning & result.flags & 3 /* Variable */) {
                 if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
                   useResult = false;
                 } else if (result.flags & 1 /* FunctionScopedVariable */) {
-                  useResult = lastLocation.kind === 169 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
+                  useResult = lastLocation.kind === 169 /* Parameter */ || !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so parameters are accessible from them
+                  lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
                 }
               }
             } else if (location.kind === 194 /* ConditionalType */) {
@@ -51210,7 +51206,6 @@ function createTypeChecker(host) {
     if (meaning) {
       const symbol = getMergedSymbol(symbols.get(name));
       if (symbol) {
-        Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
         if (symbol.flags & meaning) {
           return symbol;
         }
@@ -52462,37 +52457,6 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function markExportAsReferenced(node) {
-    if (!canCollectSymbolAliasAccessabilityData) {
-      return;
-    }
-    const symbol = getSymbolOfDeclaration(node);
-    const target = resolveAlias(symbol);
-    if (target) {
-      const markAlias = target === unknownSymbol || getSymbolFlags(
-        symbol,
-        /*excludeTypeOnlyMeanings*/
-        true
-      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
-      if (markAlias) {
-        markAliasSymbolAsReferenced(symbol);
-      }
-    }
-  }
-  function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(canCollectSymbolAliasAccessabilityData);
-    const links = getSymbolLinks(symbol);
-    if (!links.referenced) {
-      links.referenced = true;
-      const node = getDeclarationOfAliasSymbol(symbol);
-      if (!node) return Debug.fail();
-      if (isInternalModuleImportEqualsDeclaration(node)) {
-        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
-          checkExpressionCached(node.moduleReference);
-        }
-      }
-    }
-  }
   function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
     if (entityName.kind === 80 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
       entityName = entityName.parent;
@@ -52645,7 +52609,6 @@ function createTypeChecker(host) {
     } else {
       Debug.assertNever(name, "Unknown entity name kind.");
     }
-    Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
     if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 277 /* ExportAssignment */)) {
       markSymbolOfAliasDeclarationIfTypeOnly(
         getAliasDeclarationFromName(name),
@@ -54066,7 +54029,6 @@ function createTypeChecker(host) {
       return symbolToExpression(symbol, context, meaning);
     }
     function withContext2(enclosingDeclaration, flags, tracker, cb) {
-      Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 16 /* Synthesized */) === 0);
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -54080,7 +54042,18 @@ function createTypeChecker(host) {
         inferTypeParameters: void 0,
         approximateLength: 0,
         trackedSymbols: void 0,
-        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration)),
+        truncating: false,
+        usedSymbolNames: void 0,
+        remappedSymbolNames: void 0,
+        remappedSymbolReferences: void 0,
+        reverseMappedStack: void 0,
+        mustCreateTypeParameterSymbolList: true,
+        typeParameterSymbolList: void 0,
+        mustCreateTypeParametersNamesLookups: true,
+        typeParameterNames: void 0,
+        typeParameterNamesByText: void 0,
+        typeParameterNamesByTextNextNameCount: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -55075,22 +55048,22 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const flags = context.flags;
-      context.flags &= ~256 /* SuppressAnyReturnType */;
-      context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
-      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
-        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
-      } else {
-        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
-      }
       const expandedParams = getExpandedParameters(
         signature,
         /*skipUnionExpanding*/
         true
       )[0];
-      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters);
+      context.approximateLength += 3;
+      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
+        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
+      } else {
+        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
+      }
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -55188,15 +55161,14 @@ function createTypeChecker(host) {
       return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
     }
     function getParametersInScope(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
-        getSignatureFromDeclaration(node),
-        /*skipUnionExpanding*/
-        true
-      )[0] : void 0;
-    }
-    function enterNewScope(context, declaration, expandedParams, typeParameters) {
-      let cleanup;
-      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters) {
+      const cleanupContext = cloneNodeBuilderContext(context);
+      let cleanupParams;
+      let cleanupTypeParams;
+      const oldEnclosingDecl = context.enclosingDeclaration;
+      if (context.enclosingDeclaration && declaration) {
         let pushFakeScope2 = function(kind, addAll) {
           Debug.assert(context.enclosingDeclaration);
           let existingFakeScope;
@@ -55208,39 +55180,45 @@ function createTypeChecker(host) {
           Debug.assertOptionalNode(existingFakeScope, isBlock);
           const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
           let newLocals;
+          let oldLocals;
           addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
+            if (existingFakeScope) {
+              const oldSymbol = locals.get(name);
+              if (!oldSymbol) {
+                newLocals = append(newLocals, name);
+              } else {
+                oldLocals = append(oldLocals, { name, oldSymbol });
+              }
             }
+            locals.set(name, symbol);
           });
-          if (!newLocals) return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+          if (!existingFakeScope) {
+            const fakeScope = factory.createBlock(emptyArray);
             getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
             fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
+            setParent(fakeScope, context.enclosingDeclaration);
             context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
+          } else {
+            return function undo() {
+              forEach(newLocals, (s) => locals.delete(s));
+              forEach(oldLocals, (s) => locals.set(s.name, s.oldSymbol));
             };
           }
         };
         var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
+        cleanupParams = !some(expandedParams) ? void 0 : pushFakeScope2(
           "params",
           (add) => {
-            for (const param of expandedParams ?? emptyArray) {
-              if (!forEach(param.declarations, (d) => {
+            if (!expandedParams) return;
+            for (let pIndex = 0; pIndex < expandedParams.length; pIndex++) {
+              const param = expandedParams[pIndex];
+              const originalParam = originalParameters == null ? void 0 : originalParameters[pIndex];
+              if (originalParameters && originalParam !== param) {
+                add(param.escapedName, unknownSymbol);
+                if (originalParam) {
+                  add(originalParam.escapedName, unknownSymbol);
+                }
+              } else if (!forEach(param.declarations, (d) => {
                 if (isParameter(d) && isBindingPattern(d.name)) {
                   bindPattern(d.name);
                   return true;
@@ -55271,8 +55249,8 @@ function createTypeChecker(host) {
             }
           }
         );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && some(typeParameters)) {
+          cleanupTypeParams = pushFakeScope2(
             "typeParams",
             (add) => {
               for (const typeParam of typeParameters ?? emptyArray) {
@@ -55282,8 +55260,13 @@ function createTypeChecker(host) {
             }
           );
         }
-        return cleanup;
       }
+      return () => {
+        cleanupParams == null ? void 0 : cleanupParams();
+        cleanupTypeParams == null ? void 0 : cleanupTypeParams();
+        cleanupContext();
+        context.enclosingDeclaration = oldEnclosingDecl;
+      };
     }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
@@ -55501,7 +55484,11 @@ function createTypeChecker(host) {
       if ((_a = context.typeParameterSymbolList) == null ? void 0 : _a.has(symbolId)) {
         return void 0;
       }
-      (context.typeParameterSymbolList || (context.typeParameterSymbolList = /* @__PURE__ */ new Set())).add(symbolId);
+      if (context.mustCreateTypeParameterSymbolList) {
+        context.mustCreateTypeParameterSymbolList = false;
+        context.typeParameterSymbolList = new Set(context.typeParameterSymbolList);
+      }
+      context.typeParameterSymbolList.add(symbolId);
       let typeParameterNodes;
       if (context.flags & 512 /* WriteTypeParametersInQualifiedName */ && index < chain.length - 1) {
         const parentSymbol = symbol;
@@ -55762,9 +55749,15 @@ function createTypeChecker(host) {
           result = factory.createIdentifier(text);
           setIdentifierTypeArguments(result, typeArguments);
         }
-        (context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
-        (context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
-        (context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(text);
+        if (context.mustCreateTypeParametersNamesLookups) {
+          context.mustCreateTypeParametersNamesLookups = false;
+          context.typeParameterNames = new Map(context.typeParameterNames);
+          context.typeParameterNamesByTextNextNameCount = new Map(context.typeParameterNamesByTextNextNameCount);
+          context.typeParameterNamesByText = new Set(context.typeParameterNamesByText);
+        }
+        context.typeParameterNamesByTextNextNameCount.set(rawtext, i);
+        context.typeParameterNames.set(getTypeId(type), result);
+        context.typeParameterNamesByText.add(text);
       }
       return result;
     }
@@ -55886,21 +55879,22 @@ function createTypeChecker(host) {
       }
     }
     function cloneNodeBuilderContext(context) {
-      const initial = { ...context };
-      if (initial.typeParameterNames) {
-        initial.typeParameterNames = new Map(initial.typeParameterNames);
-      }
-      if (initial.typeParameterNamesByText) {
-        initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
-      }
-      if (initial.typeParameterSymbolList) {
-        initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
-      }
-      if (initial.typeParameterNamesByTextNextNameCount) {
-        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
-      }
-      initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
-      return initial;
+      const oldMustCreateTypeParameterSymbolList = context.mustCreateTypeParameterSymbolList;
+      const oldMustCreateTypeParametersNamesLookups = context.mustCreateTypeParametersNamesLookups;
+      context.mustCreateTypeParameterSymbolList = true;
+      context.mustCreateTypeParametersNamesLookups = true;
+      const oldTypeParameterNames = context.typeParameterNames;
+      const oldTypeParameterNamesByText = context.typeParameterNamesByText;
+      const oldTypeParameterNamesByTextNextNameCount = context.typeParameterNamesByTextNextNameCount;
+      const oldTypeParameterSymbolList = context.typeParameterSymbolList;
+      return () => {
+        context.typeParameterNames = oldTypeParameterNames;
+        context.typeParameterNamesByText = oldTypeParameterNamesByText;
+        context.typeParameterNamesByTextNextNameCount = oldTypeParameterNamesByTextNextNameCount;
+        context.typeParameterSymbolList = oldTypeParameterSymbolList;
+        context.mustCreateTypeParameterSymbolList = oldMustCreateTypeParameterSymbolList;
+        context.mustCreateTypeParametersNamesLookups = oldMustCreateTypeParametersNamesLookups;
+      };
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
@@ -56033,13 +56027,34 @@ function createTypeChecker(host) {
         /*dontResolveAlias*/
         true
       );
+      if (context.enclosingDeclaration && (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration || !findAncestor(node, (n) => n === context.enclosingDeclaration)) && !(sym && sym.flags & 262144 /* TypeParameter */)) {
+        sym = getExportSymbolOfValueSymbolIfExported(sym);
+        const symAtLocation = resolveEntityName(
+          leftmost,
+          meaning,
+          /*ignoreErrors*/
+          true,
+          /*dontResolveAlias*/
+          true,
+          context.enclosingDeclaration
+        );
+        if (
+          // Check for unusable parameters symbols
+          symAtLocation === unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node
+          symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference
+          symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym)
+        ) {
+          introducesError = true;
+          return { introducesError, node, sym };
+        }
+      }
       if (sym) {
         if (sym.flags & 1 /* FunctionScopedVariable */ && sym.valueDeclaration) {
-          if (isPartOfParameterDeclaration(sym.valueDeclaration)) {
+          if (isPartOfParameterDeclaration(sym.valueDeclaration) || isJSDocParameterTag(sym.valueDeclaration)) {
             return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
           }
         }
-        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the curent context if they are are resolvable
+        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the current context if they are are resolvable
         !isDeclarationName(node) && isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
@@ -56090,14 +56105,7 @@ function createTypeChecker(host) {
         return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
       function onEnterNewScope(node) {
-        const oldContex = context;
-        context = cloneNodeBuilderContext(context);
-        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
-        return onExitNewScope;
-        function onExitNewScope() {
-          cleanup == null ? void 0 : cleanup();
-          context = oldContex;
-        }
+        return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
       }
       function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
@@ -56547,17 +56555,9 @@ function createTypeChecker(host) {
         visitedSymbols.add(getSymbolId(visitedSym));
         const skipMembershipCheck = !isPrivate;
         if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) {
-          const oldContext = context;
-          context = cloneNodeBuilderContext(context);
+          const scopeCleanup = cloneNodeBuilderContext(context);
           serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
-          if (context.reportedDiagnostic) {
-            oldcontext.reportedDiagnostic = context.reportedDiagnostic;
-          }
-          if (context.trackedSymbols) {
-            if (!oldContext.trackedSymbols) oldContext.trackedSymbols = context.trackedSymbols;
-            else Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
-          }
-          context = oldContext;
+          scopeCleanup();
         }
       }
       function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias, escapedSymbolName = symbol.escapedName) {
@@ -58124,8 +58124,6 @@ function createTypeChecker(host) {
     switch (propertyName) {
       case 0 /* Type */:
         return !!getSymbolLinks(target).type;
-      case 5 /* EnumTagType */:
-        return !!getNodeLinks(target).resolvedEnumType;
       case 2 /* DeclaredType */:
         return !!getSymbolLinks(target).declaredType;
       case 1 /* ResolvedBaseConstructorType */:
@@ -58134,13 +58132,13 @@ function createTypeChecker(host) {
         return !!target.resolvedReturnType;
       case 4 /* ImmediateBaseConstraint */:
         return !!target.immediateBaseConstraint;
-      case 6 /* ResolvedTypeArguments */:
+      case 5 /* ResolvedTypeArguments */:
         return !!target.resolvedTypeArguments;
-      case 7 /* ResolvedBaseTypes */:
+      case 6 /* ResolvedBaseTypes */:
         return !!target.baseTypesResolved;
-      case 8 /* WriteType */:
+      case 7 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
-      case 9 /* ParameterInitializerContainsUndefined */:
+      case 8 /* ParameterInitializerContainsUndefined */:
         return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
@@ -59159,7 +59157,7 @@ function createTypeChecker(host) {
   function getWriteTypeOfAccessors(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.writeType) {
-      if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
+      if (!pushTypeResolution(symbol, 7 /* WriteType */)) {
         return errorType;
       }
       const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */) ?? tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
@@ -59569,7 +59567,7 @@ function createTypeChecker(host) {
   }
   function getBaseTypes(type) {
     if (!type.baseTypesResolved) {
-      if (pushTypeResolution(type, 7 /* ResolvedBaseTypes */)) {
+      if (pushTypeResolution(type, 6 /* ResolvedBaseTypes */)) {
         if (type.objectFlags & 8 /* Tuple */) {
           type.resolvedBaseTypes = [getTupleBaseType(type)];
         } else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
@@ -62464,7 +62462,7 @@ function createTypeChecker(host) {
   function getTypeArguments(type) {
     var _a, _b;
     if (!type.resolvedTypeArguments) {
-      if (!pushTypeResolution(type, 6 /* ResolvedTypeArguments */)) {
+      if (!pushTypeResolution(type, 5 /* ResolvedTypeArguments */)) {
         return ((_a = type.target.localTypeParameters) == null ? void 0 : _a.map(() => errorType)) || emptyArray;
       }
       const node = type.node;
@@ -73663,7 +73661,7 @@ function createTypeChecker(host) {
   function parameterInitializerContainsUndefined(declaration) {
     const links = getNodeLinks(declaration);
     if (links.parameterInitializerContainsUndefined === void 0) {
-      if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+      if (!pushTypeResolution(declaration, 8 /* ParameterInitializerContainsUndefined */)) {
         reportCircularityError(declaration.symbol);
         return true;
       }
@@ -73717,6 +73715,248 @@ function createTypeChecker(host) {
       return false;
     });
   }
+  function markLinkedReferences(location, hint, propSymbol, parentType) {
+    if (!canCollectSymbolAliasAccessabilityData) {
+      return;
+    }
+    if (location.flags & 33554432 /* Ambient */) {
+      return;
+    }
+    switch (hint) {
+      case 1 /* Identifier */:
+        return markIdentifierAliasReferenced(location);
+      case 2 /* Property */:
+        return markPropertyAliasReferenced(location, propSymbol, parentType);
+      case 3 /* ExportAssignment */:
+        return markExportAssignmentAliasReferenced(location);
+      case 4 /* Jsx */:
+        return markJsxAliasReferenced(location);
+      case 5 /* AsyncFunction */:
+        return markAsyncFunctionAliasReferenced(location);
+      case 6 /* ExportImportEquals */:
+        return markImportEqualsAliasReferenced(location);
+      case 7 /* ExportSpecifier */:
+        return markExportSpecifierAliasReferenced(location);
+      case 8 /* Decorator */:
+        return markDecoratorAliasReferenced(location);
+      case 0 /* Unspecified */: {
+        if (isIdentifier(location) && (isExpressionNode(location) || isShorthandPropertyAssignment(location.parent) || isImportEqualsDeclaration(location.parent) && location.parent.moduleReference === location) && shouldMarkIdentifierAliasReferenced(location)) {
+          if (isPropertyAccessOrQualifiedName(location.parent)) {
+            const left = isPropertyAccessExpression(location.parent) ? location.parent.expression : location.parent.left;
+            if (left !== location) return;
+          }
+          markIdentifierAliasReferenced(location);
+          return;
+        }
+        if (isPropertyAccessOrQualifiedName(location)) {
+          let topProp = location;
+          while (isPropertyAccessOrQualifiedName(topProp)) {
+            if (isPartOfTypeNode(topProp)) return;
+            topProp = topProp.parent;
+          }
+          return markPropertyAliasReferenced(location);
+        }
+        if (isExportAssignment(location)) {
+          return markExportAssignmentAliasReferenced(location);
+        }
+        if (isJsxOpeningLikeElement(location) || isJsxOpeningFragment(location)) {
+          return markJsxAliasReferenced(location);
+        }
+        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
+          return markAsyncFunctionAliasReferenced(location);
+        }
+        if (isImportEqualsDeclaration(location)) {
+          if (isInternalModuleImportEqualsDeclaration(location) || checkExternalImportOrExportDeclaration(location)) {
+            return markImportEqualsAliasReferenced(location);
+          }
+          return;
+        }
+        if (isExportSpecifier(location)) {
+          return markExportSpecifierAliasReferenced(location);
+        }
+        if (!compilerOptions.emitDecoratorMetadata) {
+          return;
+        }
+        if (!canHaveDecorators(location) || !hasDecorators(location) || !location.modifiers || !nodeCanBeDecorated(legacyDecorators, location, location.parent, location.parent.parent)) {
+          return;
+        }
+        return markDecoratorAliasReferenced(location);
+      }
+      default:
+        Debug.assertNever(hint, `Unhandled reference hint: ${hint}`);
+    }
+  }
+  function markIdentifierAliasReferenced(location) {
+    const symbol = getResolvedSymbol(location);
+    if (symbol && symbol !== argumentsSymbol && symbol !== unknownSymbol && !isThisInTypeQuery(location)) {
+      markAliasReferenced(symbol, location);
+    }
+  }
+  function markPropertyAliasReferenced(location, propSymbol, parentType) {
+    const left = isPropertyAccessExpression(location) ? location.expression : location.left;
+    if (isThisIdentifier(left) || !isIdentifier(left)) {
+      return;
+    }
+    const parentSymbol = getResolvedSymbol(left);
+    if (!parentSymbol || parentSymbol === unknownSymbol) {
+      return;
+    }
+    if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location)) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    const leftType = parentType || checkExpressionCached(left);
+    if (isTypeAny(leftType) || leftType === silentNeverType) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    let prop = propSymbol;
+    if (!prop && !parentType) {
+      const right = isPropertyAccessExpression(location) ? location.name : location.right;
+      const lexicallyScopedSymbol = isPrivateIdentifier(right) && lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
+      const assignmentKind = getAssignmentTargetKind(location);
+      const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(location) ? getWidenedType(leftType) : leftType);
+      prop = isPrivateIdentifier(right) ? lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(apparentType, lexicallyScopedSymbol) || void 0 : getPropertyOfType(apparentType, right.escapedText);
+    }
+    if (!(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && location.parent.kind === 306 /* EnumMember */))) {
+      markAliasReferenced(parentSymbol, location);
+    }
+    return;
+  }
+  function markExportAssignmentAliasReferenced(location) {
+    if (isIdentifier(location.expression)) {
+      const id = location.expression;
+      const sym = getExportSymbolOfValueSymbolIfExported(resolveEntityName(
+        id,
+        -1 /* All */,
+        /*ignoreErrors*/
+        true,
+        /*dontResolveAlias*/
+        true,
+        location
+      ));
+      if (sym) {
+        markAliasReferenced(sym, id);
+      }
+    }
+  }
+  function markJsxAliasReferenced(node) {
+    if (!getJsxNamespaceContainerForImplicitImport(node)) {
+      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
+      const jsxFactoryNamespace = getJsxNamespace(node);
+      const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? node.tagName : node;
+      let jsxFactorySym;
+      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
+        jsxFactorySym = resolveName(
+          jsxFactoryLocation,
+          jsxFactoryNamespace,
+          111551 /* Value */,
+          jsxFactoryRefErr,
+          /*isUse*/
+          true
+        );
+      }
+      if (jsxFactorySym) {
+        jsxFactorySym.isReferenced = -1 /* All */;
+        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+          markAliasSymbolAsReferenced(jsxFactorySym);
+        }
+      }
+      if (isJsxOpeningFragment(node)) {
+        const file = getSourceFileOfNode(node);
+        const localJsxNamespace = getLocalJsxNamespace(file);
+        if (localJsxNamespace) {
+          resolveName(
+            jsxFactoryLocation,
+            localJsxNamespace,
+            111551 /* Value */,
+            jsxFactoryRefErr,
+            /*isUse*/
+            true
+          );
+        }
+      }
+    }
+    return;
+  }
+  function markAsyncFunctionAliasReferenced(location) {
+    if (languageVersion < 2 /* ES2015 */) {
+      if (getFunctionFlags(location) & 2 /* Async */) {
+        const returnTypeNode = getEffectiveReturnTypeNode(location);
+        markTypeNodeAsReferenced(returnTypeNode);
+      }
+    }
+  }
+  function markImportEqualsAliasReferenced(location) {
+    if (hasSyntacticModifier(location, 32 /* Export */)) {
+      markExportAsReferenced(location);
+    }
+  }
+  function markExportSpecifierAliasReferenced(location) {
+    if (!location.parent.parent.moduleSpecifier && !location.isTypeOnly && !location.parent.parent.isTypeOnly) {
+      const exportedName = location.propertyName || location.name;
+      const symbol = resolveName(
+        exportedName,
+        exportedName.escapedText,
+        111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
+        /*nameNotFoundMessage*/
+        void 0,
+        /*isUse*/
+        true
+      );
+      if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
+      } else {
+        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
+        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
+          markExportAsReferenced(location);
+          markIdentifierAliasReferenced(location.propertyName || location.name);
+        }
+      }
+      return;
+    }
+  }
+  function markDecoratorAliasReferenced(node) {
+    if (compilerOptions.emitDecoratorMetadata) {
+      const firstDecorator = find(node.modifiers, isDecorator);
+      if (!firstDecorator) {
+        return;
+      }
+      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
+      switch (node.kind) {
+        case 263 /* ClassDeclaration */:
+          const constructor = getFirstConstructorWithBody(node);
+          if (constructor) {
+            for (const parameter of constructor.parameters) {
+              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+            }
+          }
+          break;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
+          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
+          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
+          break;
+        case 174 /* MethodDeclaration */:
+          for (const parameter of node.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
+          break;
+        case 172 /* PropertyDeclaration */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
+          break;
+        case 169 /* Parameter */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
+          const containingSignature = node.parent;
+          for (const parameter of containingSignature.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
+          break;
+      }
+    }
+  }
   function markAliasReferenced(symbol, location) {
     if (!canCollectSymbolAliasAccessabilityData) {
       return;
@@ -73738,6 +73978,77 @@ function createTypeChecker(host) {
       }
     }
   }
+  function markAliasSymbolAsReferenced(symbol) {
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
+    const links = getSymbolLinks(symbol);
+    if (!links.referenced) {
+      links.referenced = true;
+      const node = getDeclarationOfAliasSymbol(symbol);
+      if (!node) return Debug.fail();
+      if (isInternalModuleImportEqualsDeclaration(node)) {
+        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
+          const left = getFirstIdentifier(node.moduleReference);
+          markIdentifierAliasReferenced(left);
+        }
+      }
+    }
+  }
+  function markExportAsReferenced(node) {
+    const symbol = getSymbolOfDeclaration(node);
+    const target = resolveAlias(symbol);
+    if (target) {
+      const markAlias = target === unknownSymbol || getSymbolFlags(
+        symbol,
+        /*excludeTypeOnlyMeanings*/
+        true
+      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
+      if (markAlias) {
+        markAliasSymbolAsReferenced(symbol);
+      }
+    }
+  }
+  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
+    if (!typeName) return;
+    const rootName = getFirstIdentifier(typeName);
+    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
+    const rootSymbol = resolveName(
+      rootName,
+      rootName.escapedText,
+      meaning,
+      /*nameNotFoundMessage*/
+      void 0,
+      /*isUse*/
+      true
+    );
+    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
+      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+        markAliasSymbolAsReferenced(rootSymbol);
+      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
+        const diag2 = error2(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
+        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration2);
+        if (aliasDeclaration) {
+          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
+        }
+      }
+    }
+  }
+  function markTypeNodeAsReferenced(node) {
+    markEntityNameOrEntityExpressionAsReference(
+      node && getEntityNameFromTypeNode(node),
+      /*forDecoratorMetadata*/
+      false
+    );
+  }
+  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
+    const entityName = getEntityNameForDecoratorMetadata(node);
+    if (entityName && isEntityName(entityName)) {
+      markEntityNameOrEntityExpressionAsReference(
+        entityName,
+        /*forDecoratorMetadata*/
+        true
+      );
+    }
+  }
   function getNarrowedTypeOfSymbol(symbol, location, checkMode) {
     var _a;
     const type = getTypeOfSymbol(symbol, checkMode);
@@ -73833,7 +74144,7 @@ function createTypeChecker(host) {
       return getTypeOfSymbol(symbol);
     }
     if (shouldMarkIdentifierAliasReferenced(node)) {
-      markAliasReferenced(symbol, node);
+      markLinkedReferences(node, 1 /* Identifier */);
     }
     const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
     const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
@@ -76376,42 +76687,7 @@ function createTypeChecker(host) {
       checkGrammarJsxElement(node);
     }
     checkJsxPreconditions(node);
-    if (!getJsxNamespaceContainerForImplicitImport(node)) {
-      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
-      const jsxFactoryNamespace = getJsxNamespace(node);
-      const jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
-      let jsxFactorySym;
-      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
-        jsxFactorySym = resolveName(
-          jsxFactoryLocation,
-          jsxFactoryNamespace,
-          111551 /* Value */,
-          jsxFactoryRefErr,
-          /*isUse*/
-          true
-        );
-      }
-      if (jsxFactorySym) {
-        jsxFactorySym.isReferenced = -1 /* All */;
-        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
-          markAliasSymbolAsReferenced(jsxFactorySym);
-        }
-      }
-      if (isJsxOpeningFragment(node)) {
-        const file = getSourceFileOfNode(node);
-        const localJsxNamespace = getLocalJsxNamespace(file);
-        if (localJsxNamespace) {
-          resolveName(
-            jsxFactoryLocation,
-            localJsxNamespace,
-            111551 /* Value */,
-            jsxFactoryRefErr,
-            /*isUse*/
-            true
-          );
-        }
-      }
-    }
+    markLinkedReferences(node, 4 /* Jsx */);
     if (isNodeOpeningLikeElement) {
       const jsxOpeningLikeNode = node;
       const sig = getResolvedSignature(jsxOpeningLikeNode);
@@ -76842,7 +77118,13 @@ function createTypeChecker(host) {
     } else {
       if (isAnyLike) {
         if (isIdentifier(left) && parentSymbol) {
-          markAliasReferenced(parentSymbol, node);
+          markLinkedReferences(
+            node,
+            2 /* Property */,
+            /*propSymbol*/
+            void 0,
+            leftType
+          );
         }
         return isErrorType(apparentType) ? errorType : apparentType;
       }
@@ -76855,9 +77137,7 @@ function createTypeChecker(host) {
         node.kind === 166 /* QualifiedName */
       );
     }
-    if (isIdentifier(left) && parentSymbol && (getIsolatedModules(compilerOptions) || !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 306 /* EnumMember */)) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
-      markAliasReferenced(parentSymbol, node);
-    }
+    markLinkedReferences(node, 2 /* Property */, prop, leftType);
     let propType;
     if (!prop) {
       const indexInfo = !isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getApplicableIndexInfoForName(apparentType, right.escapedText) : void 0;
@@ -83790,7 +84070,7 @@ function createTypeChecker(host) {
         return;
       }
     } else {
-      markTypeNodeAsReferenced(returnTypeNode);
+      markLinkedReferences(node, 5 /* AsyncFunction */);
       if (isErrorType(returnType)) {
         return;
       }
@@ -83974,48 +84254,6 @@ function createTypeChecker(host) {
       voidType
     );
   }
-  function markTypeNodeAsReferenced(node) {
-    markEntityNameOrEntityExpressionAsReference(
-      node && getEntityNameFromTypeNode(node),
-      /*forDecoratorMetadata*/
-      false
-    );
-  }
-  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
-    if (!typeName) return;
-    const rootName = getFirstIdentifier(typeName);
-    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
-    const rootSymbol = resolveName(
-      rootName,
-      rootName.escapedText,
-      meaning,
-      /*nameNotFoundMessage*/
-      void 0,
-      /*isUse*/
-      true
-    );
-    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
-      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
-        markAliasSymbolAsReferenced(rootSymbol);
-      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
-        const diag2 = error2(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
-        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration2);
-        if (aliasDeclaration) {
-          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
-        }
-      }
-    }
-  }
-  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
-    const entityName = getEntityNameForDecoratorMetadata(node);
-    if (entityName && isEntityName(entityName)) {
-      markEntityNameOrEntityExpressionAsReference(
-        entityName,
-        /*forDecoratorMetadata*/
-        true
-      );
-    }
-  }
   function getEntityNameForDecoratorMetadata(node) {
     if (node) {
       switch (node.kind) {
@@ -84095,42 +84333,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    if (compilerOptions.emitDecoratorMetadata) {
-      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
-      switch (node.kind) {
-        case 263 /* ClassDeclaration */:
-          const constructor = getFirstConstructorWithBody(node);
-          if (constructor) {
-            for (const parameter of constructor.parameters) {
-              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-            }
-          }
-          break;
-        case 177 /* GetAccessor */:
-        case 178 /* SetAccessor */:
-          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
-          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
-          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
-          break;
-        case 174 /* MethodDeclaration */:
-          for (const parameter of node.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
-          break;
-        case 172 /* PropertyDeclaration */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
-          break;
-        case 169 /* Parameter */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
-          const containingSignature = node.parent;
-          for (const parameter of containingSignature.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
-          break;
-      }
-    }
+    markLinkedReferences(node, 8 /* Decorator */);
     for (const modifier of node.modifiers) {
       if (isDecorator(modifier)) {
         checkDecorator(modifier);
@@ -87471,9 +87674,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
-      if (hasSyntacticModifier(node, 32 /* Export */)) {
-        markExportAsReferenced(node);
-      }
+      markLinkedReferences(node, 6 /* ExportImportEquals */);
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
         const target = resolveAlias(getSymbolOfDeclaration(node));
         if (target !== unknownSymbol) {
@@ -87571,13 +87772,7 @@ function createTypeChecker(host) {
       if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
         error2(exportedName, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, idText(exportedName));
       } else {
-        if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
-          markExportAsReferenced(node);
-        }
-        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
-        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
-          checkExpressionCached(node.propertyName || node.name);
-        }
+        markLinkedReferences(node, 7 /* ExportSpecifier */);
       }
     } else {
       if (getESModuleInterop(compilerOptions) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && idText(node.propertyName || node.name) === "default") {
@@ -87619,8 +87814,8 @@ function createTypeChecker(host) {
         node
       ));
       if (sym) {
+        markLinkedReferences(node, 3 /* ExportAssignment */);
         const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(sym, 111551 /* Value */);
-        markAliasReferenced(sym, id);
         if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
           if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && typeOnlyDeclaration) {
@@ -134426,12 +134621,12 @@ var CompletionTriggerKind = /* @__PURE__ */ ((CompletionTriggerKind2) => {
   CompletionTriggerKind2[CompletionTriggerKind2["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
   return CompletionTriggerKind2;
 })(CompletionTriggerKind || {});
-var InlayHintKind = /* @__PURE__ */ ((InlayHintKind2) => {
-  InlayHintKind2["Type"] = "Type";
-  InlayHintKind2["Parameter"] = "Parameter";
-  InlayHintKind2["Enum"] = "Enum";
-  return InlayHintKind2;
-})(InlayHintKind || {});
+var InlayHintKind2 = /* @__PURE__ */ ((InlayHintKind3) => {
+  InlayHintKind3["Type"] = "Type";
+  InlayHintKind3["Parameter"] = "Parameter";
+  InlayHintKind3["Enum"] = "Enum";
+  return InlayHintKind3;
+})(InlayHintKind2 || {});
 var HighlightSpanKind = /* @__PURE__ */ ((HighlightSpanKind2) => {
   HighlightSpanKind2["none"] = "none";
   HighlightSpanKind2["definition"] = "definition";
@@ -159995,7 +160190,7 @@ function createSignatureDeclarationFromSignature(kind, context, quotePreference,
   }
   let typeParameters = isJs ? void 0 : signatureDeclaration.typeParameters;
   let parameters = signatureDeclaration.parameters;
-  let type = isJs ? void 0 : signatureDeclaration.type;
+  let type = isJs ? void 0 : getSynthesizedDeepClone(signatureDeclaration.type);
   if (importAdder) {
     if (typeParameters) {
       const newTypeParameters = sameMap(typeParameters, (typeParameterDecl) => {
@@ -168820,7 +169015,7 @@ function getDefinitionAtPosition(program, sourceFile, position, searchOtherFiles
   }
   if (searchOtherFilesOnly && every(symbol.declarations, (d) => d.getSourceFile().fileName === sourceFile.fileName)) return void 0;
   const calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
-  if (calledDeclaration && !(isJsxOpeningLikeElement(node.parent) && isConstructorLike(calledDeclaration))) {
+  if (calledDeclaration && !(isJsxOpeningLikeElement(node.parent) && isJsxConstructorLike(calledDeclaration))) {
     const sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration, failedAliasResolution);
     if (typeChecker.getRootSymbols(symbol).some((s) => symbolMatchesSignature(s, calledDeclaration))) {
       return [sigInfo];
@@ -169241,10 +169436,11 @@ function tryGetSignatureDeclaration(typeChecker, node) {
   const signature = callLike && typeChecker.getResolvedSignature(callLike);
   return tryCast(signature && signature.declaration, (d) => isFunctionLike(d) && !isFunctionTypeNode(d));
 }
-function isConstructorLike(node) {
+function isJsxConstructorLike(node) {
   switch (node.kind) {
     case 176 /* Constructor */:
     case 185 /* ConstructorType */:
+    case 179 /* CallSignature */:
     case 180 /* ConstructSignature */:
       return true;
     default:
@@ -177154,7 +177350,6 @@ __export(ts_exports2, {
   EmitHint: () => EmitHint,
   EmitOnly: () => EmitOnly,
   EndOfLineState: () => EndOfLineState,
-  EnumKind: () => EnumKind,
   ExitStatus: () => ExitStatus,
   ExportKind: () => ExportKind,
   Extension: () => Extension,
@@ -177181,7 +177376,7 @@ __export(ts_exports2, {
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
-  InlayHintKind: () => InlayHintKind,
+  InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
   InternalSymbolName: () => InternalSymbolName,
@@ -179575,6 +179770,7 @@ __export(ts_server_exports3, {
   CommandNames: () => CommandNames,
   ConfigFileDiagEvent: () => ConfigFileDiagEvent,
   ConfiguredProject: () => ConfiguredProject2,
+  ConfiguredProjectLoadKind: () => ConfiguredProjectLoadKind,
   CreateDirectoryWatcherEvent: () => CreateDirectoryWatcherEvent,
   CreateFileWatcherEvent: () => CreateFileWatcherEvent,
   Errors: () => Errors,
@@ -179582,7 +179778,7 @@ __export(ts_server_exports3, {
   EventEndInstallTypes: () => EventEndInstallTypes,
   EventInitializationFailed: () => EventInitializationFailed,
   EventTypesRegistry: () => EventTypesRegistry,
-  ExternalProject: () => ExternalProject2,
+  ExternalProject: () => ExternalProject,
   GcTimer: () => GcTimer,
   InferredProject: () => InferredProject2,
   LargeFileReferencedEvent: () => LargeFileReferencedEvent,
@@ -179598,7 +179794,6 @@ __export(ts_server_exports3, {
   ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
   ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
   ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
-  ProjectReferenceProjectLoadKind: () => ProjectReferenceProjectLoadKind,
   ProjectService: () => ProjectService3,
   ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
   ScriptInfo: () => ScriptInfo,
@@ -179650,7 +179845,6 @@ __export(ts_server_exports3, {
   nowString: () => nowString,
   nullCancellationToken: () => nullCancellationToken,
   nullTypingsInstaller: () => nullTypingsInstaller,
-  projectContainsInfoDirectly: () => projectContainsInfoDirectly,
   protocol: () => ts_server_protocol_exports,
   removeSorted: () => removeSorted,
   stringifyIndented: () => stringifyIndented,
@@ -180828,11 +181022,8 @@ var ScriptInfo = class {
       case 0:
         return Errors.ThrowNoProject();
       case 1:
-        return ensurePrimaryProjectKind(
-          !isProjectDeferredClose(this.containingProjects[0]) ? this.containingProjects[0] : void 0
-        );
+        return isProjectDeferredClose(this.containingProjects[0]) || isBackgroundProject(this.containingProjects[0]) ? Errors.ThrowNoProject() : this.containingProjects[0];
       default:
-        let firstExternalProject;
         let firstConfiguredProject;
         let firstInferredProject;
         let firstNonSourceOfProjectReferenceRedirect;
@@ -180849,15 +181040,13 @@ var ScriptInfo = class {
               if (!firstNonSourceOfProjectReferenceRedirect) firstNonSourceOfProjectReferenceRedirect = project;
             }
             if (!firstConfiguredProject) firstConfiguredProject = project;
-          } else if (!firstExternalProject && isExternalProject(project)) {
-            firstExternalProject = project;
+          } else if (isExternalProject(project)) {
+            return project;
           } else if (!firstInferredProject && isInferredProject(project)) {
             firstInferredProject = project;
           }
         }
-        return ensurePrimaryProjectKind(
-          defaultConfiguredProject || firstNonSourceOfProjectReferenceRedirect || firstConfiguredProject || firstExternalProject || firstInferredProject
-        );
+        return (defaultConfiguredProject || firstNonSourceOfProjectReferenceRedirect || firstConfiguredProject || firstInferredProject) ?? Errors.ThrowNoProject();
     }
   }
   registerFileUpdate() {
@@ -180947,12 +181136,6 @@ var ScriptInfo = class {
     }
   }
 };
-function ensurePrimaryProjectKind(project) {
-  if (!project || isBackgroundProject(project)) {
-    return Errors.ThrowNoProject();
-  }
-  return project;
-}
 function failIfInvalidPosition(position) {
   Debug.assert(typeof position === "number", `Expected position ${position} to be a number.`);
   Debug.assert(position >= 0, `Expected position to be non-negative.`);
@@ -182703,7 +182886,7 @@ var Project3 = class _Project {
   isDefaultProjectForOpenFiles() {
     return !!forEachEntry(
       this.projectService.openFiles,
-      (_, fileName) => this.projectService.tryGetDefaultProjectForFile(toNormalizedPath(fileName)) === this
+      (_projectRootPath, path) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path)) === this
     );
   }
   /** @internal */
@@ -182842,7 +183025,7 @@ var InferredProject2 = class extends Project3 {
     super.addRoot(info);
   }
   removeRoot(info) {
-    this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info);
+    this.projectService.stopWatchingConfigFilesForScriptInfo(info);
     super.removeRoot(info);
     if (!this.isOrphan() && this._isJsInferredProject && info.isJavaScript()) {
       if (every(this.getRootScriptInfos(), (rootInfo) => !rootInfo.isJavaScript())) {
@@ -182861,7 +183044,7 @@ var InferredProject2 = class extends Project3 {
     return !this.projectRootPath && !this.projectService.useSingleInferredProject || this.getRootScriptInfos().length === 1;
   }
   close() {
-    forEach(this.getRootScriptInfos(), (info) => this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info));
+    forEach(this.getRootScriptInfos(), (info) => this.projectService.stopWatchingConfigFilesForScriptInfo(info));
     super.close();
   }
   getTypeAcquisition() {
@@ -183193,8 +183376,6 @@ var ConfiguredProject2 = class extends Project3 {
     this.openFileWatchTriggered = /* @__PURE__ */ new Map();
     /** @internal */
     this.canConfigFileJsonReportNoInputFiles = false;
-    /** Ref count to the project when opened from external project */
-    this.externalProjectRefCount = 0;
     /** @internal */
     this.isInitialLoadPending = returnTrue;
     /** @internal */
@@ -183256,13 +183437,7 @@ var ConfiguredProject2 = class extends Project3 {
       case 2 /* Full */:
         this.openFileWatchTriggered.clear();
         const reason = Debug.checkDefined(this.pendingUpdateReason);
-        this.pendingUpdateReason = void 0;
-        this.projectService.reloadConfiguredProject(
-          this,
-          reason,
-          /*clearSemanticCache*/
-          false
-        );
+        this.projectService.reloadConfiguredProject(this, reason);
         result = true;
         break;
       default:
@@ -183366,69 +183541,13 @@ var ConfiguredProject2 = class extends Project3 {
     super.markAsDirty();
   }
   /** @internal */
-  addExternalProjectReference() {
-    this.externalProjectRefCount++;
-  }
-  /** @internal */
-  deleteExternalProjectReference() {
-    this.externalProjectRefCount--;
-  }
-  /** @internal */
   isSolution() {
     return this.getRootFilesMap().size === 0 && !this.canConfigFileJsonReportNoInputFiles;
   }
-  /**
-   * Find the configured project from the project references in project which contains the info directly
-   *
-   * @internal
-   */
-  getDefaultChildProjectFromProjectWithReferences(info) {
-    return forEachResolvedProjectReferenceProject(
-      this,
-      info.path,
-      (child) => projectContainsInfoDirectly(child, info) ? child : void 0,
-      0 /* Find */
-    );
-  }
-  /**
-   * Returns true if the project is needed by any of the open script info/external project
-   *
-   * @internal
-   */
-  hasOpenRef() {
-    var _a, _b;
-    if (!!this.externalProjectRefCount) {
-      return true;
-    }
-    if (this.isClosed()) {
-      return false;
-    }
-    const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(this.canonicalConfigFilePath);
-    if (this.deferredClose) return !!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.size);
-    if (this.projectService.hasPendingProjectUpdate(this)) {
-      return !!((_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.size);
-    }
-    return !!configFileExistenceInfo.openFilesImpactedByConfigFile && forEachEntry(
-      configFileExistenceInfo.openFilesImpactedByConfigFile,
-      (_value, infoPath) => {
-        const info = this.projectService.getScriptInfoForPath(infoPath);
-        return this.containsScriptInfo(info) || !!forEachResolvedProjectReferenceProject(
-          this,
-          info.path,
-          (child) => child.containsScriptInfo(info),
-          0 /* Find */
-        );
-      }
-    ) || false;
-  }
   /** @internal */
   isOrphan() {
     return !!this.deferredClose;
   }
-  /** @internal */
-  hasExternalProjectRef() {
-    return !!this.externalProjectRefCount;
-  }
   getEffectiveTypeRoots() {
     return getEffectiveTypeRoots(this.getCompilationSettings(), this) || [];
   }
@@ -183437,7 +183556,7 @@ var ConfiguredProject2 = class extends Project3 {
     updateErrorForNoInputFiles(fileNames, this.getConfigFilePath(), this.getCompilerOptions().configFile.configFileSpecs, this.projectErrors, this.canConfigFileJsonReportNoInputFiles);
   }
 };
-var ExternalProject2 = class extends Project3 {
+var ExternalProject = class extends Project3 {
   /** @internal */
   constructor(externalProjectName, projectService, documentRegistry, compilerOptions, lastFileExceededProgramSize, compileOnSaveEnabled, projectFilePath, watchOptions) {
     super(
@@ -183645,59 +183764,115 @@ function findProjectByName(projectName, projects) {
   }
 }
 var noopConfigFileWatcher = { close: noop };
+function getConfigFileNameFromCache(info, cache) {
+  if (!cache || isAncestorConfigFileInfo(info)) return void 0;
+  return cache.get(info.path);
+}
 function isOpenScriptInfo(infoOrFileNameOrConfig) {
   return !!infoOrFileNameOrConfig.containingProjects;
 }
 function isAncestorConfigFileInfo(infoOrFileNameOrConfig) {
   return !!infoOrFileNameOrConfig.configFileInfo;
 }
-var ProjectReferenceProjectLoadKind = /* @__PURE__ */ ((ProjectReferenceProjectLoadKind2) => {
-  ProjectReferenceProjectLoadKind2[ProjectReferenceProjectLoadKind2["Find"] = 0] = "Find";
-  ProjectReferenceProjectLoadKind2[ProjectReferenceProjectLoadKind2["FindCreate"] = 1] = "FindCreate";
-  return ProjectReferenceProjectLoadKind2;
-})(ProjectReferenceProjectLoadKind || {});
-function forEachResolvedProjectReferenceProject(project, fileName, cb, projectReferenceProjectLoadKind, reason) {
+var ConfiguredProjectLoadKind = /* @__PURE__ */ ((ConfiguredProjectLoadKind2) => {
+  ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Find"] = 0] = "Find";
+  ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Create"] = 1] = "Create";
+  ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Reload"] = 2] = "Reload";
+  return ConfiguredProjectLoadKind2;
+})(ConfiguredProjectLoadKind || {});
+function forEachAncestorProject(info, project, cb, kind, reason, allowDeferredClosed, reloadedProjects, delayReloadedConfiguredProjects) {
+  while (true) {
+    if (!project.isInitialLoadPending() && (!project.getCompilerOptions().composite || project.getCompilerOptions().disableSolutionSearching)) return;
+    const configFileName = project.projectService.getConfigFileNameForFile({
+      fileName: project.getConfigFilePath(),
+      path: info.path,
+      configFileInfo: true
+    }, kind === 0 /* Find */);
+    if (!configFileName) return;
+    const ancestor = project.projectService.findCreateOrReloadConfiguredProject(
+      configFileName,
+      kind,
+      reason,
+      allowDeferredClosed,
+      /*triggerFile*/
+      void 0,
+      reloadedProjects,
+      /*delayLoad*/
+      true,
+      delayReloadedConfiguredProjects
+    );
+    if (!ancestor) return;
+    if (ancestor.project.isInitialLoadPending() && project.getCompilerOptions().composite) {
+      ancestor.project.setPotentialProjectReference(project.canonicalConfigFilePath);
+    }
+    const result = cb(ancestor.project);
+    if (result) return result;
+    project = ancestor.project;
+  }
+}
+function forEachResolvedProjectReferenceProject(project, fileName, cb, kind, reason, allowDeferredClosed, triggerFile, reloadedProjects) {
   var _a;
   const resolvedRefs = (_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences();
   if (!resolvedRefs) return void 0;
-  let seenResolvedRefs;
   const possibleDefaultRef = fileName ? project.getResolvedProjectReferenceToRedirect(fileName) : void 0;
   if (possibleDefaultRef) {
     const configFileName = toNormalizedPath(possibleDefaultRef.sourceFile.fileName);
-    const child = project.projectService.findConfiguredProjectByProjectName(configFileName);
+    const child = project.projectService.findConfiguredProjectByProjectName(
+      configFileName,
+      allowDeferredClosed
+    );
     if (child) {
-      const result = cb(child);
+      const result = callbackWithProjectFoundUsingFind(child);
       if (result) return result;
-    } else if (projectReferenceProjectLoadKind !== 0 /* Find */) {
-      seenResolvedRefs = /* @__PURE__ */ new Map();
+    } else if (kind !== 0 /* Find */) {
       const result = forEachResolvedProjectReferenceProjectWorker(
         resolvedRefs,
         project.getCompilerOptions(),
         (ref, loadKind) => possibleDefaultRef === ref ? callback(ref, loadKind) : void 0,
-        projectReferenceProjectLoadKind,
-        project.projectService,
-        seenResolvedRefs
+        kind,
+        project.projectService
       );
       if (result) return result;
-      seenResolvedRefs.clear();
     }
   }
   return forEachResolvedProjectReferenceProjectWorker(
     resolvedRefs,
     project.getCompilerOptions(),
     (ref, loadKind) => possibleDefaultRef !== ref ? callback(ref, loadKind) : void 0,
-    projectReferenceProjectLoadKind,
-    project.projectService,
-    seenResolvedRefs
+    kind,
+    project.projectService
   );
   function callback(ref, loadKind) {
-    const configFileName = toNormalizedPath(ref.sourceFile.fileName);
-    const child = project.projectService.findConfiguredProjectByProjectName(configFileName) || (loadKind === 0 /* Find */ ? void 0 : loadKind === 1 /* FindCreate */ ? project.projectService.createConfiguredProject(configFileName, reason) : Debug.assertNever(loadKind));
-    return child && cb(child);
+    const result = project.projectService.findCreateOrReloadConfiguredProject(
+      toNormalizedPath(ref.sourceFile.fileName),
+      loadKind,
+      reason,
+      allowDeferredClosed,
+      triggerFile,
+      reloadedProjects
+    );
+    return result && (loadKind === kind ? cb(result.project, result.sentConfigFileDiag) : callbackWithProjectFoundUsingFind(result.project));
+  }
+  function callbackWithProjectFoundUsingFind(child) {
+    let sentConfigFileDiag = false;
+    switch (kind) {
+      case 1 /* Create */:
+        sentConfigFileDiag = updateConfiguredProject(child, triggerFile);
+        break;
+      case 2 /* Reload */:
+        sentConfigFileDiag = child.projectService.reloadConfiguredProjectClearingSemanticCache(child, reason, reloadedProjects);
+        break;
+      case 0 /* Find */:
+        break;
+      default:
+        Debug.assertNever(kind);
+    }
+    const result = cb(child, sentConfigFileDiag);
+    if (result) return result;
   }
 }
-function forEachResolvedProjectReferenceProjectWorker(resolvedProjectReferences, parentOptions, cb, projectReferenceProjectLoadKind, projectService, seenResolvedRefs) {
-  const loadKind = parentOptions.disableReferencedProjectLoad ? 0 /* Find */ : projectReferenceProjectLoadKind;
+function forEachResolvedProjectReferenceProjectWorker(resolvedProjectReferences, parentOptions, cb, kind, projectService, seenResolvedRefs) {
+  const loadKind = parentOptions.disableReferencedProjectLoad ? 0 /* Find */ : kind;
   return forEach(resolvedProjectReferences, (ref) => {
     if (!ref) return void 0;
     const configFileName = toNormalizedPath(ref.sourceFile.fileName);
@@ -183738,9 +183913,6 @@ function getDetailWatchInfo(watchType, project) {
 function isScriptInfoWatchedFromNodeModules(info) {
   return !info.isScriptOpen() && info.mTime !== void 0;
 }
-function projectContainsInfoDirectly(project, info) {
-  return project.containsScriptInfo(info) && !project.isSourceOfProjectReferenceRedirect(info.path);
-}
 function updateProjectIfDirty(project) {
   project.invalidateResolutionsOfFailedLookupLocations();
   return project.dirty && !project.updateGraph();
@@ -183758,6 +183930,25 @@ function updateWithTriggerFile(project, triggerFile, isReload) {
   project.triggerFileForConfigFileDiag = void 0;
   return sent;
 }
+function updateConfiguredProject(project, triggerFile) {
+  if (triggerFile) {
+    if (updateWithTriggerFile(
+      project,
+      triggerFile,
+      /*isReload*/
+      false
+    )) return true;
+  } else {
+    updateProjectIfDirty(project);
+  }
+  return false;
+}
+function fileOpenReason(info) {
+  return `Creating possible configured project for ${info.fileName} to open`;
+}
+function reloadReason(reason) {
+  return `User requested reload projects: ${reason}`;
+}
 function setProjectOptionsUsed(project) {
   if (isConfiguredProject(project)) {
     project.projectOptions = true;
@@ -183897,8 +184088,10 @@ var _ProjectService = class _ProjectService {
      * Open files: with value being project root path, and key being Path of the file that is open
      */
     this.openFiles = /* @__PURE__ */ new Map();
-    /** @internal */
+    /** Config files looked up and cached config files for open script info */
     this.configFileForOpenFiles = /* @__PURE__ */ new Map();
+    /** Set of open script infos that are root of inferred project */
+    this.rootOfInferredProjects = /* @__PURE__ */ new Set();
     /**
      * Map of open files that are opened without complete path but have projectRoot as current directory
      */
@@ -184252,9 +184445,28 @@ var _ProjectService = class _ProjectService {
     const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
     return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : void 0;
   }
+  /**
+   * If there is default project calculation pending for this file,
+   * then it completes that calculation so that correct default project is used for the project
+   */
+  tryGetDefaultProjectForEnsuringConfiguredProjectForFile(fileNameOrScriptInfo) {
+    var _a;
+    const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
+    if (!scriptInfo) return void 0;
+    if ((_a = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a.delete(scriptInfo.path)) {
+      this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+        scriptInfo,
+        1 /* Create */
+      );
+      if (scriptInfo.isOrphan()) {
+        this.assignOrphanScriptInfoToInferredProject(scriptInfo, this.openFiles.get(scriptInfo.path));
+      }
+    }
+    return this.tryGetDefaultProjectForFile(scriptInfo);
+  }
   /** @internal */
   ensureDefaultProjectForFile(fileNameOrScriptInfo) {
-    return this.tryGetDefaultProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo);
+    return this.tryGetDefaultProjectForEnsuringConfiguredProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo);
   }
   doEnsureDefaultProjectForFile(fileNameOrScriptInfo) {
     this.ensureProjectStructuresUptoDate();
@@ -184475,7 +184687,7 @@ var _ProjectService = class _ProjectService {
     return scheduledAnyProjectUpdate;
   }
   /** @internal */
-  onConfigFileChanged(canonicalConfigFilePath, eventKind) {
+  onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind) {
     const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
     const project = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
     const wasDefferedClose = project == null ? void 0 : project.deferredClose;
@@ -184489,44 +184701,35 @@ var _ProjectService = class _ProjectService {
         project.markAsDirty();
       }
     }
-    this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, "Change in config file detected");
-    this.delayReloadConfiguredProjectsForFile(
-      configFileExistenceInfo,
-      !wasDefferedClose && eventKind !== 2 /* Deleted */ ? identity : (
-        // Reload open files if they are root of inferred project
-        returnTrue
-      ),
-      // Reload all the open files impacted by config file
+    this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(
+      canonicalConfigFilePath,
       "Change in config file detected"
     );
-    this.delayEnsureProjectForOpenFiles();
-  }
-  /**
-   * This function goes through all the openFiles and tries to file the config file for them.
-   * If the config file is found and it refers to existing project, it schedules the reload it for reload
-   * If there is no existing project it just opens the configured project for the config file
-   * shouldReloadProjectFor provides a way to filter out files to reload configured project for
-   */
-  delayReloadConfiguredProjectsForFile(configFileExistenceInfo, shouldReloadProjectFor, reason) {
-    var _a;
-    const updatedProjects = /* @__PURE__ */ new Set();
-    (_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.forEach((infoIsRootOfInferredProject, path) => {
+    const updatedProjects = new Set(project ? [project] : void 0);
+    this.openFiles.forEach((_projectRootPath, path) => {
+      var _a, _b;
+      const configFileForOpenFile = this.configFileForOpenFiles.get(path);
+      if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path))) return;
       this.configFileForOpenFiles.delete(path);
-      if (!shouldReloadProjectFor(infoIsRootOfInferredProject)) {
-        return;
-      }
       const info = this.getScriptInfoForPath(path);
-      Debug.assert(info.isScriptOpen());
-      const configFileName = this.getConfigFileNameForFile(info);
-      if (configFileName) {
-        const project = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName, reason);
-        if (tryAddToSet(updatedProjects, project)) {
-          project.pendingUpdateLevel = 2 /* Full */;
-          project.pendingUpdateReason = reason;
-          this.delayUpdateProjectGraph(project);
-        }
+      const newConfigFileNameForInfo = this.getConfigFileNameForFile(
+        info,
+        /*findFromCacheOnly*/
+        false
+      );
+      if (!newConfigFileNameForInfo) return;
+      const projectForInfo = this.findConfiguredProjectByProjectName(newConfigFileNameForInfo) ?? this.createConfiguredProject(
+        newConfigFileNameForInfo,
+        `Change in config file ${configFileName} detected, ${fileOpenReason(info)}`
+      );
+      if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path))) {
+        (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path, configFileForOpenFile);
+      }
+      if (tryAddToSet(updatedProjects, projectForInfo) && projectForInfo.isInitialLoadPending()) {
+        this.delayUpdateProjectGraph(projectForInfo);
       }
     });
+    this.delayEnsureProjectForOpenFiles();
   }
   removeProject(project) {
     this.logger.info("`remove Project::");
@@ -184627,9 +184830,10 @@ var _ProjectService = class _ProjectService {
    * @param info The file that has been closed or newly configured
    */
   closeOpenFile(info, skipAssignOrphanScriptInfosToInferredProject) {
+    var _a;
     const fileExists = info.isDynamic ? false : this.host.fileExists(info.fileName);
     info.close(fileExists);
-    this.stopWatchingConfigFilesForClosedScriptInfo(info);
+    this.stopWatchingConfigFilesForScriptInfo(info);
     const canonicalFileName = this.toCanonicalFileName(info.fileName);
     if (this.openFilesWithNonRootedDiskPath.get(canonicalFileName) === info) {
       this.openFilesWithNonRootedDiskPath.delete(canonicalFileName);
@@ -184665,6 +184869,8 @@ var _ProjectService = class _ProjectService {
     }
     this.openFiles.delete(info.path);
     this.configFileForOpenFiles.delete(info.path);
+    (_a = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a.delete(info.path);
+    Debug.assert(!this.rootOfInferredProjects.has(info));
     if (!skipAssignOrphanScriptInfosToInferredProject && ensureProjectsForOpenFiles) {
       this.assignOrphanScriptInfosToInferredProject();
     }
@@ -184691,21 +184897,15 @@ var _ProjectService = class _ProjectService {
     info.closeSourceMapFileWatcher();
   }
   configFileExists(configFileName, canonicalConfigFilePath, info) {
-    var _a;
-    let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
-    if (configFileExistenceInfo) {
-      if (isOpenScriptInfo(info) && !((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(info.path))) {
-        (configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, false);
-      }
-      return configFileExistenceInfo.exists;
-    }
-    const exists = this.host.fileExists(configFileName);
+    const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
     let openFilesImpactedByConfigFile;
-    if (isOpenScriptInfo(info)) {
-      (openFilesImpactedByConfigFile || (openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, false);
+    if (this.openFiles.has(info.path) && !isAncestorConfigFileInfo(info)) {
+      if (configFileExistenceInfo) (configFileExistenceInfo.openFilesImpactedByConfigFile ?? (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(info.path);
+      else (openFilesImpactedByConfigFile = /* @__PURE__ */ new Set()).add(info.path);
     }
-    configFileExistenceInfo = { exists, openFilesImpactedByConfigFile };
-    this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
+    if (configFileExistenceInfo) return configFileExistenceInfo.exists;
+    const exists = this.host.fileExists(configFileName);
+    this.configFileExistenceInfoCache.set(canonicalConfigFilePath, { exists, openFilesImpactedByConfigFile });
     return exists;
   }
   /** @internal */
@@ -184715,7 +184915,7 @@ var _ProjectService = class _ProjectService {
     if (!configFileExistenceInfo.watcher || configFileExistenceInfo.watcher === noopConfigFileWatcher) {
       configFileExistenceInfo.watcher = this.watchFactory.watchFile(
         configFileName,
-        (_fileName, eventKind) => this.onConfigFileChanged(canonicalConfigFilePath, eventKind),
+        (_fileName, eventKind) => this.onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind),
         2e3 /* High */,
         this.getWatchOptionsFromProjectWatchOptions((_b = (_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config) == null ? void 0 : _a.parsedCommandLine) == null ? void 0 : _b.watchOptions, getDirectoryPath(configFileName)),
         WatchType.ConfigFile,
@@ -184725,12 +184925,6 @@ var _ProjectService = class _ProjectService {
     const projects = configFileExistenceInfo.config.projects;
     projects.set(forProject.canonicalConfigFilePath, projects.get(forProject.canonicalConfigFilePath) || false);
   }
-  /**
-   * Returns true if the configFileExistenceInfo is needed/impacted by open files that are root of inferred project
-   */
-  configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo) {
-    return configFileExistenceInfo.openFilesImpactedByConfigFile && forEachEntry(configFileExistenceInfo.openFilesImpactedByConfigFile, identity);
-  }
   /** @internal */
   releaseParsedConfig(canonicalConfigFilePath, forProject) {
     var _a, _b, _c;
@@ -184741,7 +184935,7 @@ var _ProjectService = class _ProjectService {
     clearSharedExtendedConfigFileWatcher(canonicalConfigFilePath, this.sharedExtendedConfigFileWatchers);
     Debug.checkDefined(configFileExistenceInfo.watcher);
     if ((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) {
-      if (this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
+      if (configFileExistenceInfo.inferredProjectRoots) {
         if (!canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath)))) {
           configFileExistenceInfo.watcher.close();
           configFileExistenceInfo.watcher = noopConfigFileWatcher;
@@ -184756,36 +184950,35 @@ var _ProjectService = class _ProjectService {
     }
   }
   /**
-   * Close the config file watcher in the cached ConfigFileExistenceInfo
-   *   if there arent any open files that are root of inferred project and there is no parsed config held by any project
-   *
+   * This is called on file close or when its removed from inferred project as root,
+   * so that we handle the watches and inferred project root data
    * @internal
    */
-  closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo) {
-    if (configFileExistenceInfo.watcher && !configFileExistenceInfo.config && !this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
-      configFileExistenceInfo.watcher.close();
-      configFileExistenceInfo.watcher = void 0;
-    }
-  }
-  /**
-   * This is called on file close, so that we stop watching the config file for this script info
-   */
-  stopWatchingConfigFilesForClosedScriptInfo(info) {
-    Debug.assert(!info.isScriptOpen());
+  stopWatchingConfigFilesForScriptInfo(info) {
+    if (this.serverMode !== 0 /* Semantic */) return;
+    const isRootOfInferredProject = this.rootOfInferredProjects.delete(info);
+    const isOpen = info.isScriptOpen();
+    if (isOpen && !isRootOfInferredProject) return;
     this.forEachConfigFileLocation(info, (canonicalConfigFilePath) => {
       var _a, _b, _c;
       const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
-      if (configFileExistenceInfo) {
-        const infoIsRootOfInferredProject = (_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.get(info.path);
-        (_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.delete(info.path);
-        if (infoIsRootOfInferredProject) {
-          this.closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo);
-        }
-        if (!((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) && !configFileExistenceInfo.config) {
-          Debug.assert(!configFileExistenceInfo.watcher);
-          this.configFileExistenceInfoCache.delete(canonicalConfigFilePath);
+      if (!configFileExistenceInfo) return;
+      if (isOpen) {
+        if (!((_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(info.path))) return;
+      } else {
+        if (!((_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.delete(info.path))) return;
+      }
+      if (isRootOfInferredProject) {
+        configFileExistenceInfo.inferredProjectRoots--;
+        if (configFileExistenceInfo.watcher && !configFileExistenceInfo.config && !configFileExistenceInfo.inferredProjectRoots) {
+          configFileExistenceInfo.watcher.close();
+          configFileExistenceInfo.watcher = void 0;
         }
       }
+      if (!((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) && !configFileExistenceInfo.config) {
+        Debug.assert(!configFileExistenceInfo.watcher);
+        this.configFileExistenceInfoCache.delete(canonicalConfigFilePath);
+      }
     });
   }
   /**
@@ -184794,39 +184987,27 @@ var _ProjectService = class _ProjectService {
    * @internal
    */
   startWatchingConfigFilesForInferredProjectRoot(info) {
+    if (this.serverMode !== 0 /* Semantic */) return;
     Debug.assert(info.isScriptOpen());
+    this.rootOfInferredProjects.add(info);
     this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName) => {
       let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
       if (!configFileExistenceInfo) {
-        configFileExistenceInfo = { exists: this.host.fileExists(configFileName) };
+        configFileExistenceInfo = { exists: this.host.fileExists(configFileName), inferredProjectRoots: 1 };
         this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
+      } else {
+        configFileExistenceInfo.inferredProjectRoots = (configFileExistenceInfo.inferredProjectRoots ?? 0) + 1;
       }
-      (configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, true);
+      (configFileExistenceInfo.openFilesImpactedByConfigFile ?? (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(info.path);
       configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath))) ? this.watchFactory.watchFile(
         configFileName,
-        (_filename, eventKind) => this.onConfigFileChanged(canonicalConfigFilePath, eventKind),
+        (_filename, eventKind) => this.onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind),
         2e3 /* High */,
         this.hostConfiguration.watchOptions,
         WatchType.ConfigFileForInferredRoot
       ) : noopConfigFileWatcher);
     });
   }
-  /**
-   * This is called by inferred project whenever root script info is removed from it
-   *
-   * @internal
-   */
-  stopWatchingConfigFilesForInferredProjectRoot(info) {
-    this.forEachConfigFileLocation(info, (canonicalConfigFilePath) => {
-      var _a;
-      const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
-      if ((_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(info.path)) {
-        Debug.assert(info.isScriptOpen());
-        configFileExistenceInfo.openFilesImpactedByConfigFile.set(info.path, false);
-        this.closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo);
-      }
-    });
-  }
   /**
    * This function tries to search for a tsconfig.json for the given file.
    * This is different from the method the compiler uses because
@@ -184869,10 +185050,25 @@ var _ProjectService = class _ProjectService {
   }
   /** @internal */
   findDefaultConfiguredProject(info) {
-    if (!info.isScriptOpen()) return void 0;
-    const configFileName = this.getConfigFileNameForFile(info);
-    const project = configFileName && this.findConfiguredProjectByProjectName(configFileName);
-    return project && projectContainsInfoDirectly(project, info) ? project : project == null ? void 0 : project.getDefaultChildProjectFromProjectWithReferences(info);
+    var _a;
+    return info.isScriptOpen() ? (_a = this.tryFindDefaultConfiguredProjectForOpenScriptInfo(
+      info,
+      0 /* Find */
+    )) == null ? void 0 : _a.defaultProject : void 0;
+  }
+  /** Get cached configFileName for scriptInfo or ancestor of open script info */
+  getConfigFileNameForFileFromCache(info, lookInPendingFilesForValue) {
+    if (lookInPendingFilesForValue) {
+      const result = getConfigFileNameFromCache(info, this.pendingOpenFileProjectUpdates);
+      if (result !== void 0) return result;
+    }
+    return getConfigFileNameFromCache(info, this.configFileForOpenFiles);
+  }
+  /** Caches the configFilename for script info or ancestor of open script info */
+  setConfigFileNameForFileInCache(info, configFileName) {
+    if (!this.openFiles.has(info.path)) return;
+    if (isAncestorConfigFileInfo(info)) return;
+    this.configFileForOpenFiles.set(info.path, configFileName || false);
   }
   /**
    * This function tries to search for a tsconfig.json for the given file.
@@ -184883,17 +185079,16 @@ var _ProjectService = class _ProjectService {
    * the newly opened file.
    * If script info is passed in, it is asserted to be open script info
    * otherwise just file name
+   * when findFromCacheOnly is true only looked up in cache instead of hitting disk to figure things out
+   * @internal
    */
-  getConfigFileNameForFile(info) {
-    if (!isAncestorConfigFileInfo(info)) {
-      const result = this.configFileForOpenFiles.get(info.path);
-      if (result !== void 0) return result || void 0;
-    }
+  getConfigFileNameForFile(info, findFromCacheOnly) {
+    const fromCache = this.getConfigFileNameForFileFromCache(info, findFromCacheOnly);
+    if (fromCache !== void 0) return fromCache || void 0;
+    if (findFromCacheOnly) return void 0;
     const configFileName = this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName2) => this.configFileExists(configFileName2, canonicalConfigFilePath, info));
     this.logger.info(`getConfigFileNameForFile:: File: ${info.fileName} ProjectRootPath: ${this.openFiles.get(info.path)}:: Result: ${configFileName}`);
-    if (isOpenScriptInfo(info)) {
-      this.configFileForOpenFiles.set(info.path, configFileName || false);
-    }
+    this.setConfigFileNameForFileInCache(info, configFileName);
     return configFileName;
   }
   printProjects() {
@@ -184913,10 +185108,10 @@ var _ProjectService = class _ProjectService {
     this.logger.endGroup();
   }
   /** @internal */
-  findConfiguredProjectByProjectName(configFileName) {
+  findConfiguredProjectByProjectName(configFileName, allowDeferredClosed) {
     const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName));
     const result = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
-    return !(result == null ? void 0 : result.deferredClose) ? result : void 0;
+    return allowDeferredClosed ? result : !(result == null ? void 0 : result.deferredClose) ? result : void 0;
   }
   getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) {
     return this.configuredProjects.get(canonicalConfigFilePath);
@@ -184950,7 +185145,7 @@ var _ProjectService = class _ProjectService {
   createExternalProject(projectFileName, files, options, typeAcquisition, excludedFiles) {
     const compilerOptions = convertCompilerOptions(options);
     const watchOptionsAndErrors = convertWatchOptions(options, getDirectoryPath(normalizeSlashes(projectFileName)));
-    const project = new ExternalProject2(
+    const project = new ExternalProject(
       projectFileName,
       this,
       this.documentRegistry,
@@ -184996,7 +185191,7 @@ var _ProjectService = class _ProjectService {
       exclude: projectOptions && projectOptions.configHasExcludeProperty,
       compileOnSave: project.compileOnSaveEnabled,
       configFileName: configFileName(),
-      projectType: project instanceof ExternalProject2 ? "external" : "configured",
+      projectType: project instanceof ExternalProject ? "external" : "configured",
       languageServiceEnabled: project.languageServiceEnabled,
       version
     };
@@ -185052,18 +185247,6 @@ var _ProjectService = class _ProjectService {
     this.createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, project);
     return project;
   }
-  /** @internal */
-  createLoadAndUpdateConfiguredProject(configFileName, reason, triggerFile) {
-    const project = this.createConfiguredProject(configFileName, reason);
-    if (triggerFile) updateWithTriggerFile(
-      project,
-      triggerFile,
-      /*isReload*/
-      false
-    );
-    else project.updateGraph();
-    return project;
-  }
   /**
    * Read the config file of the project, and update the project root file names.
    *
@@ -185337,14 +185520,23 @@ var _ProjectService = class _ProjectService {
   setFileNamesOfAutpImportProviderOrAuxillaryProject(project, fileNames) {
     this.updateNonInferredProjectFiles(project, fileNames, fileNamePropertyReader);
   }
+  /** @internal */
+  reloadConfiguredProjectClearingSemanticCache(project, reason, reloadedProjects) {
+    if (!tryAddToSet(reloadedProjects, project)) return false;
+    this.clearSemanticCache(project);
+    this.reloadConfiguredProject(project, reloadReason(reason));
+    return true;
+  }
   /**
    * Read the config file of the project again by clearing the cache and update the project graph
    *
    * @internal
    */
-  reloadConfiguredProject(project, reason, clearSemanticCache) {
+  reloadConfiguredProject(project, reason) {
+    project.isInitialLoadPending = returnFalse;
+    project.pendingUpdateReason = void 0;
+    project.pendingUpdateLevel = 0 /* Update */;
     const host = project.getCachedDirectoryStructureHost();
-    if (clearSemanticCache) this.clearSemanticCache(project);
     host.clearCache();
     this.loadConfiguredProject(project, reason);
     updateWithTriggerFile(
@@ -185356,6 +185548,7 @@ var _ProjectService = class _ProjectService {
   }
   /** @internal */
   clearSemanticCache(project) {
+    project.originalConfiguredProjects = void 0;
     project.resolutionCache.clear();
     project.getLanguageService(
       /*ensureSynchronized*/
@@ -185900,7 +186093,7 @@ Dynamic files must always be opened with service's current directory or service
         if (lazyConfiguredProjectsFromExternalProject && !this.hostConfiguration.preferences.lazyConfiguredProjectsFromExternalProject) {
           this.externalProjectToConfiguredProjectMap.forEach(
             (projects) => projects.forEach((project) => {
-              if (!project.deferredClose && !project.isClosed() && project.hasExternalProjectRef() && project.pendingUpdateLevel === 2 /* Full */ && !this.pendingProjectUpdates.has(project.getProjectName())) {
+              if (!project.deferredClose && !project.isClosed() && project.pendingUpdateLevel === 2 /* Full */ && !this.hasPendingProjectUpdate(project)) {
                 project.updateGraph();
               }
             })
@@ -185960,76 +186153,57 @@ Dynamic files must always be opened with service's current directory or service
       this.pendingProjectUpdates.delete(projectName);
     });
     this.throttledOperations.cancel(ensureProjectForOpenFileSchedule);
+    this.pendingOpenFileProjectUpdates = void 0;
     this.pendingEnsureProjectForOpenFiles = false;
     this.configFileExistenceInfoCache.forEach((info) => {
       if (info.config) info.config.updateLevel = 2 /* Full */;
     });
-    this.reloadConfiguredProjectForFiles("User requested reload projects");
+    this.configFileForOpenFiles.clear();
     this.externalProjects.forEach((project) => {
       this.clearSemanticCache(project);
       project.updateGraph();
     });
-    this.inferredProjects.forEach((project) => this.clearSemanticCache(project));
-    this.ensureProjectForOpenFiles();
-    this.logger.info("After reloading projects..");
-    this.printProjects();
-  }
-  /**
-   * This function goes through all the openFiles and tries to file the config file for them.
-   * If the config file is found and it refers to existing project, it reloads it either immediately
-   * If there is no existing project it just opens the configured project for the config file
-   */
-  reloadConfiguredProjectForFiles(reason) {
-    var _a;
-    const updatedProjects = /* @__PURE__ */ new Set();
-    const reloadChildProject = (child) => {
-      if (tryAddToSet(updatedProjects, child)) {
-        this.reloadConfiguredProject(
-          child,
-          reason,
-          /*clearSemanticCache*/
-          true
-        );
-      }
-    };
-    (_a = this.openFiles) == null ? void 0 : _a.forEach((_projectRoot, path) => {
-      this.configFileForOpenFiles.delete(path);
-      const info = this.getScriptInfoForPath(path);
-      Debug.assert(info.isScriptOpen());
-      const configFileName = this.getConfigFileNameForFile(info);
-      if (configFileName) {
-        const project = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName, reason);
-        if (tryAddToSet(updatedProjects, project)) {
-          this.reloadConfiguredProject(
+    const reloadedConfiguredProjects = /* @__PURE__ */ new Set();
+    const delayReloadedConfiguredProjects = /* @__PURE__ */ new Set();
+    this.externalProjectToConfiguredProjectMap.forEach((projects, externalProjectName) => {
+      const reason = `Reloading configured project in external project: ${externalProjectName}`;
+      projects.forEach((project) => {
+        if (this.getHostPreferences().lazyConfiguredProjectsFromExternalProject) {
+          if (!project.isInitialLoadPending()) {
+            this.clearSemanticCache(project);
+            project.pendingUpdateLevel = 2 /* Full */;
+            project.pendingUpdateReason = reloadReason(reason);
+          }
+          delayReloadedConfiguredProjects.add(project);
+        } else {
+          this.reloadConfiguredProjectClearingSemanticCache(
             project,
             reason,
-            /*clearSemanticCache*/
-            true
+            reloadedConfiguredProjects
           );
-          if (!projectContainsInfoDirectly(project, info)) {
-            const referencedProject = forEachResolvedProjectReferenceProject(
-              project,
-              info.path,
-              (child) => {
-                reloadChildProject(child);
-                return projectContainsInfoDirectly(child, info);
-              },
-              1 /* FindCreate */,
-              reason
-            );
-            if (referencedProject) {
-              forEachResolvedProjectReferenceProject(
-                project,
-                /*fileName*/
-                void 0,
-                reloadChildProject,
-                0 /* Find */
-              );
-            }
-          }
         }
-      }
+      });
+    });
+    this.openFiles.forEach((_projectRootPath, path) => {
+      const info = this.getScriptInfoForPath(path);
+      if (find(info.containingProjects, isExternalProject)) return;
+      this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+        info,
+        2 /* Reload */,
+        reloadedConfiguredProjects,
+        delayReloadedConfiguredProjects
+      );
     });
+    delayReloadedConfiguredProjects.forEach((p) => reloadedConfiguredProjects.add(p));
+    this.inferredProjects.forEach((project) => this.clearSemanticCache(project));
+    this.ensureProjectForOpenFiles();
+    this.cleanupProjectsAndScriptInfos(
+      reloadedConfiguredProjects,
+      new Set(this.openFiles.keys()),
+      new Set(this.externalProjectToConfiguredProjectMap.keys())
+    );
+    this.logger.info("After reloading projects..");
+    this.printProjects();
   }
   /**
    * Remove the root of inferred project if script info is part of another project
@@ -186057,6 +186231,14 @@ Dynamic files must always be opened with service's current directory or service
   ensureProjectForOpenFiles() {
     this.logger.info("Before ensureProjectForOpenFiles:");
     this.printProjects();
+    const pendingOpenFileProjectUpdates = this.pendingOpenFileProjectUpdates;
+    this.pendingOpenFileProjectUpdates = void 0;
+    pendingOpenFileProjectUpdates == null ? void 0 : pendingOpenFileProjectUpdates.forEach(
+      (_config, path) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+        this.getScriptInfoForPath(path),
+        1 /* Create */
+      )
+    );
     this.openFiles.forEach((projectRootPath, path) => {
       const info = this.getScriptInfoForPath(path);
       if (info.isOrphan()) {
@@ -186094,7 +186276,11 @@ Dynamic files must always be opened with service's current directory or service
     const scriptInfo = this.getScriptInfo(fileName);
     if (!scriptInfo && !this.host.fileExists(fileName)) return void 0;
     const originalFileInfo = { fileName: toNormalizedPath(fileName), path: this.toPath(fileName) };
-    const configFileName = this.getConfigFileNameForFile(originalFileInfo);
+    const configFileName = this.getConfigFileNameForFile(
+      originalFileInfo,
+      /*findFromCacheOnly*/
+      false
+    );
     if (!configFileName) return void 0;
     let configuredProject = this.findConfiguredProjectByProjectName(configFileName);
     if (!configuredProject) {
@@ -186109,17 +186295,14 @@ Dynamic files must always be opened with service's current directory or service
     updateProjectIfDirty(configuredProject);
     const projectContainsOriginalInfo = (project2) => {
       const info = this.getScriptInfo(fileName);
-      return info && projectContainsInfoDirectly(project2, info);
+      return info && project2.containsScriptInfo(info) && !project2.isSourceOfProjectReferenceRedirect(info.path);
     };
     if (configuredProject.isSolution() || !projectContainsOriginalInfo(configuredProject)) {
       configuredProject = forEachResolvedProjectReferenceProject(
         configuredProject,
         fileName,
-        (child) => {
-          updateProjectIfDirty(child);
-          return projectContainsOriginalInfo(child) ? child : void 0;
-        },
-        1 /* FindCreate */,
+        (child) => projectContainsOriginalInfo(child) ? child : void 0,
+        1 /* Create */,
         `Creating project referenced in solution ${configuredProject.projectName} to find possible configured project for original file: ${originalFileInfo.fileName}${location !== originalLocation ? " for location: " + location.fileName : ""}`
       );
       if (!configuredProject) return void 0;
@@ -186168,107 +186351,148 @@ Dynamic files must always be opened with service's current directory or service
   assignProjectToOpenedScriptInfo(info) {
     let configFileName;
     let configFileErrors;
-    let project = this.findExternalProjectContainingOpenScriptInfo(info);
+    const project = this.findExternalProjectContainingOpenScriptInfo(info);
     let retainProjects;
-    let projectForConfigFileDiag;
     let sentConfigDiag;
     if (!project && this.serverMode === 0 /* Semantic */) {
-      configFileName = this.getConfigFileNameForFile(info);
-      if (configFileName) {
-        project = this.findConfiguredProjectByProjectName(configFileName);
-        if (!project) {
-          project = this.createLoadAndUpdateConfiguredProject(configFileName, `Creating possible configured project for ${info.fileName} to open`, info.fileName);
-          (sentConfigDiag ?? (sentConfigDiag = /* @__PURE__ */ new Set())).add(project);
-        } else if (updateWithTriggerFile(
-          project,
-          info.fileName,
-          /*isReload*/
-          false
-        )) {
-          (sentConfigDiag ?? (sentConfigDiag = /* @__PURE__ */ new Set())).add(project);
-        }
-        projectForConfigFileDiag = project.containsScriptInfo(info) ? project : void 0;
-        retainProjects = project;
-        if (!projectContainsInfoDirectly(project, info)) {
-          forEachResolvedProjectReferenceProject(
-            project,
-            info.path,
-            (child) => {
-              if (updateWithTriggerFile(
-                child,
-                info.fileName,
-                /*isReload*/
-                false
-              )) {
-                (sentConfigDiag ?? (sentConfigDiag = /* @__PURE__ */ new Set())).add(child);
-              }
-              if (!isArray(retainProjects)) {
-                retainProjects = [project, child];
-              } else {
-                retainProjects.push(child);
-              }
-              if (projectContainsInfoDirectly(child, info)) {
-                projectForConfigFileDiag = child;
-                return child;
-              }
-              if (!projectForConfigFileDiag && child.containsScriptInfo(info)) {
-                projectForConfigFileDiag = child;
-              }
-            },
-            1 /* FindCreate */,
-            `Creating project referenced in solution ${project.projectName} to find possible configured project for ${info.fileName} to open`
-          );
-        }
-        if (projectForConfigFileDiag) {
-          configFileName = projectForConfigFileDiag.getConfigFilePath();
-          configFileErrors = projectForConfigFileDiag.getAllProjectErrors();
-        } else {
-          configFileName = void 0;
+      const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+        info,
+        1 /* Create */
+      );
+      if (result) {
+        retainProjects = result.seenProjects;
+        sentConfigDiag = result.sentConfigDiag;
+        if (result.defaultProject) {
+          configFileName = result.defaultProject.getConfigFilePath();
+          configFileErrors = result.defaultProject.getAllProjectErrors();
         }
-        this.createAncestorProjects(info, project);
       }
     }
     info.containingProjects.forEach(updateProjectIfDirty);
     if (info.isOrphan()) {
-      if (isArray(retainProjects)) {
-        retainProjects.forEach((project2) => {
-          if (!(sentConfigDiag == null ? void 0 : sentConfigDiag.has(project2))) this.sendConfigFileDiagEvent(
-            project2,
-            info.fileName,
-            /*force*/
-            true
-          );
-        });
-      } else if (retainProjects && !(sentConfigDiag == null ? void 0 : sentConfigDiag.has(retainProjects))) {
-        this.sendConfigFileDiagEvent(
-          retainProjects,
+      retainProjects == null ? void 0 : retainProjects.forEach((project2) => {
+        if (!sentConfigDiag.has(project2)) this.sendConfigFileDiagEvent(
+          project2,
           info.fileName,
           /*force*/
           true
         );
-      }
+      });
       Debug.assert(this.openFiles.has(info.path));
       this.assignOrphanScriptInfoToInferredProject(info, this.openFiles.get(info.path));
     }
     Debug.assert(!info.isOrphan());
     return { configFileName, configFileErrors, retainProjects };
   }
-  createAncestorProjects(info, project) {
-    if (!info.isAttached(project)) return;
-    while (true) {
-      if (!project.isInitialLoadPending() && (!project.getCompilerOptions().composite || project.getCompilerOptions().disableSolutionSearching)) return;
-      const configFileName = this.getConfigFileNameForFile({
-        fileName: project.getConfigFilePath(),
-        path: info.path,
-        configFileInfo: true
-      });
-      if (!configFileName) return;
-      const ancestor = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName, `Creating project possibly referencing default composite project ${project.getProjectName()} of open file ${info.fileName}`);
-      if (ancestor.isInitialLoadPending()) {
-        ancestor.setPotentialProjectReference(project.canonicalConfigFilePath);
-      }
-      project = ancestor;
+  /**
+   * Depending on kind
+   * - Find the configuedProject and return it - if allowDeferredClosed is set it will find the deferredClosed project as well
+   * - Create - if the project doesnt exist, it creates one as well. If not delayLoad, the project is updated (with triggerFile if passed)
+   * - Reload - if the project doesnt exist, it creates one. If not delayLoad, the project is reloaded clearing semantic cache
+   *  @internal
+   */
+  findCreateOrReloadConfiguredProject(configFileName, kind, reason, allowDeferredClosed, triggerFile, reloadedProjects, delayLoad, delayReloadedConfiguredProjects) {
+    let project = this.findConfiguredProjectByProjectName(configFileName, allowDeferredClosed);
+    let sentConfigFileDiag = false;
+    switch (kind) {
+      case 0 /* Find */:
+        if (!project) return;
+        break;
+      case 1 /* Create */:
+        project ?? (project = this.createConfiguredProject(configFileName, reason));
+        sentConfigFileDiag = !delayLoad && updateConfiguredProject(project, triggerFile);
+        break;
+      case 2 /* Reload */:
+        project ?? (project = this.createConfiguredProject(configFileName, reloadReason(reason)));
+        sentConfigFileDiag = !delayReloadedConfiguredProjects && this.reloadConfiguredProjectClearingSemanticCache(project, reason, reloadedProjects);
+        if (delayReloadedConfiguredProjects && !delayReloadedConfiguredProjects.has(project) && !reloadedProjects.has(project)) {
+          project.pendingUpdateLevel = 2 /* Full */;
+          project.pendingUpdateReason = reloadReason(reason);
+          delayReloadedConfiguredProjects.add(project);
+        }
+        break;
+      default:
+        Debug.assertNever(kind);
+    }
+    return { project, sentConfigFileDiag };
+  }
+  /**
+   * Finds the default configured project for given info
+   * For any tsconfig found, it looks into that project, if not then all its references,
+   * The search happens for all tsconfigs till projectRootPath
+   */
+  tryFindDefaultConfiguredProjectForOpenScriptInfo(info, kind, allowDeferredClosed, reloadedProjects) {
+    const configFileName = this.getConfigFileNameForFile(info, kind === 0 /* Find */);
+    if (!configFileName) return;
+    const result = this.findCreateOrReloadConfiguredProject(
+      configFileName,
+      kind,
+      fileOpenReason(info),
+      allowDeferredClosed,
+      info.fileName,
+      reloadedProjects
+    );
+    if (!result) return;
+    const seenProjects = /* @__PURE__ */ new Set();
+    const sentConfigDiag = new Set(result.sentConfigFileDiag ? [result.project] : void 0);
+    let defaultProject;
+    let possiblyDefault;
+    tryFindDefaultConfiguredProject(result.project);
+    return {
+      defaultProject: defaultProject ?? possiblyDefault,
+      sentConfigDiag,
+      seenProjects
+    };
+    function tryFindDefaultConfiguredProject(project) {
+      return isDefaultProject(project) ? defaultProject : tryFindDefaultConfiguredProjectFromReferences(project);
+    }
+    function isDefaultProject(project) {
+      if (!tryAddToSet(seenProjects, project)) return;
+      const projectWithInfo = project.containsScriptInfo(info);
+      if (projectWithInfo && !project.isSourceOfProjectReferenceRedirect(info.path)) return defaultProject = project;
+      possiblyDefault ?? (possiblyDefault = projectWithInfo ? project : void 0);
+    }
+    function tryFindDefaultConfiguredProjectFromReferences(project) {
+      return forEachResolvedProjectReferenceProject(
+        project,
+        info.path,
+        (child, sentConfigFileDiag) => {
+          if (sentConfigFileDiag) sentConfigDiag.add(child);
+          return isDefaultProject(child);
+        },
+        kind,
+        `Creating project referenced in solution ${project.projectName} to find possible configured project for ${info.fileName} to open`,
+        allowDeferredClosed,
+        info.fileName,
+        reloadedProjects
+      );
+    }
+  }
+  tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(info, kind, reloadedProjects, delayReloadedConfiguredProjects) {
+    const allowDeferredClosed = kind === 0 /* Find */;
+    const result = this.tryFindDefaultConfiguredProjectForOpenScriptInfo(
+      info,
+      kind,
+      allowDeferredClosed,
+      reloadedProjects
+    );
+    if (!result) return;
+    const { defaultProject, seenProjects } = result;
+    if (defaultProject) {
+      forEachAncestorProject(
+        info,
+        defaultProject,
+        (ancestor) => {
+          seenProjects.add(ancestor);
+        },
+        kind,
+        `Creating project possibly referencing default composite project ${defaultProject.getProjectName()} of open file ${info.fileName}`,
+        allowDeferredClosed,
+        reloadedProjects,
+        delayReloadedConfiguredProjects
+      );
     }
+    return result;
   }
   /** @internal */
   loadAncestorProjectTree(forProjects) {
@@ -186295,13 +186519,27 @@ Dynamic files must always be opened with service's current directory or service
       const referencedProject = forEachResolvedProjectReference(child.references, (ref) => forProjects.has(ref.sourceFile.path) ? ref : void 0);
       if (!referencedProject) continue;
       const configFileName = toNormalizedPath(child.sourceFile.fileName);
-      const childProject = project.projectService.findConfiguredProjectByProjectName(configFileName) || project.projectService.createConfiguredProject(configFileName, `Creating project referenced by : ${project.projectName} as it references project ${referencedProject.sourceFile.fileName}`);
+      const childProject = this.findConfiguredProjectByProjectName(configFileName) ?? this.createConfiguredProject(
+        configFileName,
+        `Creating project referenced by : ${project.projectName} as it references project ${referencedProject.sourceFile.fileName}`
+      );
       updateProjectIfDirty(childProject);
       this.ensureProjectChildren(childProject, forProjects, seenProjects);
     }
   }
-  cleanupAfterOpeningFile(toRetainConfigProjects) {
-    this.removeOrphanConfiguredProjects(toRetainConfigProjects);
+  cleanupConfiguredProjects(toRetainConfiguredProjects, externalProjectsRetainingConfiguredProjects, openFilesWithRetainedConfiguredProject) {
+    this.getOrphanConfiguredProjects(
+      toRetainConfiguredProjects,
+      openFilesWithRetainedConfiguredProject,
+      externalProjectsRetainingConfiguredProjects
+    ).forEach((project) => this.removeProject(project));
+  }
+  cleanupProjectsAndScriptInfos(toRetainConfiguredProjects, openFilesWithRetainedConfiguredProject, externalProjectsRetainingConfiguredProjects) {
+    this.cleanupConfiguredProjects(
+      toRetainConfiguredProjects,
+      externalProjectsRetainingConfiguredProjects,
+      openFilesWithRetainedConfiguredProject
+    );
     for (const inferredProject of this.inferredProjects.slice()) {
       if (inferredProject.isOrphan()) {
         this.removeProject(inferredProject);
@@ -186312,17 +186550,18 @@ Dynamic files must always be opened with service's current directory or service
   openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) {
     const info = this.getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath);
     const { retainProjects, ...result } = this.assignProjectToOpenedScriptInfo(info);
-    this.cleanupAfterOpeningFile(retainProjects);
+    this.cleanupProjectsAndScriptInfos(
+      retainProjects,
+      /* @__PURE__ */ new Set([info.path]),
+      /*externalProjectsRetainingConfiguredProjects*/
+      void 0
+    );
     this.telemetryOnOpenFile(info);
     this.printProjects();
     return result;
   }
-  removeOrphanConfiguredProjects(toRetainConfiguredProjects) {
-    const orphanConfiguredProjects = this.getOrphanConfiguredProjects(toRetainConfiguredProjects);
-    orphanConfiguredProjects.forEach((project) => this.removeProject(project));
-  }
   /** @internal */
-  getOrphanConfiguredProjects(toRetainConfiguredProjects) {
+  getOrphanConfiguredProjects(toRetainConfiguredProjects, openFilesWithRetainedConfiguredProject, externalProjectsRetainingConfiguredProjects) {
     const toRemoveConfiguredProjects = new Set(this.configuredProjects.values());
     const markOriginalProjectsAsUsed = (project) => {
       if (project.originalConfiguredProjects && (isConfiguredProject(project) || !project.isOrphan())) {
@@ -186334,32 +186573,45 @@ Dynamic files must always be opened with service's current directory or service
         );
       }
     };
-    if (toRetainConfiguredProjects) {
-      if (isArray(toRetainConfiguredProjects)) {
-        toRetainConfiguredProjects.forEach(retainConfiguredProject);
-      } else {
-        retainConfiguredProject(toRetainConfiguredProjects);
-      }
-    }
+    toRetainConfiguredProjects == null ? void 0 : toRetainConfiguredProjects.forEach(retainConfiguredProject);
     this.inferredProjects.forEach(markOriginalProjectsAsUsed);
     this.externalProjects.forEach(markOriginalProjectsAsUsed);
+    this.externalProjectToConfiguredProjectMap.forEach((projects, externalProjectName) => {
+      if (!(externalProjectsRetainingConfiguredProjects == null ? void 0 : externalProjectsRetainingConfiguredProjects.has(externalProjectName))) {
+        projects.forEach(retainConfiguredProject);
+      }
+    });
+    this.openFiles.forEach((_projectRootPath, path) => {
+      if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path)) return;
+      const info = this.getScriptInfoForPath(path);
+      if (find(info.containingProjects, isExternalProject)) return;
+      const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+        info,
+        0 /* Find */
+      );
+      if (result == null ? void 0 : result.defaultProject) {
+        result == null ? void 0 : result.seenProjects.forEach(retainConfiguredProject);
+      }
+    });
     this.configuredProjects.forEach((project) => {
-      if (!toRemoveConfiguredProjects.has(project)) return;
-      if (project.hasOpenRef()) {
-        retainConfiguredProject(project);
-      } else if (forEachReferencedProject(project, (ref) => isRetained(ref))) {
-        retainConfiguredProject(project);
+      if (toRemoveConfiguredProjects.has(project)) {
+        if (isPendingUpdate(project) || forEachReferencedProject(project, isRetained)) {
+          retainConfiguredProject(project);
+        }
       }
     });
     return toRemoveConfiguredProjects;
     function isRetained(project) {
-      return !toRemoveConfiguredProjects.has(project) || project.hasOpenRef();
+      return !toRemoveConfiguredProjects.has(project) || isPendingUpdate(project);
+    }
+    function isPendingUpdate(project) {
+      var _a, _b;
+      return (project.deferredClose || project.projectService.hasPendingProjectUpdate(project)) && !!((_b = (_a = project.projectService.configFileExistenceInfoCache.get(project.canonicalConfigFilePath)) == null ? void 0 : _a.openFilesImpactedByConfigFile) == null ? void 0 : _b.size);
     }
     function retainConfiguredProject(project) {
-      if (toRemoveConfiguredProjects.delete(project)) {
-        markOriginalProjectsAsUsed(project);
-        forEachReferencedProject(project, retainConfiguredProject);
-      }
+      if (!toRemoveConfiguredProjects.delete(project)) return;
+      markOriginalProjectsAsUsed(project);
+      forEachReferencedProject(project, retainConfiguredProject);
     }
   }
   removeOrphanScriptInfos() {
@@ -186474,14 +186726,20 @@ Dynamic files must always be opened with service's current directory or service
       }
     }
     let retainProjects;
-    if (openScriptInfos) {
-      retainProjects = flatMap(openScriptInfos, (info) => this.assignProjectToOpenedScriptInfo(info).retainProjects);
-    }
+    openScriptInfos == null ? void 0 : openScriptInfos.forEach((info) => {
+      var _a;
+      return (_a = this.assignProjectToOpenedScriptInfo(info).retainProjects) == null ? void 0 : _a.forEach((p) => (retainProjects ?? (retainProjects = /* @__PURE__ */ new Set())).add(p));
+    });
     if (assignOrphanScriptInfosToInferredProject) {
       this.assignOrphanScriptInfosToInferredProject();
     }
     if (openScriptInfos) {
-      this.cleanupAfterOpeningFile(retainProjects);
+      this.cleanupProjectsAndScriptInfos(
+        retainProjects,
+        new Set(openScriptInfos.map((info) => info.path)),
+        /*externalProjectsRetainingConfiguredProjects*/
+        void 0
+      );
       openScriptInfos.forEach((info) => this.telemetryOnOpenFile(info));
       this.printProjects();
     } else if (length(closedFiles)) {
@@ -186494,20 +186752,11 @@ Dynamic files must always be opened with service's current directory or service
       scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText);
     }
   }
-  closeConfiguredProjectReferencedFromExternalProject(configuredProjects) {
-    configuredProjects == null ? void 0 : configuredProjects.forEach((configuredProject) => {
-      if (!configuredProject.isClosed()) {
-        configuredProject.deleteExternalProjectReference();
-        if (!configuredProject.hasOpenRef()) this.removeProject(configuredProject);
-      }
-    });
-  }
   // eslint-disable-line @typescript-eslint/unified-signatures
-  closeExternalProject(uncheckedFileName, print) {
+  closeExternalProject(uncheckedFileName, cleanupAfter) {
     const fileName = toNormalizedPath(uncheckedFileName);
-    const configuredProjects = this.externalProjectToConfiguredProjectMap.get(fileName);
-    if (configuredProjects) {
-      this.closeConfiguredProjectReferencedFromExternalProject(configuredProjects);
+    const projects = this.externalProjectToConfiguredProjectMap.get(fileName);
+    if (projects) {
       this.externalProjectToConfiguredProjectMap.delete(fileName);
     } else {
       const externalProject = this.findExternalProjectByProjectName(uncheckedFileName);
@@ -186515,28 +186764,28 @@ Dynamic files must always be opened with service's current directory or service
         this.removeProject(externalProject);
       }
     }
-    if (print) this.printProjects();
+    if (cleanupAfter) {
+      this.cleanupConfiguredProjects();
+      this.printProjects();
+    }
   }
   openExternalProjects(projects) {
-    const projectsToClose = arrayToMap(this.externalProjects, (p) => p.getProjectName(), (_) => true);
-    forEachKey(this.externalProjectToConfiguredProjectMap, (externalProjectName) => {
-      projectsToClose.set(externalProjectName, true);
-    });
+    const projectsToClose = new Set(this.externalProjects.map((p) => p.getProjectName()));
+    this.externalProjectToConfiguredProjectMap.forEach((_, externalProjectName) => projectsToClose.add(externalProjectName));
     for (const externalProject of projects) {
       this.openExternalProject(
         externalProject,
-        /*print*/
+        /*cleanupAfter*/
         false
       );
       projectsToClose.delete(externalProject.projectFileName);
     }
-    forEachKey(projectsToClose, (externalProjectName) => {
-      this.closeExternalProject(
-        externalProjectName,
-        /*print*/
-        false
-      );
-    });
+    projectsToClose.forEach((externalProjectName) => this.closeExternalProject(
+      externalProjectName,
+      /*cleanupAfter*/
+      false
+    ));
+    this.cleanupConfiguredProjects();
     this.printProjects();
   }
   static escapeFilenameForRegex(filename) {
@@ -186641,9 +186890,8 @@ Dynamic files must always be opened with service's current directory or service
     }
   }
   // eslint-disable-line @typescript-eslint/unified-signatures
-  openExternalProject(proj, print) {
+  openExternalProject(proj, cleanupAfter) {
     const existingExternalProject = this.findExternalProjectByProjectName(proj.projectFileName);
-    const existingConfiguredProjects = this.externalProjectToConfiguredProjectMap.get(proj.projectFileName);
     let configuredProjects;
     let rootFiles = [];
     for (const file of proj.rootFiles) {
@@ -186652,18 +186900,11 @@ Dynamic files must always be opened with service's current directory or service
         if (this.serverMode === 0 /* Semantic */ && this.host.fileExists(normalized)) {
           let project = this.findConfiguredProjectByProjectName(normalized);
           if (!project) {
-            project = this.getHostPreferences().lazyConfiguredProjectsFromExternalProject ? this.createConfiguredProject(normalized, `Creating configured project in external project: ${proj.projectFileName}`) : this.createLoadAndUpdateConfiguredProject(
-              normalized,
-              `Creating configured project in external project: ${proj.projectFileName}`,
-              /*triggerFile*/
-              void 0
-            );
-          }
-          if (!(existingConfiguredProjects == null ? void 0 : existingConfiguredProjects.has(project))) {
-            project.addExternalProjectReference();
+            project = this.createConfiguredProject(normalized, `Creating configured project in external project: ${proj.projectFileName}`);
+            if (!this.getHostPreferences().lazyConfiguredProjectsFromExternalProject) project.updateGraph();
           }
           (configuredProjects ?? (configuredProjects = /* @__PURE__ */ new Set())).add(project);
-          existingConfiguredProjects == null ? void 0 : existingConfiguredProjects.delete(project);
+          Debug.assert(!project.isClosed());
         }
       } else {
         rootFiles.push(file);
@@ -186701,8 +186942,13 @@ Dynamic files must always be opened with service's current directory or service
         project.updateGraph();
       }
     }
-    this.closeConfiguredProjectReferencedFromExternalProject(existingConfiguredProjects);
-    if (print) this.printProjects();
+    if (cleanupAfter) {
+      this.cleanupConfiguredProjects(
+        configuredProjects,
+        new Set(proj.projectFileName)
+      );
+      this.printProjects();
+    }
   }
   hasDeferredExtension() {
     for (const extension of this.hostConfiguration.extraFileExtensions) {
@@ -187616,7 +187862,7 @@ var Session3 = class _Session {
       ["openExternalProject" /* OpenExternalProject */]: (request) => {
         this.projectService.openExternalProject(
           request.arguments,
-          /*print*/
+          /*cleanupAfter*/
           true
         );
         return this.requiredResponse(
@@ -187634,7 +187880,7 @@ var Session3 = class _Session {
       ["closeExternalProject" /* CloseExternalProject */]: (request) => {
         this.projectService.closeExternalProject(
           request.arguments.projectFileName,
-          /*print*/
+          /*cleanupAfter*/
           true
         );
         return this.requiredResponse(
@@ -191359,6 +191605,7 @@ __export(ts_server_exports4, {
   CommandNames: () => CommandNames,
   ConfigFileDiagEvent: () => ConfigFileDiagEvent,
   ConfiguredProject: () => ConfiguredProject2,
+  ConfiguredProjectLoadKind: () => ConfiguredProjectLoadKind,
   CreateDirectoryWatcherEvent: () => CreateDirectoryWatcherEvent,
   CreateFileWatcherEvent: () => CreateFileWatcherEvent,
   Errors: () => Errors,
@@ -191366,7 +191613,7 @@ __export(ts_server_exports4, {
   EventEndInstallTypes: () => EventEndInstallTypes,
   EventInitializationFailed: () => EventInitializationFailed,
   EventTypesRegistry: () => EventTypesRegistry,
-  ExternalProject: () => ExternalProject2,
+  ExternalProject: () => ExternalProject,
   GcTimer: () => GcTimer,
   InferredProject: () => InferredProject2,
   LargeFileReferencedEvent: () => LargeFileReferencedEvent,
@@ -191382,7 +191629,6 @@ __export(ts_server_exports4, {
   ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
   ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
   ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
-  ProjectReferenceProjectLoadKind: () => ProjectReferenceProjectLoadKind,
   ProjectService: () => ProjectService3,
   ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
   ScriptInfo: () => ScriptInfo,
@@ -191434,7 +191680,6 @@ __export(ts_server_exports4, {
   nowString: () => nowString,
   nullCancellationToken: () => nullCancellationToken,
   nullTypingsInstaller: () => nullTypingsInstaller,
-  projectContainsInfoDirectly: () => projectContainsInfoDirectly,
   protocol: () => ts_server_protocol_exports,
   removeSorted: () => removeSorted,
   stringifyIndented: () => stringifyIndented,
@@ -191496,7 +191741,6 @@ if (typeof console !== "undefined") {
   EmitHint,
   EmitOnly,
   EndOfLineState,
-  EnumKind,
   ExitStatus,
   ExportKind,
   Extension,