@abco20/btxml-checker 0.1.0 → 0.1.1

package/dist/server.cjs

@@ -15878,6 +15878,7 @@ var require_node3 = __commonJS({
 });
 
 // src/server.ts
+var import_promises2 = require("fs/promises");
 var import_node_path3 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 
@@ -40915,14 +40916,14 @@ function analyzeAssignment(context) {
   }
   const left = expression.left;
   const accessKind = expression.operator === ":=" ? "declare" : expression.operator === "=" ? "write" : "readwrite";
-  const access = {
+  const access2 = {
     name: left.name,
     kind: accessKind,
     range: left.range,
     identifier: left,
     statementIndex: context.statementIndex
   };
-  identifiers.push(access);
+  identifiers.push(access2);
   const existingSymbol = environment.symbols.get(left.name);
   if (expression.operator === ":=" && !existingSymbol) {
     const symbol2 = {
@@ -40939,14 +40940,14 @@ function analyzeAssignment(context) {
     };
     environment.symbols.set(left.name, symbol2);
     context.resolvedIdentifiers.push({
-      access,
+      access: access2,
       resolution: { kind: "symbol", symbol: symbol2 }
     });
     introducedSymbols.push(symbol2);
     return rightType;
   }
   if (!existingSymbol) {
-    context.resolvedIdentifiers.push({ access, resolution: { kind: "unknown" } });
+    context.resolvedIdentifiers.push({ access: access2, resolution: { kind: "unknown" } });
     reportDiagnostic(
       context,
       "assignment-to-unknown-variable",
@@ -40958,7 +40959,7 @@ function analyzeAssignment(context) {
     return ERROR_TYPE;
   }
   context.resolvedIdentifiers.push({
-    access,
+    access: access2,
     resolution: { kind: "symbol", symbol: existingSymbol }
   });
   if (expression.operator === "=") {
@@ -40993,18 +40994,18 @@ function analyzeAssignment(context) {
   return resultType;
 }
 function analyzeReadIdentifier(context, name, range) {
-  const access = {
+  const access2 = {
     name,
     kind: "read",
     range,
     identifier: context.expression,
     statementIndex: context.statementIndex
   };
-  context.identifiers.push(access);
+  context.identifiers.push(access2);
   const enumValue = context.environment.enums.get(name);
   if (enumValue !== void 0) {
     context.resolvedIdentifiers.push({
-      access,
+      access: access2,
       resolution: { kind: "enum", name, value: enumValue }
     });
     return NUMBER_TYPE;
@@ -41012,13 +41013,13 @@ function analyzeReadIdentifier(context, name, range) {
   const symbol2 = context.environment.symbols.get(name);
   if (symbol2) {
     context.resolvedIdentifiers.push({
-      access,
+      access: access2,
       resolution: { kind: "symbol", symbol: symbol2 }
     });
     return symbol2.type;
   }
-  context.resolvedIdentifiers.push({ access, resolution: { kind: "unknown" } });
-  context.unknownIdentifiers.push(access);
+  context.resolvedIdentifiers.push({ access: access2, resolution: { kind: "unknown" } });
+  context.unknownIdentifiers.push(access2);
   return UNKNOWN_TYPE;
 }
 function compoundAssignmentResult(left, right, operator) {
@@ -44796,40 +44797,40 @@ function createWorkspaceService(options = {}) {
       return documents2.get(uri);
     },
     getDiagnostics(uri) {
-      const access = getDocumentAccess(uri);
-      if (!access || !access.emitDiagnostics) return { diagnostics: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2 || !access2.emitDiagnostics) return { diagnostics: [] };
       const result = {
-        diagnostics: access.snapshot.diagnostics.diagnostics
+        diagnostics: access2.snapshot.diagnostics.diagnostics
       };
-      if (access.snapshot.diagnostics.partial) result.partial = true;
+      if (access2.snapshot.diagnostics.partial) result.partial = true;
       return result;
     },
     getWorkspaceDiagnostics() {
       return { diagnostics: [...getRuntimeState()?.diagnostics ?? runtimeDiagnostics] };
     },
     getSemanticDocumentView(uri) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { diagnostics: [] };
-      return getSemanticDocumentResult(uri, access.effectiveConfig);
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { diagnostics: [] };
+      return getSemanticDocumentResult(uri, access2.effectiveConfig);
     },
     getNodeCatalog(uri) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { models: [] };
-      return { models: getNodeCatalogModels(access.snapshot) };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { models: [] };
+      return { models: getNodeCatalogModels(access2.snapshot) };
     },
     getSemanticNode(uri, nodeId) {
-      const access = getDocumentAccess(uri);
-      if (!access) return {};
-      const result = getSemanticDocumentResult(uri, access.effectiveConfig);
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return {};
+      const result = getSemanticDocumentResult(uri, access2.effectiveConfig);
       return {
         node: result.view?.nodes.find((candidate) => candidate.nodeId === nodeId)
       };
     },
     getNodeUsageAt(uri, position) {
-      const access = getDocumentAccess(uri);
-      if (!access) return {};
-      const view = getSemanticView(access.snapshot);
-      if (!access.snapshot.parsed || !view) return {};
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return {};
+      const view = getSemanticView(access2.snapshot);
+      if (!access2.snapshot.parsed || !view) return {};
       const node = findSemanticNodeAtPosition(view, position);
       if (!node) return {};
       return {
@@ -44859,16 +44860,16 @@ function createWorkspaceService(options = {}) {
       if (genericKind === "Action" || genericKind === "Condition") {
         return { capable: false, reason: "generic-leaf" };
       }
-      const access = getDocumentAccess(uri);
-      if (!access) {
+      const access2 = getDocumentAccess(uri);
+      if (!access2) {
         return { capable: false, reason: "unknown-model" };
       }
-      const usage = resolveNodeUsage(access.snapshot.semantic, {
+      const usage = resolveNodeUsage(access2.snapshot.semantic, {
         element: createSyntheticElement(tagName, attributes),
-        documentRoot: access.snapshot.parsed?.root,
+        documentRoot: access2.snapshot.parsed?.root,
         uri,
-        config: access.snapshot.config,
-        policy: access.snapshot.nodeUsagePolicy
+        config: access2.snapshot.config,
+        policy: access2.snapshot.nodeUsagePolicy
       });
       if (usage.model.status !== "resolved") {
         return {
@@ -44883,20 +44884,20 @@ function createWorkspaceService(options = {}) {
       };
     },
     getPortInfoAt(uri, position) {
-      const access = getDocumentAccess(uri);
-      if (!access) return {};
-      const view = getSemanticView(access.snapshot);
-      if (!access.snapshot.parsed || !view) return {};
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return {};
+      const view = getSemanticView(access2.snapshot);
+      if (!access2.snapshot.parsed || !view) return {};
       const binding = findSemanticPortBindingAtPosition(view, position);
       const nodeUsageAt = this.getNodeUsageAt(uri, position);
       const node = nodeUsageAt.node;
-      const usage = binding && node ? resolvePortUsage(access.snapshot.semantic, {
+      const usage = binding && node ? resolvePortUsage(access2.snapshot.semantic, {
         element: node.usage.element,
-        documentRoot: access.snapshot.parsed.root,
+        documentRoot: access2.snapshot.parsed.root,
         attributeName: binding.portName,
         uri,
-        config: access.snapshot.config,
-        policy: access.snapshot.nodeUsagePolicy
+        config: access2.snapshot.config,
+        policy: access2.snapshot.nodeUsagePolicy
       }) : void 0;
       return {
         node,
@@ -44907,72 +44908,72 @@ function createWorkspaceService(options = {}) {
       };
     },
     getFormattingEdits(uri) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { edits: [], diagnostics: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { edits: [], diagnostics: [] };
       return languageService.getFormattingEdits({
-        document: access.document,
-        config: access.effectiveConfig
+        document: access2.document,
+        config: access2.effectiveConfig
       });
     },
     getCompletions(uri, position, triggerCharacter) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { items: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { items: [] };
       return languageService.getCompletions({
-        document: access.document,
+        document: access2.document,
         position,
         workspace: getRuntimeWorkspace(),
         triggerCharacter,
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getHover(uri, position) {
-      const access = getDocumentAccess(uri);
-      if (!access) return {};
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return {};
       return languageService.getHover({
-        document: access.document,
+        document: access2.document,
         position,
         workspace: getRuntimeWorkspace(),
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getDefinition(uri, position) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { locations: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { locations: [] };
       return languageService.getDefinition({
-        document: access.document,
+        document: access2.document,
         position,
         workspace: getRuntimeWorkspace(),
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getReferences(uri, position) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { locations: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { locations: [] };
       return languageService.getReferences({
-        document: access.document,
+        document: access2.document,
         position,
         workspace: getRuntimeWorkspace(),
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getDocumentSymbols(uri) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { symbols: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { symbols: [] };
       return languageService.getDocumentSymbols({
-        document: access.document,
+        document: access2.document,
         workspace: getRuntimeWorkspace(),
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getCodeActions(uri, range, diagnostics) {
-      const access = getDocumentAccess(uri);
-      if (!access) return { actions: [] };
+      const access2 = getDocumentAccess(uri);
+      if (!access2) return { actions: [] };
       return languageService.getCodeActions({
-        document: access.document,
+        document: access2.document,
         range,
         diagnostics,
         workspace: getRuntimeWorkspace(),
-        config: access.effectiveConfig
+        config: access2.effectiveConfig
       });
     },
     getLanguageService() {
@@ -45727,10 +45728,11 @@ var connection = (0, import_node4.createConnection)(import_node4.ProposedFeature
 var documents = new import_node4.TextDocuments(TextDocument);
 var openUris = /* @__PURE__ */ new Set();
 var debounceTimers = /* @__PURE__ */ new Map();
-var documentWorkspaceRoots = /* @__PURE__ */ new Map();
-var workspaceServices = /* @__PURE__ */ new Map();
-var loadedWorkspaceRoots = /* @__PURE__ */ new Set();
-var workspaceRoots = [process.cwd()];
+var documentProjectKeys = /* @__PURE__ */ new Map();
+var projectBindings = /* @__PURE__ */ new Map();
+var projectServices = /* @__PURE__ */ new Map();
+var loadedProjects = /* @__PURE__ */ new Set();
+var workspaceRoots = [import_node_path3.default.resolve(process.cwd())];
 var settings = {
   configPath: void 0,
   diagnosticsEnabled: true,
@@ -45751,41 +45753,45 @@ function normalizeDocumentUri(uri) {
     return uri;
   }
 }
-function normalizeWorkspaceRoot2(rootPath) {
-  const normalized = import_node_path3.default.resolve(rootPath).replace(/\\/g, "/").replace(/\/$/, "");
+function normalizeFsPath(fsPath) {
+  const normalized = import_node_path3.default.resolve(fsPath).replace(/\\/g, "/").replace(/\/$/, "");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
+function normalizeLanguageId(languageId) {
+  return languageId === "btcpp-xml" ? "btcpp-xml" : "xml";
+}
+function toDocumentSnapshot(document) {
+  return {
+    text: document.getText(),
+    version: document.version,
+    languageId: normalizeLanguageId(document.languageId)
+  };
+}
+function isWithinPath(parentPath, targetPath) {
+  const normalizedParent = normalizeFsPath(parentPath);
+  const normalizedTarget = normalizeFsPath(targetPath);
+  return normalizedTarget === normalizedParent || normalizedTarget.startsWith(`${normalizedParent}/`);
+}
 function setWorkspaceRoots(nextRoots) {
-  const deduped = /* @__PURE__ */ new Set();
+  const deduped = /* @__PURE__ */ new Map();
   for (const root of nextRoots) {
     const resolvedRoot = import_node_path3.default.resolve(root);
-    const normalizedRoot = normalizeWorkspaceRoot2(resolvedRoot);
+    const normalizedRoot = normalizeFsPath(resolvedRoot);
     if (deduped.has(normalizedRoot)) continue;
-    deduped.add(normalizedRoot);
+    deduped.set(normalizedRoot, resolvedRoot);
   }
-  workspaceRoots = [...deduped].map((normalizedRoot) => {
-    return nextRoots.find(
-      (root) => normalizeWorkspaceRoot2(import_node_path3.default.resolve(root)) === normalizedRoot
-    );
-  }).filter((root) => Boolean(root)) || [process.cwd()];
+  workspaceRoots = deduped.size > 0 ? [...deduped.values()] : [import_node_path3.default.resolve(process.cwd())];
 }
 function collectWorkspaceRoots(params) {
   const roots = params.workspaceFolders?.map((folder) => fileUriToPath4(folder.uri)) || (params.rootUri ? [fileUriToPath4(params.rootUri)] : params.rootPath ? [params.rootPath] : []);
   return roots.length > 0 ? roots : [process.cwd()];
 }
-function getWorkspaceService(rootPath) {
-  let workspace = workspaceServices.get(rootPath);
-  if (workspace) return workspace;
-  workspace = createNodeWorkspaceService({ cwd: rootPath });
-  workspaceServices.set(rootPath, workspace);
-  return workspace;
-}
 function resolveWorkspaceRootForPath(fsPath) {
-  const normalizedPath = normalizeWorkspaceRoot2(fsPath);
-  let matchedRoot = workspaceRoots[0] || process.cwd();
+  const normalizedPath = normalizeFsPath(fsPath);
+  let matchedRoot = workspaceRoots[0] || import_node_path3.default.resolve(process.cwd());
   let matchedLength = -1;
   for (const root of workspaceRoots) {
-    const normalizedRoot = normalizeWorkspaceRoot2(root);
+    const normalizedRoot = normalizeFsPath(root);
     if (normalizedPath !== normalizedRoot && !normalizedPath.startsWith(`${normalizedRoot}/`)) {
       continue;
     }
@@ -45796,18 +45802,21 @@ function resolveWorkspaceRootForPath(fsPath) {
   return matchedRoot;
 }
 function resolveWorkspaceRootForUri(uri) {
-  if (!uri.startsWith("file://")) return workspaceRoots[0] || process.cwd();
+  if (!uri.startsWith("file://")) return workspaceRoots[0] || import_node_path3.default.resolve(process.cwd());
   try {
     return resolveWorkspaceRootForPath(fileUriToPath4(uri));
   } catch {
-    return workspaceRoots[0] || process.cwd();
+    return workspaceRoots[0] || import_node_path3.default.resolve(process.cwd());
   }
 }
-function getDocumentWorkspaceRoot(uri) {
-  return documentWorkspaceRoots.get(uri) || resolveWorkspaceRootForUri(uri);
-}
-function getWorkspaceForDocumentUri(uri) {
-  return getWorkspaceService(getDocumentWorkspaceRoot(uri));
+function withNormalizedTextDocumentUri(params) {
+  return {
+    ...params,
+    textDocument: {
+      ...params.textDocument,
+      uri: normalizeDocumentUri(params.textDocument.uri)
+    }
+  };
 }
 function applySettings(next) {
   const scoped = next && typeof next === "object" && "btxml" in next ? next.btxml : next;
@@ -45821,103 +45830,187 @@ function applySettings(next) {
     diagnosticsDebounceMs: Number(value.diagnosticsDebounceMs ?? value.lsp?.diagnosticsDebounceMs ?? 200) || 200
   };
 }
-function getDocument(uri) {
-  const normalizedUri = normalizeDocumentUri(uri);
-  const workspace = getWorkspaceForDocumentUri(normalizedUri);
-  return workspace.getDocument(normalizedUri) || workspace.getDocument(fileUriToPath4(normalizedUri));
+async function pathExists(fsPath) {
+  try {
+    await (0, import_promises2.access)(fsPath);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function withNormalizedTextDocumentUri(params) {
+function getConfiguredConfigPath(workspaceRoot) {
+  if (!settings.configPath) return void 0;
+  return import_node_path3.default.isAbsolute(settings.configPath) ? import_node_path3.default.resolve(settings.configPath) : import_node_path3.default.resolve(workspaceRoot, settings.configPath);
+}
+async function findNearestConfigPath(documentPath, workspaceRoot) {
+  const boundedRoot = isWithinPath(workspaceRoot, documentPath) ? import_node_path3.default.resolve(workspaceRoot) : void 0;
+  let currentDir = import_node_path3.default.dirname(documentPath);
+  while (true) {
+    const candidate = import_node_path3.default.join(currentDir, "btxml.config.json");
+    if (await pathExists(candidate)) return candidate;
+    if (boundedRoot && normalizeFsPath(currentDir) === normalizeFsPath(boundedRoot))
+      return void 0;
+    const parentDir = import_node_path3.default.dirname(currentDir);
+    if (parentDir === currentDir) return void 0;
+    if (boundedRoot && !isWithinPath(boundedRoot, parentDir)) return void 0;
+    currentDir = parentDir;
+  }
+}
+function toWorkspaceProjectBinding(workspaceRoot) {
+  const resolvedWorkspaceRoot = import_node_path3.default.resolve(workspaceRoot);
   return {
-    ...params,
-    textDocument: {
-      ...params.textDocument,
-      uri: normalizeDocumentUri(params.textDocument.uri)
-    }
+    key: `workspace:${normalizeFsPath(resolvedWorkspaceRoot)}`,
+    cwd: resolvedWorkspaceRoot,
+    workspaceRoot: resolvedWorkspaceRoot
   };
 }
-async function reloadWorkspace(rootPath) {
-  const workspace = getWorkspaceService(rootPath);
-  const result = await workspace.loadProject({
-    cwd: rootPath,
-    configPath: settings.configPath
-  });
-  if (workspace.getResolvedConfig()) {
-    loadedWorkspaceRoots.add(rootPath);
-  } else {
-    loadedWorkspaceRoots.delete(rootPath);
+function toConfigProjectBinding(configPath2, workspaceRoot) {
+  const resolvedConfigPath = import_node_path3.default.resolve(configPath2);
+  return {
+    key: `config:${normalizeFsPath(resolvedConfigPath)}`,
+    cwd: import_node_path3.default.dirname(resolvedConfigPath),
+    workspaceRoot: import_node_path3.default.resolve(workspaceRoot),
+    configPath: resolvedConfigPath
+  };
+}
+async function resolveProjectForDocumentUri(uri) {
+  const workspaceRoot = import_node_path3.default.resolve(resolveWorkspaceRootForUri(uri));
+  const configuredConfigPath = getConfiguredConfigPath(workspaceRoot);
+  if (configuredConfigPath) {
+    return toConfigProjectBinding(configuredConfigPath, workspaceRoot);
+  }
+  if (uri.startsWith("file://")) {
+    try {
+      const nearestConfigPath = await findNearestConfigPath(fileUriToPath4(uri), workspaceRoot);
+      if (nearestConfigPath) return toConfigProjectBinding(nearestConfigPath, workspaceRoot);
+    } catch {
+    }
+  }
+  return toWorkspaceProjectBinding(workspaceRoot);
+}
+function getProjectService(binding) {
+  projectBindings.set(binding.key, binding);
+  let projectService = projectServices.get(binding.key);
+  if (projectService) return projectService;
+  projectService = createNodeWorkspaceService({ cwd: binding.cwd });
+  projectServices.set(binding.key, projectService);
+  return projectService;
+}
+function getProjectBindingForDocumentUri(uri) {
+  const key = documentProjectKeys.get(uri);
+  return key ? projectBindings.get(key) : void 0;
+}
+function getProjectServiceForBoundDocumentUri(uri) {
+  const binding = getProjectBindingForDocumentUri(uri);
+  return binding ? getProjectService(binding) : void 0;
+}
+function getWorkspaceDocument(uri) {
+  const normalizedUri = normalizeDocumentUri(uri);
+  const projectService = getProjectServiceForBoundDocumentUri(normalizedUri);
+  return projectService?.getDocument(normalizedUri) || (normalizedUri.startsWith("file://") ? projectService?.getDocument(fileUriToPath4(normalizedUri)) : void 0);
+}
+function getOpenDocumentSnapshot(uri) {
+  const document = documents.get(uri);
+  if (document) return toDocumentSnapshot(document);
+  const projectService = getProjectServiceForBoundDocumentUri(uri);
+  const workspaceDocument = projectService?.getDocument(uri);
+  return workspaceDocument ? toDocumentSnapshot(workspaceDocument) : void 0;
+}
+function isProjectInUse(key) {
+  for (const projectKey of documentProjectKeys.values()) {
+    if (projectKey === key) return true;
+  }
+  return false;
+}
+function disposeProject(key) {
+  const projectService = projectServices.get(key);
+  if (projectService) projectService.dispose();
+  projectServices.delete(key);
+  projectBindings.delete(key);
+  loadedProjects.delete(key);
+}
+function disposeProjectIfUnused(key) {
+  if (isProjectInUse(key)) return;
+  disposeProject(key);
+}
+function disposeUnusedProjects() {
+  for (const key of [...projectServices.keys()]) {
+    disposeProjectIfUnused(key);
   }
+}
+async function reloadProject(binding, options) {
+  const projectService = getProjectService(binding);
+  const result = await projectService.loadProject(
+    binding.configPath ? {
+      cwd: binding.cwd,
+      configPath: binding.configPath
+    } : {
+      cwd: binding.workspaceRoot
+    }
+  );
+  loadedProjects.add(binding.key);
   if (!result.ok && result.diagnostics.length > 0) {
     const lines = result.diagnostics.map((diag) => `${diag.severity} ${diag.code} ${diag.message}`);
     process.stderr.write(`${lines.join("\n")}
 `);
   }
-  for (const uri of openUris) {
-    if (getDocumentWorkspaceRoot(uri) !== rootPath) continue;
-    publishDiagnostics(uri);
+  if (options?.publishDiagnostics !== false) {
+    for (const uri of openUris) {
+      if (documentProjectKeys.get(uri) !== binding.key) continue;
+      publishDiagnostics(uri);
+    }
   }
   return result;
 }
-async function reloadAllWorkspaces() {
-  return Promise.all(workspaceRoots.map((rootPath) => reloadWorkspace(rootPath)));
+async function ensureProjectLoaded(binding) {
+  if (loadedProjects.has(binding.key)) return false;
+  await reloadProject(binding);
+  return true;
 }
-async function handleWorkspaceFoldersChanged(params) {
-  const removedRoots = new Set(
-    params.event.removed.map((folder) => normalizeWorkspaceRoot2(fileUriToPath4(folder.uri)))
-  );
-  const addedRoots = params.event.added.map((folder) => fileUriToPath4(folder.uri));
-  const movedOpenDocuments = /* @__PURE__ */ new Map();
-  for (const uri of openUris) {
-    const previousRoot = documentWorkspaceRoots.get(uri);
-    if (!previousRoot || !removedRoots.has(normalizeWorkspaceRoot2(previousRoot))) continue;
-    const document = workspaceServices.get(previousRoot)?.getDocument(uri);
-    movedOpenDocuments.set(
-      uri,
-      document ? {
-        text: document.text,
-        version: document.version,
-        languageId: document.languageId
-      } : void 0
-    );
-  }
-  setWorkspaceRoots(
-    workspaceRoots.filter((rootPath) => !removedRoots.has(normalizeWorkspaceRoot2(rootPath))).concat(addedRoots)
-  );
-  for (const [rootPath, workspace] of [...workspaceServices.entries()]) {
-    if (workspaceRoots.some(
-      (candidate) => normalizeWorkspaceRoot2(candidate) === normalizeWorkspaceRoot2(rootPath)
-    )) {
-      continue;
-    }
-    workspace.dispose();
-    workspaceServices.delete(rootPath);
-    loadedWorkspaceRoots.delete(rootPath);
+async function bindOpenDocument(uri, snapshot) {
+  const normalizedUri = normalizeDocumentUri(uri);
+  const nextBinding = await resolveProjectForDocumentUri(normalizedUri);
+  const previousKey = documentProjectKeys.get(normalizedUri);
+  const previousService = previousKey ? projectServices.get(previousKey) : void 0;
+  const nextService = getProjectService(nextBinding);
+  const changedProject = previousKey !== nextBinding.key;
+  const wasLoaded = loadedProjects.has(nextBinding.key);
+  if (changedProject) previousService?.closeDocument(normalizedUri);
+  documentProjectKeys.set(normalizedUri, nextBinding.key);
+  projectBindings.set(nextBinding.key, nextBinding);
+  if (!wasLoaded) {
+    await reloadProject(nextBinding, { publishDiagnostics: false });
+  }
+  if (!wasLoaded || changedProject || !nextService.getDocument(normalizedUri)) {
+    nextService.openDocument(normalizedUri, snapshot.text, snapshot.version, snapshot.languageId);
+  } else {
+    nextService.updateDocument(normalizedUri, snapshot.text, snapshot.version, snapshot.languageId);
   }
-  await reloadAllWorkspaces();
+  if (changedProject && previousKey) disposeProjectIfUnused(previousKey);
+  return { binding: nextBinding, reloaded: !wasLoaded };
+}
+async function rebindAllOpenDocuments() {
   for (const uri of openUris) {
-    const nextRoot = resolveWorkspaceRootForUri(uri);
-    const previousRoot = documentWorkspaceRoots.get(uri);
-    if (previousRoot === nextRoot) {
-      publishDiagnostics(uri);
-      continue;
-    }
-    const previousWorkspace = previousRoot ? workspaceServices.get(previousRoot) : void 0;
-    const document = previousWorkspace?.getDocument(uri) ?? movedOpenDocuments.get(uri);
-    previousWorkspace?.closeDocument(uri);
-    documentWorkspaceRoots.set(uri, nextRoot);
-    if (document) {
-      getWorkspaceService(nextRoot).openDocument(
-        uri,
-        document.text,
-        document.version,
-        document.languageId
-      );
-    }
+    const snapshot = getOpenDocumentSnapshot(uri);
+    if (!snapshot) continue;
+    await bindOpenDocument(uri, snapshot);
     publishDiagnostics(uri);
   }
+  disposeUnusedProjects();
+}
+async function getProjectServiceForDocumentUri(uri) {
+  const normalizedUri = normalizeDocumentUri(uri);
+  const boundBinding = getProjectBindingForDocumentUri(normalizedUri);
+  if (boundBinding) {
+    await ensureProjectLoaded(boundBinding);
+    return getProjectService(boundBinding);
+  }
+  const binding = await resolveProjectForDocumentUri(normalizedUri);
+  await ensureProjectLoaded(binding);
+  return getProjectService(binding);
 }
 function publishDiagnostics(uri) {
   const normalizedUri = normalizeDocumentUri(uri);
-  const workspace = getWorkspaceForDocumentUri(normalizedUri);
   if (!settings.diagnosticsEnabled) {
     connection.sendNotification("textDocument/publishDiagnostics", {
       uri: normalizedUri,
@@ -45925,15 +46018,16 @@ function publishDiagnostics(uri) {
     });
     return;
   }
-  const document = getDocument(normalizedUri);
-  if (!document) {
+  const document = getWorkspaceDocument(normalizedUri);
+  const projectService = getProjectServiceForBoundDocumentUri(normalizedUri);
+  if (!document || !projectService) {
     connection.sendNotification("textDocument/publishDiagnostics", {
       uri: normalizedUri,
       diagnostics: []
     });
     return;
   }
-  const result = workspace.getDiagnostics(normalizedUri);
+  const result = projectService.getDiagnostics(normalizedUri);
   connection.sendNotification("textDocument/publishDiagnostics", {
     uri: normalizedUri,
     diagnostics: result.diagnostics.map(toDiagnostic)
@@ -45948,54 +46042,52 @@ function scheduleDiagnostics(uri) {
   }, settings.diagnosticsDebounceMs);
   debounceTimers.set(uri, timeout);
 }
+function bindingMatchesFilePath(binding, fsPath) {
+  if (binding.configPath && normalizeFsPath(binding.configPath) === normalizeFsPath(fsPath))
+    return true;
+  return isWithinPath(binding.cwd, fsPath);
+}
 documents.onDidOpen(async (event) => {
   const normalizedUri = normalizeDocumentUri(event.document.uri);
-  const rootPath = resolveWorkspaceRootForUri(normalizedUri);
-  documentWorkspaceRoots.set(normalizedUri, rootPath);
-  if (!loadedWorkspaceRoots.has(rootPath)) {
-    await reloadWorkspace(rootPath);
-  }
   openUris.add(normalizedUri);
-  const workspace = getWorkspaceService(rootPath);
-  workspace.openDocument(
-    normalizedUri,
-    event.document.getText(),
-    event.document.version,
-    event.document.languageId === "btcpp-xml" ? "btcpp-xml" : "xml"
-  );
+  await bindOpenDocument(normalizedUri, toDocumentSnapshot(event.document));
   publishDiagnostics(normalizedUri);
 });
 documents.onDidChangeContent((event) => {
   const normalizedUri = normalizeDocumentUri(event.document.uri);
-  const workspace = getWorkspaceForDocumentUri(normalizedUri);
-  workspace.updateDocument(
+  const projectService = getProjectServiceForBoundDocumentUri(normalizedUri);
+  if (!projectService) return;
+  projectService.updateDocument(
     normalizedUri,
     event.document.getText(),
     event.document.version,
-    event.document.languageId === "btcpp-xml" ? "btcpp-xml" : "xml"
+    normalizeLanguageId(event.document.languageId)
   );
   scheduleDiagnostics(normalizedUri);
 });
 documents.onDidClose((event) => {
   const normalizedUri = normalizeDocumentUri(event.document.uri);
-  const workspace = getWorkspaceForDocumentUri(normalizedUri);
+  const projectKey = documentProjectKeys.get(normalizedUri);
+  const projectService = projectKey ? projectServices.get(projectKey) : void 0;
   openUris.delete(normalizedUri);
   const existing = debounceTimers.get(normalizedUri);
   if (existing) clearTimeout(existing);
   debounceTimers.delete(normalizedUri);
-  workspace.closeDocument(normalizedUri);
-  documentWorkspaceRoots.delete(normalizedUri);
+  projectService?.closeDocument(normalizedUri);
+  if (projectKey) {
+    documentProjectKeys.delete(normalizedUri);
+    disposeProjectIfUnused(projectKey);
+  }
   connection.sendNotification("textDocument/publishDiagnostics", {
     uri: normalizedUri,
     diagnostics: []
   });
 });
-connection.onInitialize(async (params) => {
+connection.onInitialize((params) => {
   applySettings(params.initializationOptions);
   setWorkspaceRoots(
     collectWorkspaceRoots(params)
   );
-  await reloadAllWorkspaces();
   return {
     serverInfo: {
       name: "btxml",
@@ -46031,114 +46123,125 @@ connection.onNotification(
   "workspace/didChangeConfiguration",
   async (params) => {
     applySettings(params.settings);
-    await reloadAllWorkspaces();
+    loadedProjects.clear();
+    await rebindAllOpenDocuments();
   }
 );
 connection.onNotification(
   "workspace/didChangeWorkspaceFolders",
   async (params) => {
-    await handleWorkspaceFoldersChanged(params);
+    const removedRoots = new Set(
+      params.event.removed.map((folder) => normalizeFsPath(fileUriToPath4(folder.uri)))
+    );
+    const addedRoots = params.event.added.map((folder) => fileUriToPath4(folder.uri));
+    setWorkspaceRoots(
+      workspaceRoots.filter((rootPath) => !removedRoots.has(normalizeFsPath(rootPath))).concat(addedRoots)
+    );
+    loadedProjects.clear();
+    await rebindAllOpenDocuments();
   }
 );
 connection.onNotification("workspace/didChangeWatchedFiles", async (params) => {
   const changes = params?.changes || [];
-  const reloadedRoots = /* @__PURE__ */ new Set();
-  await Promise.all(
-    changes.map(async (change) => {
-      const normalizedUri = normalizeDocumentUri(change.uri);
-      const affectedRoots = normalizedUri.startsWith("file://") ? (() => {
-        const rootPath = resolveWorkspaceRootForUri(normalizedUri);
-        const fsPath = fileUriToPath4(normalizedUri);
-        const normalizedRoot = normalizeWorkspaceRoot2(rootPath);
-        const normalizedPath = normalizeWorkspaceRoot2(fsPath);
-        return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`) ? [rootPath] : workspaceRoots;
-      })() : workspaceRoots;
-      const reloads = await Promise.all(
-        affectedRoots.map(
-          (rootPath) => getWorkspaceService(rootPath).notifyWatchedFileChanged(normalizedUri)
-        )
-      );
-      if (reloads.some((result) => result)) {
-        for (const rootPath of affectedRoots) reloadedRoots.add(rootPath);
-      }
-    })
-  );
-  if (reloadedRoots.size > 0) {
-    for (const uri of openUris) {
-      if (!reloadedRoots.has(getDocumentWorkspaceRoot(uri))) continue;
-      publishDiagnostics(uri);
+  if (changes.length === 0) return;
+  if (changes.some(
+    (change) => normalizeDocumentUri(change.uri).toLowerCase().endsWith("btxml.config.json")
+  )) {
+    loadedProjects.clear();
+    await rebindAllOpenDocuments();
+    return;
+  }
+  const reloadedProjects = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    const normalizedUri = normalizeDocumentUri(change.uri);
+    if (!normalizedUri.startsWith("file://")) continue;
+    const fsPath = fileUriToPath4(normalizedUri);
+    for (const binding of projectBindings.values()) {
+      if (!bindingMatchesFilePath(binding, fsPath)) continue;
+      const result = await getProjectService(binding).notifyWatchedFileChanged(normalizedUri);
+      if (!result) continue;
+      loadedProjects.add(binding.key);
+      reloadedProjects.add(binding.key);
     }
   }
+  if (reloadedProjects.size === 0) return;
+  for (const uri of openUris) {
+    const projectKey = documentProjectKeys.get(uri);
+    if (!projectKey || !reloadedProjects.has(projectKey)) continue;
+    publishDiagnostics(uri);
+  }
 });
-connection.onRequest("textDocument/completion", (params) => {
+connection.onRequest("textDocument/completion", async (params) => {
   if (!settings.completionEnabled) return [];
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleCompletion(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("textDocument/hover", (params) => {
+connection.onRequest("textDocument/hover", async (params) => {
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleHover(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("textDocument/definition", (params) => {
+connection.onRequest("textDocument/definition", async (params) => {
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleDefinition(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("textDocument/references", (params) => {
+connection.onRequest("textDocument/references", async (params) => {
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleReferences(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("textDocument/documentSymbol", (params) => {
+connection.onRequest("textDocument/documentSymbol", async (params) => {
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleDocumentSymbols(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams,
     import_node4.SymbolKind
   );
 });
-connection.onRequest("textDocument/formatting", (params) => {
+connection.onRequest("textDocument/formatting", async (params) => {
   if (!settings.formatEnabled) return [];
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleFormatting(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("textDocument/codeAction", (params) => {
+connection.onRequest("textDocument/codeAction", async (params) => {
   const normalizedParams = withNormalizedTextDocumentUri(params);
   return handleCodeActions(
-    getWorkspaceForDocumentUri(normalizedParams.textDocument.uri),
-    getDocument(normalizedParams.textDocument.uri),
+    await getProjectServiceForDocumentUri(normalizedParams.textDocument.uri),
+    getWorkspaceDocument(normalizedParams.textDocument.uri),
     normalizedParams
   );
 });
-connection.onRequest("btxml/getNodeModelById", (params) => {
-  return handleGetNodeModelById(getWorkspaceForDocumentUri(normalizeDocumentUri(params.uri)), {
+connection.onRequest("btxml/getNodeModelById", async (params) => {
+  const normalizedUri = normalizeDocumentUri(params.uri);
+  return handleGetNodeModelById(await getProjectServiceForDocumentUri(normalizedUri), {
     ...params,
-    uri: normalizeDocumentUri(params.uri)
+    uri: normalizedUri
   });
 });
-connection.onRequest("btxml/getChildCapability", (params) => {
-  return handleGetChildCapability(getWorkspaceForDocumentUri(normalizeDocumentUri(params.uri)), {
+connection.onRequest("btxml/getChildCapability", async (params) => {
+  const normalizedUri = normalizeDocumentUri(params.uri);
+  return handleGetChildCapability(await getProjectServiceForDocumentUri(normalizedUri), {
     ...params,
-    uri: normalizeDocumentUri(params.uri)
+    uri: normalizedUri
   });
 });
 async function startLanguageServer() {