sysml-v2-lsp 0.37.0 → 0.39.0

package/dist/server/browserServerMain.js

@@ -123,30 +123,30 @@
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
       var is = __importStar(require_is());
-      var ErrorCodes2;
-      (function(ErrorCodes3) {
-        ErrorCodes3.ParseError = -32700;
-        ErrorCodes3.InvalidRequest = -32600;
-        ErrorCodes3.MethodNotFound = -32601;
-        ErrorCodes3.InvalidParams = -32602;
-        ErrorCodes3.InternalError = -32603;
-        ErrorCodes3.jsonrpcReservedErrorRangeStart = -32099;
-        ErrorCodes3.serverErrorStart = -32099;
-        ErrorCodes3.MessageWriteError = -32099;
-        ErrorCodes3.MessageReadError = -32098;
-        ErrorCodes3.PendingResponseRejected = -32097;
-        ErrorCodes3.ConnectionInactive = -32096;
-        ErrorCodes3.ServerNotInitialized = -32002;
-        ErrorCodes3.UnknownErrorCode = -32001;
-        ErrorCodes3.jsonrpcReservedErrorRangeEnd = -32e3;
-        ErrorCodes3.serverErrorEnd = -32e3;
-      })(ErrorCodes2 || (exports.ErrorCodes = ErrorCodes2 = {}));
-      var ResponseError2 = class _ResponseError extends Error {
+      var ErrorCodes3;
+      (function(ErrorCodes4) {
+        ErrorCodes4.ParseError = -32700;
+        ErrorCodes4.InvalidRequest = -32600;
+        ErrorCodes4.MethodNotFound = -32601;
+        ErrorCodes4.InvalidParams = -32602;
+        ErrorCodes4.InternalError = -32603;
+        ErrorCodes4.jsonrpcReservedErrorRangeStart = -32099;
+        ErrorCodes4.serverErrorStart = -32099;
+        ErrorCodes4.MessageWriteError = -32099;
+        ErrorCodes4.MessageReadError = -32098;
+        ErrorCodes4.PendingResponseRejected = -32097;
+        ErrorCodes4.ConnectionInactive = -32096;
+        ErrorCodes4.ServerNotInitialized = -32002;
+        ErrorCodes4.UnknownErrorCode = -32001;
+        ErrorCodes4.jsonrpcReservedErrorRangeEnd = -32e3;
+        ErrorCodes4.serverErrorEnd = -32e3;
+      })(ErrorCodes3 || (exports.ErrorCodes = ErrorCodes3 = {}));
+      var ResponseError3 = class _ResponseError extends Error {
         code;
         data;
         constructor(code, message, data) {
           super(message);
-          this.code = is.number(code) ? code : ErrorCodes2.UnknownErrorCode;
+          this.code = is.number(code) ? code : ErrorCodes3.UnknownErrorCode;
           this.data = data;
           Object.setPrototypeOf(this, _ResponseError.prototype);
         }
@@ -161,7 +161,7 @@
           return result;
         }
       };
-      exports.ResponseError = ResponseError2;
+      exports.ResponseError = ResponseError3;
       var ParameterStructures = class _ParameterStructures {
         kind;
         /**
@@ -3526,7 +3526,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         CodeDescription3.is = is;
       })(CodeDescription || (CodeDescription = {}));
-      (function(Diagnostic8) {
+      (function(Diagnostic9) {
         function create(range, message, severity, code, source, relatedInformation) {
           const result = { range, message };
           if (Is.defined(severity)) {
@@ -3543,17 +3543,17 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return result;
         }
-        Diagnostic8.create = create;
+        Diagnostic9.create = create;
         function is(value) {
           var _a;
           const candidate = value;
           return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.message) || MarkupContent.is(candidate.message)) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
         }
-        Diagnostic8.is = is;
+        Diagnostic9.is = is;
         function is3_17(value) {
           return Is.string(value.message);
         }
-        Diagnostic8.is3_17 = is3_17;
+        Diagnostic9.is3_17 = is3_17;
         function getMessageString(diagnostic) {
           if (Is.string(diagnostic.message)) {
             return diagnostic.message;
@@ -3563,7 +3563,7 @@ ${JSON.stringify(message, null, 4)}`);
             throw new Error(`Unknown message type ${typeof diagnostic.message}`);
           }
         }
-        Diagnostic8.getMessageString = getMessageString;
+        Diagnostic9.getMessageString = getMessageString;
       })(Diagnostic || (Diagnostic = {}));
       (function(Command3) {
         function create(title, command, ...args) {
@@ -9290,28 +9290,28 @@ ${JSON.stringify(message, null, 4)}`);
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
       var is = require_is4();
-      var ErrorCodes2;
-      (function(ErrorCodes3) {
-        ErrorCodes3.ParseError = -32700;
-        ErrorCodes3.InvalidRequest = -32600;
-        ErrorCodes3.MethodNotFound = -32601;
-        ErrorCodes3.InvalidParams = -32602;
-        ErrorCodes3.InternalError = -32603;
-        ErrorCodes3.jsonrpcReservedErrorRangeStart = -32099;
-        ErrorCodes3.serverErrorStart = -32099;
-        ErrorCodes3.MessageWriteError = -32099;
-        ErrorCodes3.MessageReadError = -32098;
-        ErrorCodes3.PendingResponseRejected = -32097;
-        ErrorCodes3.ConnectionInactive = -32096;
-        ErrorCodes3.ServerNotInitialized = -32002;
-        ErrorCodes3.UnknownErrorCode = -32001;
-        ErrorCodes3.jsonrpcReservedErrorRangeEnd = -32e3;
-        ErrorCodes3.serverErrorEnd = -32e3;
-      })(ErrorCodes2 || (exports.ErrorCodes = ErrorCodes2 = {}));
-      var ResponseError2 = class _ResponseError extends Error {
+      var ErrorCodes3;
+      (function(ErrorCodes4) {
+        ErrorCodes4.ParseError = -32700;
+        ErrorCodes4.InvalidRequest = -32600;
+        ErrorCodes4.MethodNotFound = -32601;
+        ErrorCodes4.InvalidParams = -32602;
+        ErrorCodes4.InternalError = -32603;
+        ErrorCodes4.jsonrpcReservedErrorRangeStart = -32099;
+        ErrorCodes4.serverErrorStart = -32099;
+        ErrorCodes4.MessageWriteError = -32099;
+        ErrorCodes4.MessageReadError = -32098;
+        ErrorCodes4.PendingResponseRejected = -32097;
+        ErrorCodes4.ConnectionInactive = -32096;
+        ErrorCodes4.ServerNotInitialized = -32002;
+        ErrorCodes4.UnknownErrorCode = -32001;
+        ErrorCodes4.jsonrpcReservedErrorRangeEnd = -32e3;
+        ErrorCodes4.serverErrorEnd = -32e3;
+      })(ErrorCodes3 || (exports.ErrorCodes = ErrorCodes3 = {}));
+      var ResponseError3 = class _ResponseError extends Error {
         constructor(code, message, data) {
           super(message);
-          this.code = is.number(code) ? code : ErrorCodes2.UnknownErrorCode;
+          this.code = is.number(code) ? code : ErrorCodes3.UnknownErrorCode;
           this.data = data;
           Object.setPrototypeOf(this, _ResponseError.prototype);
         }
@@ -9326,7 +9326,7 @@ ${JSON.stringify(message, null, 4)}`);
           return result;
         }
       };
-      exports.ResponseError = ResponseError2;
+      exports.ResponseError = ResponseError3;
       var ParameterStructures = class _ParameterStructures {
         constructor(kind) {
           this.kind = kind;
@@ -12599,7 +12599,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         CodeDescription3.is = is;
       })(CodeDescription2 || (CodeDescription2 = {}));
-      (function(Diagnostic8) {
+      (function(Diagnostic9) {
         function create(range, message, severity, code, source, relatedInformation) {
           let result = { range, message };
           if (Is2.defined(severity)) {
@@ -12616,13 +12616,13 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return result;
         }
-        Diagnostic8.create = create;
+        Diagnostic9.create = create;
         function is(value) {
           var _a;
           let candidate = value;
           return Is2.defined(candidate) && Range2.is(candidate.range) && Is2.string(candidate.message) && (Is2.number(candidate.severity) || Is2.undefined(candidate.severity)) && (Is2.integer(candidate.code) || Is2.string(candidate.code) || Is2.undefined(candidate.code)) && (Is2.undefined(candidate.codeDescription) || Is2.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is2.string(candidate.source) || Is2.undefined(candidate.source)) && (Is2.undefined(candidate.relatedInformation) || Is2.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation2.is));
         }
-        Diagnostic8.is = is;
+        Diagnostic9.is = is;
       })(Diagnostic2 || (Diagnostic2 = {}));
       (function(Command3) {
         function create(title, command, ...args) {
@@ -17437,7 +17437,7 @@ ${JSON.stringify(message, null, 4)}`);
   });
 
   // server/src/server.ts
-  var import_node13 = __toESM(require_main3());
+  var import_node14 = __toESM(require_main3());
 
   // server/src/platform/shims/fs.ts
   function readFileSync(_path, _enc) {
@@ -133028,6 +133028,13 @@ ${JSON.stringify(message, null, 4)}`);
      * indexed yet" apart from "genuinely doesn't exist".
      */
     workspaceScanComplete = true;
+    /**
+     * Last version given to a stand-in text by `withTexts`. Caches keyed by
+     * version assume one text per uri and version, so each stand-in gets a
+     * version outside the LSP integer range (LSP 3.17, base types).
+     * These internal positive versions are never sent to the client.
+     */
+    temporaryVersion = 2 ** 31 - 1;
     /**
      * Parse a document and cache the result.
      * Returns the cached result if the content hasn't changed.
@@ -133231,6 +133238,35 @@ ${JSON.stringify(message, null, 4)}`);
       this.wsSymbolTable.removeUri(uri);
       this.wsBuiltVersions.delete(uri);
     }
+    /**
+     * Runs `fn` with each text standing in for the document at its uri (or
+     * added as a new document), all at once, then restores the previous
+     * state. `fn` must be synchronous: no other request can run in between,
+     * so no other request ever sees the temporary texts. Every text is
+     * parsed before anything changes. The stand-ins get versions no real
+     * document has, so caches keyed by version never confuse them with the
+     * real documents.
+     */
+    withTexts(documents2, fn) {
+      if (!Number.isSafeInteger(this.temporaryVersion + documents2.length)) {
+        throw new RangeError("Temporary document version space exhausted.");
+      }
+      const parsed = documents2.map(({ uri, text }) => ({ uri, text, result: parseDocument(text) }));
+      const previous = new Map(parsed.map(({ uri }) => [uri, this.cache.get(uri)]));
+      for (const { uri, text, result } of parsed) {
+        this.cache.set(uri, { version: ++this.temporaryVersion, text, result, needsParse: false });
+      }
+      try {
+        return fn();
+      } finally {
+        for (const [uri, entry] of previous) {
+          if (entry) this.cache.set(uri, entry);
+          else this.cache.delete(uri);
+          this.wsSymbolTable.removeUri(uri);
+          this.wsBuiltVersions.delete(uri);
+        }
+      }
+    }
     /**
      * Get all cached URIs.
      */
@@ -136411,12 +136447,19 @@ ${JSON.stringify(message, null, 4)}`);
   function findConflictedQualifiedNames(allSymbols) {
     return groupConflicts(allSymbols.filter((s) => s.qualifiedName !== void 0), (s) => s.qualifiedName);
   }
+  function memberNamesOf(symbol) {
+    return symbol.shortName && symbol.shortName !== symbol.name ? [symbol.name, symbol.shortName] : [symbol.name];
+  }
   function findConflictingDeclarations(allSymbols) {
     const conflicting = /* @__PURE__ */ new Map();
     const add = (groups) => {
-      for (const group of groups.values()) for (const s of group) conflicting.set(s, group);
+      for (const group of groups) {
+        for (const s of group) {
+          conflicting.set(s, [.../* @__PURE__ */ new Set([...conflicting.get(s) ?? [], ...group])]);
+        }
+      }
     };
-    add(findConflictedQualifiedNames(allSymbols));
+    add(findConflictedQualifiedNames(allSymbols).values());
     const membersOfAnonymous = allSymbols.filter((s) => s.qualifiedName === void 0 && !isAnonymous(s) && s.parentId !== void 0);
     const byOwner = /* @__PURE__ */ new Map();
     for (const s of membersOfAnonymous) {
@@ -136424,13 +136467,33 @@ ${JSON.stringify(message, null, 4)}`);
       list.push(s);
       byOwner.set(s.parentId, list);
     }
-    for (const members of byOwner.values()) add(groupConflicts(members, (s) => s.name));
+    for (const members of byOwner.values()) add(groupConflicts(members, (s) => s.name).values());
+    add([...findConflictingShortNames(allSymbols).values()].map((group) => group.symbols));
     return conflicting;
   }
+  function findConflictingShortNames(allSymbols) {
+    const byId = new Map(allSymbols.map((s) => [s.symbolId, s]));
+    const entries = [];
+    const keysWithShortName = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) {
+      if (isAnonymous(s)) continue;
+      const owner = s.parentId ? byId.get(s.parentId) : void 0;
+      const namespace = owner === void 0 ? "q:" : owner.qualifiedName !== void 0 ? `q:${owner.qualifiedName}` : `id:${owner.symbolId}`;
+      for (const name of memberNamesOf(s)) {
+        const key = `${namespace}\0${name}`;
+        entries.push({ symbol: s, key });
+        if (name === s.shortName) keysWithShortName.add(key);
+      }
+    }
+    const groups = groupKeyedConflicts(entries.filter((e) => keysWithShortName.has(e.key)));
+    return new Map([...groups].map(([key, symbols]) => [key, { name: key.slice(key.indexOf("\0") + 1), symbols }]));
+  }
   function groupConflicts(symbols, keyOf) {
+    return groupKeyedConflicts(symbols.map((symbol) => ({ symbol, key: keyOf(symbol) })));
+  }
+  function groupKeyedConflicts(entries) {
     const byKeyAndKind = /* @__PURE__ */ new Map();
-    for (const s of symbols) {
-      const key = keyOf(s);
+    for (const { symbol: s, key } of entries) {
       let byKind = byKeyAndKind.get(key);
       if (!byKind) {
         byKind = /* @__PURE__ */ new Map();
@@ -136502,7 +136565,13 @@ ${JSON.stringify(message, null, 4)}`);
     for (const s of allSymbols) {
       byId.set(s.symbolId, s);
     }
-    const indexes = { byName, byParent, byQualifiedName, byId, definitionsByName, portsByName };
+    const clashingShortNames = /* @__PURE__ */ new Map();
+    for (const { name, symbols } of findConflictingShortNames(allSymbols).values()) {
+      const clashing = clashingShortNames.get(name) ?? /* @__PURE__ */ new Set();
+      for (const s of symbols) clashing.add(s);
+      clashingShortNames.set(name, clashing);
+    }
+    const indexes = { byName, byParent, byQualifiedName, byId, definitionsByName, portsByName, clashingShortNames };
     for (const s of allSymbols) {
       if (isAnonymous(s)) continue;
       const nameList = byName.get(s.name) ?? [];
@@ -136591,6 +136660,16 @@ ${JSON.stringify(message, null, 4)}`);
     resolveNameIn(namespace, name, indexes) {
       return this.resolveQualifiedNameFrom(namespace ? namespaceKeyOf(namespace) : "", name, indexes);
     }
+    /** Resolve an editor reference without losing the reason a name is unresolved. */
+    resolveReferenceIn(namespace, name, indexes) {
+      return this.resolveQualifiedReferenceFrom(namespace ? namespaceKeyOf(namespace) : "", name, indexes);
+    }
+    /** Resolve a public qualified or feature-path member, without enclosing-scope fallback. */
+    resolveMemberReference(owner, name, indexes) {
+      const members = this.getResolvedMembers(namespaceKeyOf(owner), indexes).get(name);
+      if (members && this.isAmbiguous(name, members, indexes)) return { ambiguous: true };
+      return this.referenceTo(members?.find((member) => member.visibility === "public")?.symbol, indexes);
+    }
     /**
      * Resolve a (possibly qualified) name to its symbol per §7.5.1, searching
      * outward from namespace `start` and its enclosing namespaces (its own resolved
@@ -136602,28 +136681,48 @@ ${JSON.stringify(message, null, 4)}`);
      * its own enclosing package already imported, per §7.5.1/§7.5.3).
      */
     resolveQualifiedNameFrom(start, name, indexes) {
+      return this.resolveQualifiedReferenceFrom(start, name, indexes).symbol;
+    }
+    resolveQualifiedReferenceFrom(start, name, indexes) {
       const [first, ...rest] = splitQualifiedName(name);
       let resolved;
       for (const ancestor of this.namespaceAncestorsOf(start, indexes)) {
         const candidates = this.getResolvedMembers(ancestor, indexes).get(first);
         if (candidates && candidates.length > 0) {
+          if (this.isAmbiguous(first, candidates, indexes)) return { ambiguous: true };
           resolved = candidates[0].symbol;
           break;
         }
       }
-      if (resolved === void 0) return void 0;
+      if (resolved === void 0) return { ambiguous: false };
       const isWithinStart = (namespace) => this.namespaceAncestorsOf(start, indexes).has(namespace);
       for (const segment of rest) {
         const owner = resolved;
         const ownerKey = namespaceKeyOf(owner);
         const members = this.getResolvedMembers(ownerKey, indexes).get(segment);
+        if (members && this.isAmbiguous(segment, members, indexes)) return { ambiguous: true };
         const visibleMember = members?.find(
           (m2) => m2.visibility === "public" || isWithinStart(ownerKey) || m2.visibility === "protected" && this.isProtectedVisibleFrom(start, owner, indexes)
         );
-        if (!visibleMember) return void 0;
+        if (!visibleMember) return { ambiguous: false };
         resolved = visibleMember.symbol;
       }
-      return resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+      return this.referenceTo(resolved, indexes);
+    }
+    referenceTo(resolved, indexes) {
+      if (!resolved) return { ambiguous: false };
+      const symbol = resolved.qualifiedName !== void 0 ? indexes.byQualifiedName.get(resolved.qualifiedName) : resolved;
+      return { symbol, ambiguous: symbol === void 0 };
+    }
+    /**
+     * Whether `name` names more than one of `candidates` that clash on it
+     * through a short name (`SymbolIndexes.clashingShortNames`), so it can't
+     * be resolved to either (KerML 7.2.5.2). Like a conflicted qualifiedName,
+     * it doesn't fall through to an enclosing namespace's member of that name.
+     */
+    isAmbiguous(name, candidates, indexes) {
+      const clashing = indexes.clashingShortNames.get(name);
+      return clashing !== void 0 && candidates.filter((c) => clashing.has(c.symbol)).length > 1;
     }
     /**
      * §7.5.3's protected-import exception: "A visibility of protected is the
@@ -139329,9 +139428,11 @@ ${childIndent}item def ${sourceName};
         if (target && !path.qualifiedNames.some((name) => name.segments.some((segment) => segment.name === target.name || segment.name === target.shortName))) continue;
         const namespace = namespaces.find((ns) => ns.body < path.start && path.end <= ns.end);
         let receiver;
+        let receiverAmbiguous = false;
         for (let group = 0; group < path.qualifiedNames.length; group++) {
           const qualified = path.qualifiedNames[group];
           let resolved;
+          let ambiguous = false;
           for (let index2 = 0; index2 < qualified.segments.length; index2++) {
             const segment = qualified.segments[index2];
             const range = import_node3.Range.create(doc.positionAt(segment.start), doc.positionAt(segment.end));
@@ -139340,17 +139441,27 @@ ${childIndent}item def ${sourceName};
             while (before >= 0 && /\s/.test(text[before])) before--;
             while (after < text.length && /\s/.test(text[after])) after++;
             const declaration = symbols.find((symbol) => !isAnonymous(symbol) && (symbol.selectionRange.start.line === range.start.line && symbol.selectionRange.start.character === range.start.character && symbol.selectionRange.end.character === range.end.character || symbol.shortName === segment.name && text[before] === "<" && text[after] === ">" && doc.offsetAt(symbol.range.start) <= segment.start && segment.end < doc.offsetAt(symbol.selectionRange.start)));
-            if (declaration) resolved = declaration;
-            else if (index2 > 0) {
-              resolved = resolved ? this.resolver.getResolvedMembers(namespaceKeyOf(resolved), this.indexes).get(segment.name)?.find((entry) => entry.visibility === "public")?.symbol : void 0;
+            if (declaration) {
+              resolved = declaration;
+              ambiguous = false;
+            } else if (index2 > 0) {
+              if (resolved) {
+                const result = this.resolver.resolveMemberReference(resolved, segment.name, this.indexes);
+                resolved = result.symbol;
+                ambiguous = result.ambiguous;
+              }
             } else if (group > 0) {
-              resolved = receiver ? this.resolveFeature(receiver, segment.name) : void 0;
+              const result = receiver ? this.resolveFeature(receiver, segment.name) : { ambiguous: receiverAmbiguous };
+              resolved = result.symbol;
+              ambiguous = result.ambiguous;
             } else {
-              resolved = this.resolver.resolveNameIn(
+              const result = this.resolver.resolveReferenceIn(
                 namespace?.symbol,
                 joinQualifiedName([segment.name]),
                 this.indexes
               );
+              resolved = result.symbol;
+              ambiguous = result.ambiguous;
             }
             if (cursor !== void 0 && (cursor < segment.start || cursor > segment.end)) continue;
             if (target && segment.name !== target.name && segment.name !== target.shortName) continue;
@@ -139360,10 +139471,12 @@ ${childIndent}item def ${sourceName};
               name: segment.name,
               qualifiedName: index2 === qualified.segments.length - 1 ? qualified.name : segment.name,
               symbol: resolved,
-              isDeclaration: declaration !== void 0
+              isDeclaration: declaration !== void 0,
+              isAmbiguous: ambiguous
             });
           }
           receiver = resolved;
+          receiverAmbiguous = ambiguous;
         }
       }
       return refs;
@@ -139375,14 +139488,14 @@ ${childIndent}item def ${sourceName};
         const owner = queue[index2];
         if (visited.has(owner)) continue;
         visited.add(owner);
-        const member = this.resolver.getResolvedMembers(namespaceKeyOf(owner), this.indexes).get(name)?.find((entry) => entry.visibility === "public")?.symbol;
-        if (member) return member;
+        const member = this.resolver.resolveMemberReference(owner, name, this.indexes);
+        if (member.symbol || member.ambiguous) return member;
         for (const typeName of owner.typeNames) {
           const type = this.resolver.resolveNameFrom(owner, typeName, this.indexes);
           if (type && !visited.has(type)) queue.push(type);
         }
       }
-      return void 0;
+      return { ambiguous: false };
     }
   };
 
@@ -139399,6 +139512,7 @@ ${childIndent}item def ${sourceName};
       }
       const wsSymbolTable = this.documentManager.getWorkspaceSymbolTable();
       const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+      if (reference?.isAmbiguous) return null;
       if (reference?.symbol && !reference.isDeclaration) {
         return { uri: reference.symbol.uri, range: reference.symbol.selectionRange };
       }
@@ -140013,6 +140127,7 @@ ${childIndent}item def ${sourceName};
       }
       const text = this.documentManager.getText(params.textDocument.uri);
       const reference = new NameReferences(this.documentManager).at(params.textDocument.uri, params.position);
+      if (reference?.isAmbiguous) return null;
       const word = reference?.qualifiedName ?? (text ? this.getWordAtPosition(text, params.position.line, params.position.character) : void 0);
       if (word && word.includes("::") && !reference?.symbol) {
         const libHover = this.buildLibraryHover(word);
@@ -142068,6 +142183,115 @@ ${info.documentation}`);
     }
   };
 
+  // server/src/providers/textValidationProvider.ts
+  var import_node13 = __toESM(require_main3());
+  var DEFAULT_TEXT_VALIDATION_SETTINGS = {
+    enabled: false,
+    maxDocuments: 5,
+    maxLines: 200,
+    maxCharacters: 8192,
+    maxTotalCharacters: 16384
+  };
+  function readTextValidationSettings(section) {
+    const raw = typeof section === "object" && section !== null ? section : {};
+    const limit = (value, fallback) => Number.isSafeInteger(value) && value > 0 ? value : fallback;
+    return {
+      enabled: raw.enabled === true,
+      maxDocuments: limit(raw.maxDocuments, DEFAULT_TEXT_VALIDATION_SETTINGS.maxDocuments),
+      maxLines: limit(raw.maxLines, DEFAULT_TEXT_VALIDATION_SETTINGS.maxLines),
+      maxCharacters: limit(raw.maxCharacters, DEFAULT_TEXT_VALIDATION_SETTINGS.maxCharacters),
+      maxTotalCharacters: limit(raw.maxTotalCharacters, DEFAULT_TEXT_VALIDATION_SETTINGS.maxTotalCharacters)
+    };
+  }
+  var TextValidationProvider = class {
+    /**
+     * `isReported` filters diagnostics as the server does before
+     * publishing them (`sysml.validation.disabledCodes`), so a text gets
+     * exactly what it would get as an open document.
+     */
+    constructor(documentManager2, semanticValidator2, isReported2 = () => true) {
+      this.documentManager = documentManager2;
+      this.semanticValidator = semanticValidator2;
+      this.isReported = isReported2;
+    }
+    documentManager;
+    semanticValidator;
+    isReported;
+    settings = { ...DEFAULT_TEXT_VALIDATION_SETTINGS };
+    /** Applies the client's settings to the requests that follow. */
+    configure(settings) {
+      this.settings = { ...settings };
+    }
+    /**
+     * The diagnostics each text would get as an open document, with all
+     * texts in place at the same time. Answers `MethodNotFound` while
+     * disabled, and `InvalidParams` for malformed parameters or parameters
+     * over a limit.
+     */
+    validate(params) {
+      if (!this.settings.enabled) {
+        throw new import_node13.ResponseError(
+          import_node13.ErrorCodes.MethodNotFound,
+          "sysml/validateText is experimental and disabled: set sysml.experimental.validateText.enabled to true."
+        );
+      }
+      const documents2 = this.checkDocuments(params?.documents);
+      const known = documents2.map((document) => ({ uri: this.knownSpelling(document.uri), text: document.text }));
+      const diagnostics = this.documentManager.withTexts(known, () => known.map(({ uri }) => this.diagnose(uri)));
+      return { documents: documents2.map((document, index2) => ({ uri: document.uri, diagnostics: diagnostics[index2] })) };
+    }
+    /** `documents` checked: a non-empty array of `{ uri, text }` within the limits, each naming a different document. */
+    checkDocuments(documents2) {
+      if (!Array.isArray(documents2) || documents2.length === 0) invalid('"documents" must be a non-empty array of { uri, text }.');
+      const { maxDocuments, maxLines, maxCharacters, maxTotalCharacters } = this.settings;
+      if (documents2.length > maxDocuments) {
+        invalid(`${documents2.length} documents, more than the ${maxDocuments} allowed (sysml.experimental.validateText.maxDocuments).`);
+      }
+      const checked = documents2;
+      let totalCharacters = 0;
+      checked.forEach((document, index2) => {
+        if (typeof document?.text !== "string") invalid(`documents[${index2}] needs "text", the SysML text to validate.`);
+        if (document.text.length > maxCharacters) {
+          invalid(`documents[${index2}] has ${document.text.length} characters, more than the ${maxCharacters} allowed (sysml.experimental.validateText.maxCharacters).`);
+        }
+        totalCharacters += document.text.length;
+        if (totalCharacters > maxTotalCharacters) {
+          invalid(`${totalCharacters} total characters, more than the ${maxTotalCharacters} allowed (sysml.experimental.validateText.maxTotalCharacters).`);
+        }
+        const lines = lineCount(document.text);
+        if (lines > maxLines) {
+          invalid(`documents[${index2}] has ${lines} lines, more than the ${maxLines} allowed (sysml.experimental.validateText.maxLines).`);
+        }
+        if (!isUri(document.uri)) invalid(`documents[${index2}] needs "uri", the document the text is the content of.`);
+        const earlier = checked.findIndex((other) => isSameDocumentUri(other.uri, document.uri));
+        if (earlier !== index2) invalid(`documents[${earlier}] and documents[${index2}] name the same document.`);
+      });
+      return checked;
+    }
+    /** The syntax, keyword and semantic diagnostics of the document at `uri`, as published for an open document. */
+    diagnose(uri) {
+      const diagnostics = new DiagnosticsProvider(this.documentManager).getDiagnostics(uri);
+      const parseResult = this.documentManager.get(uri);
+      if (parseResult) diagnostics.push(...validateKeywords(parseResult));
+      diagnostics.push(...this.semanticValidator.validate(uri));
+      return diagnostics.filter(this.isReported);
+    }
+    /** The spelling under which the server knows the document `uri` names, else `uri` itself (see `isSameDocumentUri`). */
+    knownSpelling(uri) {
+      return this.documentManager.getUris().find((known) => isSameDocumentUri(known, uri)) ?? uri;
+    }
+  };
+  function lineCount(text) {
+    const breaks = text.match(/\r\n|\r|\n/g)?.length ?? 0;
+    return text === "" || /[\r\n]$/.test(text) ? breaks : breaks + 1;
+  }
+  function isUri(value) {
+    return typeof value === "string" && value.trim() !== "";
+  }
+  function invalid(message) {
+    throw new import_node13.ResponseError(import_node13.ErrorCodes.InvalidParams, `sysml/validateText: ${message}`);
+  }
+
   // server/src/platform/shims/fs-promises.ts
   async function readFile(_path, _enc) {
     throw new Error("fs/promises.readFile is not available in the browser");
@@ -142148,7 +142372,7 @@ ${info.documentation}`);
     return void 0;
   }
   var connection = createServerConnection();
-  var documents = new import_node13.TextDocuments(TextDocument2);
+  var documents = new import_node14.TextDocuments(TextDocument2);
   var serverStartTime = Date.now();
   var documentManager = new DocumentManager();
   var modelProvider = new SysMLModelProvider(documentManager);
@@ -142165,6 +142389,7 @@ ${info.documentation}`);
   var codeActionProvider = new CodeActionProvider(documentManager);
   var formattingProvider = new FormattingProvider(documents);
   var semanticValidator = new SemanticValidator(documentManager);
+  var textValidationProvider = new TextValidationProvider(documentManager, semanticValidator, isReported);
   hoverProvider.setSemanticValidator(semanticValidator);
   var hasConfigurationCapability = false;
   var hasWorkspaceFolderCapability = false;
@@ -142176,11 +142401,11 @@ ${info.documentation}`);
   var isWorkspaceFile = false;
   var preloadOnOpen = "workspaceOnly";
   var disabledDiagnosticCodes = /* @__PURE__ */ new Set();
+  function isReported(diagnostic) {
+    return diagnostic.code === void 0 || !disabledDiagnosticCodes.has(String(diagnostic.code));
+  }
   function publishDiagnostics(uri, diagnostics) {
-    connection.sendDiagnostics({
-      uri,
-      diagnostics: diagnostics.filter((diagnostic) => diagnostic.code === void 0 || !disabledDiagnosticCodes.has(String(diagnostic.code)))
-    });
+    connection.sendDiagnostics({ uri, diagnostics: diagnostics.filter(isReported) });
   }
   var skipDirs = new Set(DEFAULT_SKIP_DIRS);
   var serverReady = false;
@@ -142313,7 +142538,7 @@ ${info.documentation}`);
     };
     const result = {
       capabilities: {
-        textDocumentSync: import_node13.TextDocumentSyncKind.Incremental,
+        textDocumentSync: import_node14.TextDocumentSyncKind.Incremental,
         // Completion
         completionProvider: {
           resolveProvider: true,
@@ -142341,7 +142566,7 @@ ${info.documentation}`);
         // Code actions (quick fixes)
         codeActionProvider: {
           codeActionKinds: [
-            import_node13.CodeActionKind.QuickFix
+            import_node14.CodeActionKind.QuickFix
           ]
         },
         // Document formatting
@@ -142362,7 +142587,7 @@ ${info.documentation}`);
   connection.onInitialized(async () => {
     if (hasConfigurationCapability) {
       connection.client.register(
-        import_node13.DidChangeConfigurationNotification.type,
+        import_node14.DidChangeConfigurationNotification.type,
         void 0
       );
     }
@@ -142423,6 +142648,8 @@ ${info.documentation}`);
     const validation = await connection.workspace.getConfiguration("sysml.validation");
     const codes = validation?.disabledCodes;
     disabledDiagnosticCodes = new Set(Array.isArray(codes) ? codes.filter((code) => typeof code === "string") : []);
+    const experimental = await connection.workspace.getConfiguration("sysml.experimental");
+    textValidationProvider.configure(readTextValidationSettings(experimental?.validateText));
   }
   function applySettings(config) {
     if (!config) return;
@@ -142776,6 +143003,10 @@ ${info.documentation}`);
     await initialization;
     return elementLookupProvider.elementLookup(params);
   });
+  connection.onRequest("sysml/validateText", async (params) => {
+    await initialization;
+    return textValidationProvider.validate(params);
+  });
   connection.onRequest("sysml/serverStats", () => {
     const mem = typeof process !== "undefined" && typeof process.memoryUsage === "function" ? process.memoryUsage() : { heapUsed: 0, heapTotal: 0, rss: 0, external: 0 };
     const toMB = (bytes) => Math.round(bytes / 1024 / 1024);