sysml-v2-lsp 0.37.0 → 0.39.0

package/dist/server/server.js

@@ -118,28 +118,28 @@ var require_messages = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Message = exports2.NotificationType9 = exports2.NotificationType8 = exports2.NotificationType7 = exports2.NotificationType6 = exports2.NotificationType5 = exports2.NotificationType4 = exports2.NotificationType3 = exports2.NotificationType2 = exports2.NotificationType1 = exports2.NotificationType0 = exports2.NotificationType = exports2.RequestType9 = exports2.RequestType8 = exports2.RequestType7 = exports2.RequestType6 = exports2.RequestType5 = exports2.RequestType4 = exports2.RequestType3 = exports2.RequestType2 = exports2.RequestType1 = exports2.RequestType = exports2.RequestType0 = exports2.AbstractMessageSignature = exports2.ParameterStructures = exports2.ResponseError = exports2.ErrorCodes = void 0;
     var is = require_is2();
-    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 || (exports2.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 || (exports2.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);
       }
@@ -154,7 +154,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports2.ResponseError = ResponseError2;
+    exports2.ResponseError = ResponseError3;
     var ParameterStructures = class _ParameterStructures {
       constructor(kind) {
         this.kind = kind;
@@ -3552,8 +3552,8 @@ var require_main2 = __commonJS({
         }
         CodeDescription2.is = is;
       })(CodeDescription || (exports3.CodeDescription = CodeDescription = {}));
-      var Diagnostic6;
-      (function(Diagnostic7) {
+      var Diagnostic7;
+      (function(Diagnostic8) {
         function create(range, message, severity, code, source, relatedInformation) {
           var result = { range, message };
           if (Is.defined(severity)) {
@@ -3570,14 +3570,14 @@ var require_main2 = __commonJS({
           }
           return result;
         }
-        Diagnostic7.create = create;
+        Diagnostic8.create = create;
         function is(value) {
           var _a;
           var candidate = value;
           return Is.defined(candidate) && Range6.is(candidate.range) && Is.string(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));
         }
-        Diagnostic7.is = is;
-      })(Diagnostic6 || (exports3.Diagnostic = Diagnostic6 = {}));
+        Diagnostic8.is = is;
+      })(Diagnostic7 || (exports3.Diagnostic = Diagnostic7 = {}));
       var Command;
       (function(Command2) {
         function create(title, command) {
@@ -4362,7 +4362,7 @@ var require_main2 = __commonJS({
         CodeActionContext2.create = create;
         function is(value) {
           var candidate = value;
-          return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic6.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
+          return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic7.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
         }
         CodeActionContext2.is = is;
       })(CodeActionContext || (exports3.CodeActionContext = CodeActionContext = {}));
@@ -4387,7 +4387,7 @@ var require_main2 = __commonJS({
         CodeAction3.create = create;
         function is(value) {
           var candidate = value;
-          return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic6.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit4.is(candidate.edit));
+          return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic7.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit4.is(candidate.edit));
         }
         CodeAction3.is = is;
       })(CodeAction2 || (exports3.CodeAction = CodeAction2 = {}));
@@ -8880,7 +8880,7 @@ var require_node3 = __commonJS({
 });
 
 // server/src/server.ts
-var import_node14 = __toESM(require_node3());
+var import_node15 = __toESM(require_node3());
 var fs = __toESM(require("node:fs"));
 var path2 = __toESM(require("node:path"));
 var import_node_url2 = require("node:url");
@@ -124358,6 +124358,13 @@ var DocumentManager = class {
    * 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.
@@ -124561,6 +124568,35 @@ var DocumentManager = class {
     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.
    */
@@ -125382,12 +125418,19 @@ var MAX_NAMESPACE_NESTING_DEPTH = 64;
 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) {
@@ -125395,13 +125438,33 @@ function findConflictingDeclarations(allSymbols) {
     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();
@@ -125473,7 +125536,13 @@ function buildSymbolIndexes(allSymbols) {
   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) ?? [];
@@ -125562,6 +125631,16 @@ var NamespaceResolver = class {
   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
@@ -125573,28 +125652,48 @@ var NamespaceResolver = class {
    * 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
@@ -128297,9 +128396,11 @@ var NameReferences = class {
       if (target && !path3.qualifiedNames.some((name) => name.segments.some((segment) => segment.name === target.name || segment.name === target.shortName))) continue;
       const namespace = namespaces.find((ns) => ns.body < path3.start && path3.end <= ns.end);
       let receiver;
+      let receiverAmbiguous = false;
       for (let group = 0; group < path3.qualifiedNames.length; group++) {
         const qualified = path3.qualifiedNames[group];
         let resolved;
+        let ambiguous = false;
         for (let index2 = 0; index2 < qualified.segments.length; index2++) {
           const segment = qualified.segments[index2];
           const range = import_node4.Range.create(doc.positionAt(segment.start), doc.positionAt(segment.end));
@@ -128308,17 +128409,27 @@ var NameReferences = class {
           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;
@@ -128328,10 +128439,12 @@ var NameReferences = class {
             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;
@@ -128343,14 +128456,14 @@ var NameReferences = class {
       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 };
   }
 };
 
@@ -128367,6 +128480,7 @@ var DefinitionProvider = class {
     }
     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 };
     }
@@ -128981,6 +129095,7 @@ var HoverProvider = class {
     }
     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);
@@ -131036,6 +131151,115 @@ var SemanticValidator = class _SemanticValidator {
   }
 };
 
+// server/src/providers/textValidationProvider.ts
+var import_node14 = __toESM(require_node3());
+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_node14.ResponseError(
+        import_node14.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_node14.ResponseError(import_node14.ErrorCodes.InvalidParams, `sysml/validateText: ${message}`);
+}
+
 // server/src/utils/fileDiscovery.ts
 var fsp = __toESM(require("node:fs/promises"));
 var path = __toESM(require("node:path"));
@@ -131110,7 +131334,7 @@ function toFsPath(uri) {
   return void 0;
 }
 var connection = createServerConnection();
-var documents = new import_node14.TextDocuments(TextDocument);
+var documents = new import_node15.TextDocuments(TextDocument);
 var serverStartTime = Date.now();
 var documentManager = new DocumentManager();
 var modelProvider = new SysMLModelProvider(documentManager);
@@ -131127,6 +131351,7 @@ var renameProvider = new RenameProvider(documentManager);
 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;
@@ -131138,11 +131363,11 @@ function rootsOf(folderUris) {
 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;
@@ -131275,7 +131500,7 @@ connection.onInitialize((params) => {
   };
   const result = {
     capabilities: {
-      textDocumentSync: import_node14.TextDocumentSyncKind.Incremental,
+      textDocumentSync: import_node15.TextDocumentSyncKind.Incremental,
       // Completion
       completionProvider: {
         resolveProvider: true,
@@ -131303,7 +131528,7 @@ connection.onInitialize((params) => {
       // Code actions (quick fixes)
       codeActionProvider: {
         codeActionKinds: [
-          import_node14.CodeActionKind.QuickFix
+          import_node15.CodeActionKind.QuickFix
         ]
       },
       // Document formatting
@@ -131324,7 +131549,7 @@ connection.onInitialize((params) => {
 connection.onInitialized(async () => {
   if (hasConfigurationCapability) {
     connection.client.register(
-      import_node14.DidChangeConfigurationNotification.type,
+      import_node15.DidChangeConfigurationNotification.type,
       void 0
     );
   }
@@ -131385,6 +131610,8 @@ async function pullSettings() {
   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;
@@ -131738,6 +131965,10 @@ connection.onRequest("sysml/elementLookup", async (params) => {
   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);

package/package.json

@@ -2,7 +2,7 @@
   "name": "sysml-v2-lsp",
   "displayName": "SysML v2 Language Server",
   "description": "Language Server Protocol implementation for SysML v2, powered by ANTLR4",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "publisher": "JamieD",
   "license": "MIT",
   "repository": {
@@ -96,6 +96,40 @@
           "default": [],
           "description": "Diagnostic codes to suppress, such as missing-doc. Changes apply to open documents immediately."
         },
+        "sysml.experimental.validateText.enabled": {
+          "scope": "window",
+          "type": "boolean",
+          "default": false,
+          "markdownDescription": "Experimental: answer the custom `sysml/validateText` request, which validates SysML text against the workspace model without opening a document or publishing diagnostics. The request is meant for tools that generate or edit SysML text."
+        },
+        "sysml.experimental.validateText.maxDocuments": {
+          "scope": "window",
+          "type": "integer",
+          "minimum": 1,
+          "default": 5,
+          "markdownDescription": "Experimental: the most documents one `sysml/validateText` request may validate. Requests with more are rejected."
+        },
+        "sysml.experimental.validateText.maxLines": {
+          "scope": "window",
+          "type": "integer",
+          "minimum": 1,
+          "default": 200,
+          "markdownDescription": "Experimental: the most lines of code one document's text may have in a `sysml/validateText` request. Requests with a longer text are rejected. Character limits also apply."
+        },
+        "sysml.experimental.validateText.maxCharacters": {
+          "scope": "window",
+          "type": "integer",
+          "minimum": 1,
+          "default": 8192,
+          "markdownDescription": "Experimental: the most characters (UTF-16 code units) per document in a `sysml/validateText` request. Checked before parsing, including for single-line text."
+        },
+        "sysml.experimental.validateText.maxTotalCharacters": {
+          "scope": "window",
+          "type": "integer",
+          "minimum": 1,
+          "default": 16384,
+          "markdownDescription": "Experimental: the most characters (UTF-16 code units) across all documents in a `sysml/validateText` request. Checked before parsing."
+        },
         "sysml.maxNumberOfProblems": {
           "scope": "resource",
           "type": "number",