sysml-validate 0.10.18 → 0.14.2

package/out/main.js

@@ -57907,9 +57907,53 @@ function asDiagnosticLevel(value, fallback = "off") {
 }
 
 // ../language-server/out/src/services/import-visibility.js
+var GlobalDescriptionIndex = class _GlobalDescriptionIndex {
+  /** Reuse an existing index; wrap a plain list. */
+  static from(source) {
+    return source instanceof _GlobalDescriptionIndex ? source : new _GlobalDescriptionIndex(source);
+  }
+  /** Exact name → descriptions carrying it (qualified and simple names alike). */
+  byName = /* @__PURE__ */ new Map();
+  /** Namespace path → descriptions for its DIRECT members (`A::B` → `A::B::C`). */
+  directMembers = /* @__PURE__ */ new Map();
+  /** Namespace path → descriptions for all its descendants (`A` → `A::B::C`). */
+  nestedMembers = /* @__PURE__ */ new Map();
+  constructor(descriptions) {
+    for (const desc of descriptions) {
+      push(this.byName, desc.name, desc);
+      let sep2 = desc.name.indexOf("::");
+      while (sep2 >= 0) {
+        const prefix = desc.name.slice(0, sep2);
+        push(this.nestedMembers, prefix, desc);
+        const next = desc.name.indexOf("::", sep2 + 2);
+        if (next < 0)
+          push(this.directMembers, prefix, desc);
+        sep2 = next;
+      }
+    }
+  }
+  named(name) {
+    return this.byName.get(name) ?? EMPTY_DESCRIPTIONS;
+  }
+  firstNamed(name) {
+    return this.byName.get(name)?.[0];
+  }
+  membersOf(path10, wildcard) {
+    const map3 = wildcard === "shallow" ? this.directMembers : this.nestedMembers;
+    return map3.get(path10) ?? EMPTY_DESCRIPTIONS;
+  }
+};
+var EMPTY_DESCRIPTIONS = [];
+function push(map3, key, desc) {
+  const list = map3.get(key);
+  if (list)
+    list.push(desc);
+  else
+    map3.set(key, [desc]);
+}
 function expandImportEntries(imp, globalDescriptions, options = {}) {
   const out = [];
-  expandImportInto(imp, globalDescriptions, out, options, /* @__PURE__ */ new Set());
+  expandImportInto(imp, GlobalDescriptionIndex.from(globalDescriptions), out, options, /* @__PURE__ */ new Set());
   return dedupeEntries(out);
 }
 function importedPath(imp) {
@@ -57934,12 +57978,13 @@ function importVisibility(imp) {
   return imp.visibility ?? "private";
 }
 function resolveDescription(name, globalDescriptions) {
+  const index = GlobalDescriptionIndex.from(globalDescriptions);
   const normalized = name.trim();
-  const direct = globalDescriptions.find((desc) => desc.name === normalized);
+  const direct = index.firstNamed(normalized);
   if (direct)
     return direct;
   const simple = normalized.split(/::|\./).pop();
-  return simple ? globalDescriptions.find((desc) => desc.name === simple) : void 0;
+  return simple ? index.firstNamed(simple) : void 0;
 }
 function descriptionKey(description) {
   return `${description.documentUri.toString()}#${description.path}`;
@@ -58064,7 +58109,7 @@ function qualifiedNameMatches(a2, b) {
   return true;
 }
 function resolveImportedDescription(path10, globalDescriptions, options, visitedNamespaces) {
-  const direct = globalDescriptions.find((desc) => desc.name === path10);
+  const direct = globalDescriptions.firstNamed(path10);
   if (direct)
     return direct;
   const split = path10.lastIndexOf("::");
@@ -58077,23 +58122,17 @@ function resolveImportedDescription(path10, globalDescriptions, options, visited
   return exported.find((entry) => entry.name === simpleName2)?.description;
 }
 function expandNamespaceMembers(path10, wildcard, globalDescriptions, out) {
-  const prefix = path10 + "::";
-  for (const desc of globalDescriptions) {
-    if (!desc.name.startsWith(prefix))
-      continue;
+  const prefixLength = path10.length + 2;
+  for (const desc of globalDescriptions.membersOf(path10, wildcard)) {
     if (isPrivateDescription(desc))
       continue;
-    const rest = desc.name.slice(prefix.length);
-    if (wildcard === "shallow" && rest.includes("::"))
-      continue;
+    const rest = desc.name.slice(prefixLength);
     const simple = rest.includes("::") ? rest.slice(rest.lastIndexOf("::") + 2) : rest;
     out.push({ name: simple, targetName: desc.name, description: desc });
   }
 }
 function expandNamespaceImports(path10, globalDescriptions, out, options, visitedNamespaces) {
-  for (const namespaceDesc of globalDescriptions) {
-    if (namespaceDesc.name !== path10)
-      continue;
+  for (const namespaceDesc of globalDescriptions.named(path10)) {
     const key = descriptionKey(namespaceDesc);
     if (visitedNamespaces.has(key))
       continue;
@@ -58269,7 +58308,7 @@ function splitUnitFactors(symbol) {
   let start = 0;
   let quote = false;
   let nextOp = "*";
-  const push = (end) => {
+  const push2 = (end) => {
     const text = symbol.slice(start, end).trim();
     if (!text)
       return false;
@@ -58289,13 +58328,13 @@ function splitUnitFactors(symbol) {
       continue;
     }
     if (ch === "*" || ch === "/" || ch === "\u22C5") {
-      if (!push(i))
+      if (!push2(i))
         return void 0;
       nextOp = ch === "/" ? "/" : "*";
       start = i + 1;
     }
   }
-  if (quote || !push(symbol.length))
+  if (quote || !push2(symbol.length))
     return void 0;
   return tokens;
 }
@@ -58651,6 +58690,8 @@ function nearestUnits(symbol, limit) {
 
 // ../language-server/out/src/messages.js
 var DIAGNOSTIC_MESSAGES = {
+  // REQ-317 — expression paths diagnose the exact missing feature segment.
+  RES001_FEATURE_PATH_SEGMENT: (segment, owner) => `Feature path segment '${segment}' does not exist on '${owner}'.`,
   LEX001_UNTERMINATED_STRING: `Unterminated string literal \u2014 missing closing '"'.`,
   LEX002_UNTERMINATED_BLOCK_COMMENT: "Unterminated block comment - '/*' is never closed with '*/'.",
   LEX003_UNTERMINATED_UNRESTRICTED_NAME: `Unterminated unrestricted name \u2014 missing closing "'".`,
@@ -58969,6 +59010,352 @@ function isLibraryDocument(doc) {
   return doc.isLibraryDocument === true || isStandardLibraryUri(doc.uri);
 }
 
+// ../language-server/out/src/services/escaped-name.js
+function decodeEscapes(body) {
+  return body.replace(/\\(.)/gu, (_m, ch) => {
+    switch (ch) {
+      case "n":
+        return "\n";
+      case "t":
+        return "	";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      default:
+        return ch;
+    }
+  });
+}
+function canonicalEscapedName(token) {
+  if (token.length < 2 || !token.startsWith("'") || !token.endsWith("'"))
+    return token;
+  return "'" + decodeEscapes(token.slice(1, -1)) + "'";
+}
+function decodeUnrestrictedName(token) {
+  if (token.length >= 2 && token.startsWith("'") && token.endsWith("'")) {
+    return decodeEscapes(token.slice(1, -1));
+  }
+  return token;
+}
+var BARE_ID = /^[_a-zA-Z]\w*$/u;
+function encodeUnrestrictedName(value) {
+  const raw = value.length >= 2 && value.startsWith("'") && value.endsWith("'") ? decodeUnrestrictedName(value) : value;
+  if (BARE_ID.test(raw))
+    return raw;
+  const escaped = raw.replace(/\r\n?/gu, "\n").replace(/[\\']/gu, (ch) => `\\${ch}`).replace(/\n/gu, "\\n").replace(/\t/gu, "\\t").replace(/[\f]/gu, "\\f").replace(/[\b]/gu, "\\b");
+  return `'${escaped}'`;
+}
+
+// ../language-server/out/src/services/feature-path-resolver.js
+var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+function nameOf(node) {
+  const name = node?.name;
+  if (typeof name === "string" && name.length > 0)
+    return name;
+  if (node?.$type === "FeatureRedefinitionShorthand") {
+    const leading = node.preRelationships?.[0]?.targets?.[0];
+    return leading ? lastSegment2(leading) : void 0;
+  }
+  if (node?.$type === "FeatureShorthand") {
+    const text = node.$cstNode?.text;
+    const head2 = text?.split(/(?=\s(?::|:>|:>>|=|\[|\{|;))/u, 1)[0]?.trim();
+    const tokens = head2?.match(/'(?:\\.|[^'])*'|[\p{L}_][\p{L}\p{N}_]*/gu);
+    if (tokens && tokens.length > 1)
+      return canonicalEscapedName(tokens.at(-1));
+  }
+  if (node?.$container?.$type === "EnumDecl") {
+    const literal = node.$cstNode?.text.trim().replace(/;$/u, "").trim();
+    if (literal && !/[\s{}[\]=:]/u.test(literal))
+      return canonicalEscapedName(literal);
+  }
+  return void 0;
+}
+function unwrap(node) {
+  if (node.$type !== "PrefixMetadataMember")
+    return node;
+  return node.element ?? node;
+}
+function directNamedChildren(node) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of ast_utils_exports.streamContents(node)) {
+    const child = unwrap(raw);
+    if (!nameOf(child) || seen.has(child))
+      continue;
+    seen.add(child);
+    result.push(child);
+  }
+  return result;
+}
+function isAncestor(candidate, node) {
+  if (!candidate)
+    return false;
+  for (let current2 = node; current2; current2 = current2.$container) {
+    if (current2 === candidate)
+      return true;
+  }
+  return false;
+}
+function lastSegment2(path10) {
+  return path10.split(/::|\./u).pop() ?? path10;
+}
+var FeaturePathResolver = class {
+  indexManager;
+  descriptions;
+  documents;
+  locator;
+  snapshots = /* @__PURE__ */ new WeakMap();
+  constructor(services) {
+    this.indexManager = services?.shared.workspace.IndexManager;
+    this.descriptions = services?.workspace.AstNodeDescriptionProvider;
+    this.documents = services?.shared.workspace.LangiumDocuments;
+    this.locator = services?.workspace.AstNodeLocator;
+    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.snapshots = /* @__PURE__ */ new WeakMap();
+    });
+  }
+  // REQ-220/317 — resolve every independently clickable/diagnosable segment.
+  resolve(node) {
+    const segments = this.segmentsOf(node);
+    if (segments.length === 0)
+      return { segments };
+    const root3 = ast_utils_exports.getDocument(node).parseResult.value;
+    const snapshot = this.snapshot(root3);
+    let current2 = this.resolveRoot(node, segments[0].text, snapshot);
+    this.applyTarget(segments[0], current2);
+    if (!current2.node && !current2.description) {
+      return { segments, indeterminateIndex: 0 };
+    }
+    for (let index = 1; index < segments.length; index += 1) {
+      const segment = segments[index];
+      const next = this.resolveChild(current2, segment.text, segments, index, snapshot);
+      this.applyTarget(segment, next);
+      if (!next.node && !next.description) {
+        if (!current2.node && current2.description || !current2.certain) {
+          return { segments, indeterminateIndex: index };
+        }
+        return { segments, unresolvedIndex: index };
+      }
+      current2 = next;
+    }
+    return { segments };
+  }
+  isPathExpr(node) {
+    return isPathExpr(node);
+  }
+  segmentsOf(node) {
+    const cst = node.$cstNode;
+    if (!cst)
+      return [];
+    const segments = [];
+    let separator;
+    for (const leaf of cst_utils_exports.flattenCst(cst)) {
+      if (leaf.text === "$")
+        continue;
+      if (leaf.text === "." || leaf.text === "::") {
+        separator = leaf.text;
+        continue;
+      }
+      segments.push({
+        text: canonicalEscapedName(leaf.text),
+        separator: segments.length === 0 ? void 0 : separator,
+        cst: leaf
+      });
+      separator = void 0;
+    }
+    return segments;
+  }
+  resolveRoot(node, name, snapshot) {
+    if (name === "self" || name === "this" || name === "that") {
+      for (let owner = node.$container; owner; owner = owner.$container) {
+        if (nameOf(owner)) {
+          return this.targetForNode(owner, this.memberInventoryKnown(owner, snapshot));
+        }
+      }
+    }
+    for (let owner = node.$container; owner; owner = owner.$container) {
+      const local = directNamedChildren(owner).find((candidate) => nameOf(candidate) === name && !isAncestor(candidate, node));
+      if (local)
+        return this.targetForNode(local, this.memberInventoryKnown(local, snapshot));
+    }
+    return this.targetFromDescriptions(snapshot.byName.get(name), node);
+  }
+  resolveChild(current2, name, segments, index, snapshot) {
+    const owner = this.followAlias(current2, snapshot);
+    if (owner.node) {
+      const direct = directNamedChildren(owner.node).find((candidate) => nameOf(candidate) === name);
+      if (direct) {
+        return this.targetForNode(direct, current2.certain === true && this.memberInventoryKnown(direct, snapshot));
+      }
+      for (const inheritedOwner of this.typedAndSpecializedOwners(owner.node, snapshot)) {
+        const inherited = directNamedChildren(inheritedOwner).find((candidate) => nameOf(candidate) === name);
+        if (inherited) {
+          return this.targetForNode(inherited, current2.certain === true && this.memberInventoryKnown(inherited, snapshot));
+        }
+      }
+    }
+    if (segments.slice(1, index + 1).every((segment) => segment.separator === "::")) {
+      const exact = segments.slice(0, index + 1).map((segment) => segment.text).join("::");
+      const indexed = this.targetFromDescriptions(snapshot.byName.get(exact));
+      if (indexed.node || indexed.description)
+        return indexed;
+    }
+    return {};
+  }
+  typedAndSpecializedOwners(node, snapshot) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (candidate) => {
+      if (!candidate || seen.has(candidate))
+        return;
+      seen.add(candidate);
+      result.push(candidate);
+      visit(this.typingTarget(candidate, snapshot));
+      for (const specialized of this.specializationTargets(candidate, snapshot))
+        visit(specialized);
+    };
+    visit(this.typingTarget(node, snapshot));
+    for (const specialized of this.specializationTargets(node, snapshot))
+      visit(specialized);
+    return result;
+  }
+  typingTarget(node, snapshot) {
+    const typing = node.typing?.type;
+    let typed;
+    try {
+      typed = typing?.ref;
+    } catch {
+      typed = void 0;
+    }
+    if (!typed && typing?.$refText) {
+      typed = this.nodeOf(this.pickDescription(snapshot.byName.get(typing.$refText))) ?? this.nodeOf(this.pickDescription(snapshot.byName.get(lastSegment2(typing.$refText))));
+    }
+    return typed;
+  }
+  specializationTargets(node, snapshot) {
+    const relNode = node;
+    const result = [];
+    for (const relation of [...relNode.preRelationships ?? [], ...relNode.relationships ?? []]) {
+      if (!relation.kind || !SPECIALIZATION_KINDS.has(relation.kind))
+        continue;
+      for (const target of relation.targets ?? []) {
+        const description = this.pickDescription(snapshot.byName.get(target)) ?? this.pickDescription(snapshot.byName.get(lastSegment2(target)));
+        const resolved = this.nodeOf(description);
+        if (resolved)
+          result.push(resolved);
+      }
+    }
+    return result;
+  }
+  memberInventoryKnown(node, snapshot) {
+    const record = node;
+    if (record.isDef === true || node.$type === "ClassDecl" || node.$type === "StructDecl" || node.$type === "EnumDecl" || node.$type === "DatatypeDecl" || node.$type === "FunctionDecl" || node.$type === "PredicateDecl") {
+      return true;
+    }
+    const typed = this.typingTarget(node, snapshot);
+    if (typed) {
+      const localUri = ast_utils_exports.getDocument(node).uri.toString();
+      const typedUri = ast_utils_exports.getDocument(typed).uri.toString();
+      if (localUri === typedUri)
+        return true;
+      const refText = record.typing?.type?.$refText;
+      const candidates = refText ? snapshot.byName.get(refText) ?? snapshot.byName.get(lastSegment2(refText)) : void 0;
+      return candidates?.length === 1;
+    }
+    const semanticRelationships = [...record.preRelationships ?? [], ...record.relationships ?? []].filter((relation) => relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+    return semanticRelationships.length > 0 && semanticRelationships.every((relation) => (relation.targets ?? []).every((target) => Boolean(this.nodeOf(this.pickDescription(snapshot.byName.get(target))) ?? this.nodeOf(this.pickDescription(snapshot.byName.get(lastSegment2(target)))))));
+  }
+  followAlias(target, snapshot) {
+    const node = target.node;
+    if (node?.$type !== "AliasDecl")
+      return target;
+    const aliasTarget = node.target;
+    if (!aliasTarget)
+      return target;
+    const exact = this.targetFromDescriptions(snapshot.byName.get(aliasTarget));
+    if (exact.node || exact.description)
+      return exact;
+    const simple = this.targetFromDescriptions(snapshot.byName.get(lastSegment2(aliasTarget)));
+    return simple.node || simple.description ? simple : target;
+  }
+  targetForNode(node, certain = false) {
+    const name = nameOf(node);
+    let description;
+    if (name && this.descriptions) {
+      try {
+        description = this.descriptions.createDescription(node, name);
+      } catch {
+        description = void 0;
+      }
+    }
+    return { node, description, certain };
+  }
+  targetFromDescriptions(descriptions, context) {
+    const description = this.pickDescription(descriptions, context);
+    return description ? { description, node: this.nodeOf(description) } : {};
+  }
+  pickDescription(descriptions, context) {
+    if (!descriptions?.length)
+      return void 0;
+    if (context) {
+      const uri = ast_utils_exports.getDocument(context).uri.toString();
+      const local = descriptions.find((description) => description.documentUri.toString() === uri && !isAncestor(description.node, context));
+      if (local)
+        return local;
+    }
+    return descriptions.find((description) => !context || !isAncestor(description.node, context));
+  }
+  nodeOf(description) {
+    if (!description)
+      return void 0;
+    if (description.node)
+      return description.node;
+    const root3 = this.documents?.getDocument(description.documentUri)?.parseResult.value;
+    return root3 && this.locator ? this.locator.getAstNode(root3, description.path) : void 0;
+  }
+  applyTarget(segment, target) {
+    segment.target = target.node;
+    segment.description = target.description;
+  }
+  snapshot(root3) {
+    const cached = this.snapshots.get(root3);
+    if (cached)
+      return cached;
+    const byName = /* @__PURE__ */ new Map();
+    if (this.indexManager) {
+      for (const description of this.indexManager.allElements()) {
+        const values2 = byName.get(description.name) ?? [];
+        values2.push(description);
+        byName.set(description.name, values2);
+      }
+    } else {
+      for (const node of [root3, ...ast_utils_exports.streamAllContents(root3)]) {
+        const name = nameOf(node);
+        if (!name)
+          continue;
+        const values2 = byName.get(name) ?? [];
+        const target = this.targetForNode(node);
+        if (target.description)
+          values2.push(target.description);
+        else {
+          values2.push({
+            name,
+            type: node.$type,
+            documentUri: ast_utils_exports.getDocument(node).uri,
+            path: "",
+            node
+          });
+        }
+        byName.set(name, values2);
+      }
+    }
+    const snapshot = { byName };
+    this.snapshots.set(root3, snapshot);
+    return snapshot;
+  }
+};
+
 // ../language-server/out/src/services/validator.js
 var severityOverrides = {};
 function setSeverityOverrides(overrides) {
@@ -59038,7 +59425,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -59065,10 +59452,12 @@ var SysmlValidator = class _SysmlValidator {
   indexManager;
   langiumDocuments;
   astNodeLocator;
+  featurePaths;
   constructor(services) {
     this.indexManager = services.shared.workspace.IndexManager;
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
+    this.featurePaths = new FeaturePathResolver(services);
   }
   // ══════════════════════════════════════════════════════════════════════
   // STYL — naming conventions (REQ-169, REQ-332)
@@ -59076,6 +59465,28 @@ var SysmlValidator = class _SysmlValidator {
   // REQ-330 — SSM014 support: message-endpoint root features per interaction,
   // computed once per interaction AST node instead of once per participant.
   interactionMessageRoots = /* @__PURE__ */ new WeakMap();
+  // REQ-317 — PathExpr is stored as one datatype string, so the ordinary
+  // Langium linker cannot diagnose a missing intermediate feature. Resolve the
+  // chain here and underline only the first invalid segment.
+  checkPathExpr(node, accept) {
+    let declaration = node.$container;
+    while (declaration && !isPartDecl(declaration))
+      declaration = declaration.$container;
+    const modifiers2 = declaration?.modifiers ?? [];
+    if (!declaration || !modifiers2.includes("ref"))
+      return;
+    const resolution = this.featurePaths.resolve(node);
+    if (resolution.unresolvedIndex === void 0)
+      return;
+    const invalid = resolution.segments[resolution.unresolvedIndex];
+    const owner = resolution.unresolvedIndex > 0 ? resolution.segments[resolution.unresolvedIndex - 1].text : "the current scope";
+    accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, owner), {
+      node,
+      range: invalid.cst.range,
+      code: "RES001",
+      data: { featurePathSegment: true }
+    });
+  }
   // REQ-169, REQ-329 — SSM001 def/usage mismatch for parts
   checkPartDecl(node, accept) {
     if (!node.isDef && node.name && /^[A-Z]/.test(node.name)) {
@@ -60843,6 +61254,7 @@ ${baseIndent}}`;
     return {
       Document: this.checkDocument.bind(this),
       PartDecl: this.checkPartDecl.bind(this),
+      PathExpr: this.checkPathExpr.bind(this),
       RequirementDecl: this.checkRequirementDecl.bind(this),
       AttributeDecl: this.checkAttributeDecl.bind(this),
       ConstraintDecl: this.checkConstraintDecl.bind(this),
@@ -61063,7 +61475,7 @@ function specializationTargets(node) {
     ...node.relationships ?? []
   ];
   for (const rel of rels) {
-    if (rel.kind && SPECIALIZATION_KINDS.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS2.has(rel.kind))
       out.push(...rel.targets);
   }
   return out;
@@ -61303,8 +61715,17 @@ function isWithinNamespaceOf(inner, target) {
   }
   return false;
 }
+var globalIndexes = /* @__PURE__ */ new WeakMap();
+function globalIndexFor(index) {
+  let globalIndex = globalIndexes.get(index);
+  if (!globalIndex) {
+    globalIndex = new GlobalDescriptionIndex(Array.from(index.values()).flat());
+    globalIndexes.set(index, globalIndex);
+  }
+  return globalIndex;
+}
 function introducedNames(imp, index, nodeOf) {
-  const globalDescs = Array.from(index.values()).flat();
+  const globalDescs = globalIndexFor(index);
   const protectedNamespaceKeys = protectedNamespaceKeysFor(imp.$container, globalDescs, nodeOf);
   return expandImportEntries(imp, globalDescs, {
     nodeOf,
@@ -61937,7 +62358,7 @@ function trailingBlockBody(node) {
 }
 
 // ../language-server/out/src/services/document-symbol-provider.js
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", "specializes"]);
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
@@ -62006,7 +62427,7 @@ function specializationTargets2(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS2.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS3.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -63841,12 +64262,17 @@ var SNIPPETS = [
 ];
 var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   indexManager;
+  // REQ-245, REQ-268 — Qualified names of every indexed element, keyed by the
+  // element it names. Built once per workspace build and evicted with the rest
+  // of the workspace caches; see [[qualifiedNamesByElement]].
+  qualifiedNameCache;
   completionOptions = {
     triggerCharacters: COMPLETION_TRIGGER_CHARACTERS
   };
   constructor(services) {
     super(services);
     this.indexManager = services.shared.workspace.IndexManager;
+    this.qualifiedNameCache = new WorkspaceCache(services.shared);
   }
   async getCompletion(document, params) {
     const defaultResult = await super.getCompletion(document, params);
@@ -64010,8 +64436,34 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   qualifiedNameFor(desc) {
     if (desc.name.includes("::"))
       return desc.name;
-    const candidates = this.indexManager.allElements().toArray().filter((other) => other.documentUri.toString() === desc.documentUri.toString()).filter((other) => other.path === desc.path && other.type === desc.type).map((other) => other.name).filter((name) => name.includes("::") && simpleName(name) === desc.name).sort((a2, b) => a2.length - b.length || a2.localeCompare(b));
-    return candidates[0];
+    const candidates = this.qualifiedNamesByElement().get(elementKey(desc));
+    return candidates?.find((name) => simpleName(name) === desc.name);
+  }
+  // REQ-245, REQ-268 — An element's qualified names, shortest first, keyed by
+  // the element. A type-context completion offers thousands of symbols and each
+  // one needs its qualified name to plan an auto-import; looking that up by
+  // scanning the whole index per candidate made the index-sized scan happen
+  // thousands of times, and a single `: ` keystroke blocked the server for
+  // 10 s — long enough for the editor to report the request as timed out. One
+  // grouped pass per build answers all of them.
+  qualifiedNamesByElement() {
+    return this.qualifiedNameCache.get("all", () => {
+      const byElement = /* @__PURE__ */ new Map();
+      for (const desc of this.indexManager.allElements()) {
+        if (!desc.name.includes("::"))
+          continue;
+        const key = elementKey(desc);
+        const names = byElement.get(key);
+        if (names)
+          names.push(desc.name);
+        else
+          byElement.set(key, [desc.name]);
+      }
+      for (const names of byElement.values()) {
+        names.sort((a2, b) => a2.length - b.length || a2.localeCompare(b));
+      }
+      return byElement;
+    });
   }
   importPathItems(importPrefix) {
     const prefix = importPrefix.trim();
@@ -64215,6 +64667,9 @@ function isPackageBody(prefix) {
     return true;
   return /\bpackage\s+(?:<[^>]+>\s*)?[\p{L}_'][^;{}]*$/u.test(prefix.slice(Math.max(0, open - 160), open));
 }
+function elementKey(desc) {
+  return `${desc.documentUri.toString()}#${desc.path}#${desc.type}`;
+}
 function isDefinitionDescription(desc) {
   const node = desc.node;
   return node?.isDef === void 0 || node.isDef === true;
@@ -64567,11 +65022,16 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
   // global symbol table, which made indexing the standard library O(refs ×
   // symbols) — minutes of unusable startup. See REQ-073/REQ-220.
   importCache;
+  // REQ-268 — The global symbol table, indexed by name and by namespace prefix.
+  // Built once per reference type per build and evicted with the same
+  // `DocumentBuilder` update that evicts Langium's own global-scope cache.
+  globalIndexCache;
   langiumDocuments;
   astNodeLocator;
   constructor(services) {
     super(services);
     this.importCache = new DocumentCache(services.shared);
+    this.globalIndexCache = new WorkspaceCache(services.shared);
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
     this.astNodeLocator = services.workspace.AstNodeLocator;
   }
@@ -64591,8 +65051,9 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
     const refType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(refType, context);
     const doc = ast_utils_exports.getDocument(context.container);
-    const contextKey = this.importContextKey(context.container);
-    const imported = this.importCache.get(doc.uri, `${refType}|${contextKey}`, () => this.computeImportedDescriptions(doc, refType, context.container));
+    const protectedNamespaces = this.protectedNamespacesFor(context.container, this.globalIndex(refType));
+    const contextKey = this.importContextKey(context.container, protectedNamespaces);
+    const imported = this.importCache.get(doc.uri, `${refType} ${contextKey}`, () => this.computeImportedDescriptions(doc, refType, context.container, protectedNamespaces));
     let scope = imported.length > 0 ? this.createScope(imported, globalScope) : globalScope;
     const localLayers = this.localScopeLayers(context.container, refType);
     for (let i = localLayers.length - 1; i >= 0; i--) {
@@ -64624,12 +65085,11 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
   // REQ-067, REQ-069 — Collect import- and alias-visible descriptions for a
   // document. Computed once per (document, reference type) and cached; the
   // global element list is scanned a single time here rather than per reference.
-  computeImportedDescriptions(doc, refType, contextNode) {
+  computeImportedDescriptions(doc, refType, contextNode, protectedNamespaces) {
     const root3 = doc.parseResult?.value;
     if (!root3 || !isDocument(root3))
       return [];
-    const globalDescs = Array.from(this.indexManager.allElements(refType));
-    const protectedNamespaces = this.protectedNamespacesFor(contextNode, globalDescs);
+    const globalDescs = this.globalIndex(refType);
     const options = {
       nodeOf: this.nodeOf.bind(this),
       protectedNamespaceKeys: protectedNamespaces.keys,
@@ -64652,6 +65112,10 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
     }
     return dedupeDescriptions(result);
   }
+  // REQ-268 — One index over the global symbol table per reference type.
+  globalIndex(refType) {
+    return this.globalIndexCache.get(refType, () => new GlobalDescriptionIndex(Array.from(this.indexManager.allElements(refType))));
+  }
   // REQ-067, REQ-068, REQ-069, REQ-323 — Expand import forms and visibility re-exports
   expandImport(imp, globalDescs, out, options) {
     for (const entry of expandImportEntries(imp, globalDescs, options)) {
@@ -64677,6 +65141,16 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
     }
     return imports;
   }
+  // REQ-060, REQ-068 — The namespaces a context specializes (transitively) that
+  // re-export their `protected` imports to it.
+  //
+  // REQ-268 — Only a namespace that actually OWNS a protected import can change
+  // an expansion: `expandNamespaceImports` consults the key set for exactly that
+  // case, and the re-export loop iterates exactly those members. Namespaces
+  // without one are therefore dropped here rather than carried into the cache
+  // key, so the common model — where nothing is imported `protected` — resolves
+  // every reference against one cached expansion instead of one per specializing
+  // element.
   protectedNamespacesFor(contextNode, globalDescs) {
     const keys3 = /* @__PURE__ */ new Set();
     const nodes = [];
@@ -64688,7 +65162,7 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
       }
       cur = cur.$container;
     }
-    return { keys: keys3, nodes };
+    return { keys: keys3, nodes, key: keys3.size === 0 ? "" : [...keys3].sort().join(" ") };
   }
   collectProtectedNamespace(targetName, globalDescs, keys3, nodes, visitedTargets) {
     if (visitedTargets.has(targetName))
@@ -64698,26 +65172,43 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
     if (!desc)
       return;
     const key = descriptionKey(desc);
-    const wasNew = !keys3.has(key);
-    keys3.add(key);
     const node = this.nodeOf(desc);
     if (!node)
       return;
-    if (wasNew)
+    if (ownsProtectedImport(node) && !keys3.has(key)) {
+      keys3.add(key);
       nodes.push(node);
+    }
     for (const inherited of specializationTargets3(node)) {
       this.collectProtectedNamespace(inherited, globalDescs, keys3, nodes, visitedTargets);
     }
   }
-  importContextKey(contextNode) {
+  // REQ-268 — The cache key for a context's import expansion.
+  //
+  // The expansion is a pure function of exactly two things: the imports visible
+  // from the context (innermost namespace outwards) and the protected-import
+  // re-exports its specializations open up. Every import resolves its path
+  // against the GLOBAL symbol table, so an import expands to the same members
+  // wherever it is written; two contexts that see the same import text in the
+  // same order, under the same protected re-exports, get the same result.
+  //
+  // Keying on those inputs rather than on the nearest enclosing namespace NODE
+  // is what makes the cache useful: a model file has one or two distinct import
+  // sets but hundreds of namespace nodes, so the node key missed on nearly
+  // every reference and re-expanded the whole standard library each time
+  // (measured on a 1 500-line model: 226 misses over 349 references, 16 s).
+  importContextKey(contextNode, protectedNamespaces) {
+    const parts = [];
     let cur = contextNode;
     while (cur) {
-      if (isDocument(cur) || namespaceMembers(cur).length > 0 || specializationTargets3(cur).length > 0) {
-        return this.nodeKey(cur);
+      for (const member of namespaceMembers(cur)) {
+        if (isImport(member))
+          parts.push(importSignature(member));
       }
       cur = cur.$container;
     }
-    return "root";
+    const imports = parts.length > 0 ? parts.join(" ") : "root";
+    return protectedNamespaces.key ? `${imports} ${protectedNamespaces.key}` : imports;
   }
   nodeOf(desc) {
     if (desc.node)
@@ -64728,16 +65219,23 @@ var SysmlScopeProvider = class extends DefaultScopeProvider {
       return void 0;
     return this.astNodeLocator.getAstNode(root3, desc.path);
   }
-  nodeKey(node) {
-    return `${ast_utils_exports.getDocument(node).uri.toString()}#${this.astNodeLocator.getAstNodePath(node)}`;
-  }
 };
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+function ownsProtectedImport(node) {
+  return namespaceMembers(node).some((member) => isImport(member) && importVisibility(member) === "protected");
+}
+function importSignature(imp) {
+  const text = imp.$cstNode?.text;
+  if (text)
+    return text;
+  const segments = imp.segs.map((seg) => `${seg.name ?? ""}${seg.star ? "*" : ""}${seg.recursive ? "**" : ""}`);
+  return `${importVisibility(imp)} ${imp.head}::${segments.join("::")}${imp.alias ? ` as ${imp.alias}` : ""}`;
+}
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets3(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS3.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS4.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -64797,20 +65295,21 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
     const imports = Array.from(ast_utils_exports.streamAllContents(root3)).filter(isImport).filter((imp) => importVisibility(imp) === "public");
     if (imports.length === 0)
       return;
-    const physicalExports = [...exports2];
+    const physicalAliases = aliasesByNode(exports2);
     const ownerAliases = /* @__PURE__ */ new Map();
     for (const imp of imports) {
       const owner = imp.$container;
-      ownerAliases.set(imp, owner ? physicalExports.filter((desc) => desc.node === owner && !desc.name.includes(".")).map((desc) => desc.name) : []);
+      ownerAliases.set(imp, owner && physicalAliases.get(owner) || []);
     }
     const seen = new Set(exports2.map(exportAliasKey));
     for (let pass = 0; pass < imports.length + 1; pass++) {
       let changed = false;
+      const indexed = new GlobalDescriptionIndex(exports2);
       for (const imp of imports) {
         const aliases = ownerAliases.get(imp) ?? [];
         if (aliases.length === 0)
           continue;
-        for (const entry of directImportEntries(imp, exports2)) {
+        for (const entry of directImportEntries(imp, indexed)) {
           for (const ownerAlias of aliases) {
             const description = {
               ...entry.description,
@@ -64835,28 +65334,23 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
   // where Country owns Life). Materialize those same-document aliases so the
   // linker can resolve the qualified spelling without a full type evaluator.
   addInheritedQualifiedAliases(root3, exports2) {
-    const physicalExports = [...exports2];
     const seen = new Set(exports2.map(exportAliasKey));
-    const nodes = Array.from(ast_utils_exports.streamAllContents(root3));
-    const ownerAliases = /* @__PURE__ */ new Map();
-    for (const node of nodes) {
-      ownerAliases.set(node, physicalExports.filter((desc) => desc.node === node && !desc.name.includes(".")).map((desc) => desc.name));
-    }
+    const nodes = Array.from(ast_utils_exports.streamAllContents(root3)).filter((node) => specializationTargets4(node).length > 0);
+    if (nodes.length === 0)
+      return;
+    const ownerAliases = aliasesByNode(exports2);
     for (let pass = 0; pass < nodes.length; pass++) {
-      const sourceDescriptions = [...exports2];
+      const sourceDescriptions = new GlobalDescriptionIndex(exports2);
       const additions = [];
       for (const node of nodes) {
         const targets = specializationTargets4(node);
-        if (targets.length === 0)
-          continue;
         const aliases = ownerAliases.get(node) ?? [];
+        if (aliases.length === 0)
+          continue;
         for (const target of targets) {
-          for (const inherited of sourceDescriptions) {
-            const prefix = `${target}::`;
-            if (!inherited.name.startsWith(prefix))
-              continue;
-            const suffix = inherited.name.slice(prefix.length);
-            if (!suffix || suffix.includes("::"))
+          for (const inherited of sourceDescriptions.membersOf(target, "shallow")) {
+            const suffix = inherited.name.slice(target.length + 2);
+            if (!suffix)
               continue;
             for (const ownerAlias of aliases) {
               const description = {
@@ -64974,28 +65468,38 @@ function nodeVisibility(node) {
 function exportAliasKey(description) {
   return `${description.name}|${description.documentUri.toString()}|${description.path}`;
 }
+function aliasesByNode(exports2) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const desc of exports2) {
+    if (!desc.node || desc.name.includes("."))
+      continue;
+    const names = byNode.get(desc.node);
+    if (names)
+      names.push(desc.name);
+    else
+      byNode.set(desc.node, [desc.name]);
+  }
+  return byNode;
+}
 function directImportEntries(imp, descriptions) {
   const path10 = importedPath(imp);
   if (!path10)
     return [];
   const wildcard = importWildcard(imp);
   if (wildcard === "none") {
-    const description = descriptions.find((candidate) => candidate.name === path10);
+    const description = descriptions.firstNamed(path10);
     if (!description)
       return [];
     return [{ name: imp.alias ?? path10.split("::").pop() ?? path10, description }];
   }
-  const prefix = `${path10}::`;
   const entries = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const description of descriptions) {
-    if (!description.name.startsWith(prefix))
-      continue;
+  for (const description of descriptions.membersOf(path10, wildcard)) {
     const visibility = description;
     if (visibility.isPrivate || visibility.visibility === "private")
       continue;
-    const rest = description.name.slice(prefix.length);
-    if (!rest || wildcard === "shallow" && rest.includes("::"))
+    const rest = description.name.slice(path10.length + 2);
+    if (!rest)
       continue;
     const name = rest.split("::").pop();
     if (!name)
@@ -65008,12 +65512,12 @@ function directImportEntries(imp, descriptions) {
   }
   return entries;
 }
-var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets4(node) {
   const value = node;
   const targets = [];
   for (const relationship of [...value.preRelationships ?? [], ...value.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS4.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS5.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -65062,43 +65566,6 @@ var SysmlLinker = class extends DefaultLinker {
   }
 };
 
-// ../language-server/out/src/services/escaped-name.js
-function decodeEscapes(body) {
-  return body.replace(/\\(.)/gu, (_m, ch) => {
-    switch (ch) {
-      case "n":
-        return "\n";
-      case "t":
-        return "	";
-      case "b":
-        return "\b";
-      case "f":
-        return "\f";
-      default:
-        return ch;
-    }
-  });
-}
-function canonicalEscapedName(token) {
-  if (token.length < 2 || !token.startsWith("'") || !token.endsWith("'"))
-    return token;
-  return "'" + decodeEscapes(token.slice(1, -1)) + "'";
-}
-function decodeUnrestrictedName(token) {
-  if (token.length >= 2 && token.startsWith("'") && token.endsWith("'")) {
-    return decodeEscapes(token.slice(1, -1));
-  }
-  return token;
-}
-var BARE_ID = /^[_a-zA-Z]\w*$/u;
-function encodeUnrestrictedName(value) {
-  const raw = value.length >= 2 && value.startsWith("'") && value.endsWith("'") ? decodeUnrestrictedName(value) : value;
-  if (BARE_ID.test(raw))
-    return raw;
-  const escaped = raw.replace(/\r\n?/gu, "\n").replace(/[\\']/gu, (ch) => `\\${ch}`).replace(/\n/gu, "\\n").replace(/\t/gu, "\\t").replace(/[\f]/gu, "\\f").replace(/[\b]/gu, "\\b");
-  return `'${escaped}'`;
-}
-
 // ../language-server/out/src/services/rename-provider.js
 var SysmlRenameProvider = class extends DefaultRenameProvider {
   langiumDocuments;
@@ -65228,7 +65695,7 @@ var SysmlCodeActionProvider = class {
           }
         });
       }
-      if (code === "RES001") {
+      if (code === "RES001" && !(typeof diagnostic.data === "object" && diagnostic.data !== null && diagnostic.data.featurePathSegment === true)) {
         const start = diagnostic.range.start;
         const end = diagnostic.range.end;
         const name = document.textDocument.getText({ start, end });
@@ -66039,7 +66506,7 @@ function multiplicityAnchor(node) {
 function allAstNodes(root3) {
   return [root3, ...ast_utils_exports.streamAllContents(root3).toArray()];
 }
-function lastSegment2(name) {
+function lastSegment3(name) {
   const idx = name.lastIndexOf("::");
   return (idx >= 0 ? name.slice(idx + 2) : name).replace(/^'(.*)'$/u, "$1");
 }
@@ -66062,7 +66529,7 @@ function typeAnchor(node, refText) {
   const cst = node.$cstNode;
   if (!cst)
     return void 0;
-  const target = lastSegment2(refText);
+  const target = lastSegment3(refText);
   const leaves = cst_utils_exports.flattenCst(cst).toArray();
   for (let index = leaves.length - 1; index >= 0; index--) {
     const leaf = leaves[index];
@@ -66476,7 +66943,7 @@ function indexByName(root3, type) {
   });
   return map3;
 }
-function lastSegment3(path10) {
+function lastSegment4(path10) {
   if (!path10)
     return void 0;
   return path10.split(/::|\./).pop();
@@ -66495,17 +66962,6 @@ function qualifiedNameOf2(node) {
 function isDiagramAnchor(node) {
   return isPackage(node) || isPartDecl(node) || isStateDecl(node) || isExhibitStateDecl(node) || isActionDecl(node) || isOccurrenceDecl(node) || isUseCaseDecl(node) || isVerificationCaseDecl(node);
 }
-function hasDiagrammableContent(root3) {
-  let found = false;
-  walkAst(root3, (n) => {
-    if (found)
-      return;
-    const name = n.name;
-    if (typeof name === "string" && name.length > 0)
-      found = true;
-  });
-  return found;
-}
 function naturalKindFor(node) {
   if (node.isDef)
     return void 0;
@@ -66552,20 +67008,6 @@ var SysmlCodeLensProvider = class {
       return void 0;
     const lenses = [];
     const uri = document.uri.toString();
-    if (hasDiagrammableContent(root3)) {
-      const firstLine = {
-        start: { line: 0, character: 0 },
-        end: { line: 0, character: 0 }
-      };
-      lenses.push({
-        range: firstLine,
-        command: {
-          title: "$(graph) Show all diagrams",
-          command: "sysml.preview.showDiagram",
-          arguments: [uri]
-        }
-      });
-    }
     const requirements = indexByName(root3, "RequirementDecl");
     const parts = indexByName(root3, "PartDecl");
     walkAst(root3, (node) => {
@@ -66574,7 +67016,7 @@ var SysmlCodeLensProvider = class {
         return;
       const range = cst.range;
       if (isSatisfyStmt(node)) {
-        const reqName = lastSegment3(node.target);
+        const reqName = lastSegment4(node.target);
         const req = reqName ? requirements.get(reqName) : void 0;
         if (req) {
           const bound = bindingName(node.by);
@@ -66677,11 +67119,24 @@ var SysmlDocumentHighlightProvider = class {
 var import_vscode_languageserver22 = __toESM(require_main4(), 1);
 var SysmlDefinitionProvider = class extends DefaultDefinitionProvider {
   indexManager;
+  featurePaths;
   constructor(services) {
     super(services);
     this.indexManager = services.shared.workspace.IndexManager;
+    this.featurePaths = new FeaturePathResolver(services);
   }
   collectLocationLinks(sourceCstNode, params) {
+    if (isPathExpr(sourceCstNode.astNode)) {
+      const resolution = this.featurePaths.resolve(sourceCstNode.astNode);
+      const segment = resolution.segments.find((candidate) => candidate.cst.offset <= sourceCstNode.offset && candidate.cst.end >= sourceCstNode.end);
+      if (segment?.description) {
+        const link2 = this.linkFromDescription(segment.description, segment.cst);
+        if (link2)
+          return [link2];
+      }
+      if (segment)
+        return void 0;
+    }
     const referenced = this.references.findDeclaration(sourceCstNode);
     if (referenced && isAliasDecl(referenced)) {
       const followed = this.resolveAliasTarget(referenced);
@@ -66816,7 +67271,7 @@ var SysmlDeclarationProvider = class {
 
 // ../language-server/out/src/services/references-provider.js
 var import_vscode_languageserver24 = __toESM(require_main4(), 1);
-function lastSegment4(qualified) {
+function lastSegment5(qualified) {
   return qualified.split(/::|\./u).pop() ?? qualified;
 }
 function locationKey(uri, cst) {
@@ -66838,7 +67293,7 @@ var SysmlReferencesProvider = class extends DefaultReferencesProvider {
     const targetNames = this.namesOf(targetNode);
     if (targetNames.size === 0)
       return base;
-    const targetSimpleNames = new Set([...targetNames].map(lastSegment4));
+    const targetSimpleNames = new Set([...targetNames].map(lastSegment5));
     const seen = /* @__PURE__ */ new Set();
     const out = [];
     for (const location of base) {
@@ -66880,7 +67335,7 @@ var SysmlReferencesProvider = class extends DefaultReferencesProvider {
     }
     const names = this.namesOf(targetNode);
     if (names.size > 0) {
-      const simpleNames = new Set([...names].map(lastSegment4));
+      const simpleNames = new Set([...names].map(lastSegment5));
       for (const doc of this.langiumDocuments.all) {
         const root3 = doc.parseResult?.value;
         if (!root3)
@@ -66919,7 +67374,7 @@ var SysmlReferencesProvider = class extends DefaultReferencesProvider {
   resolveByName(text) {
     if (!text)
       return void 0;
-    const simple = lastSegment4(text);
+    const simple = lastSegment5(text);
     const all = this.indexManager.allElements().toArray();
     return all.find((d) => d.name === text)?.node ?? all.find((d) => d.name === simple)?.node;
   }
@@ -68439,7 +68894,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.10.18" : "dev";
+var VERSION2 = true ? "0.14.2" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {